@saadnvd1/agent-os 0.3.592 → 0.3.595

package/components/SessionList/SessionShelves.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { ReactNode } from "react";
-import { ChevronDown } from "lucide-react";
+import { ChevronDown, ListTodo, Server, type LucideIcon } from "lucide-react";
 import {
   DONE_PAGE,
   doneLimit,
@@ -16,21 +16,35 @@ import { OrchestratorPinRow, OrchestratorStartRow } from "./OrchestratorPinRow";
 import { QueuedRow } from "./QueuedRow";
 import type { QueuedRow as QueuedRowData } from "@/lib/sidebar/queued";
 
-function ShelfLabel({
+// A shelf's header. Only groups that aren't a state (a machine, the line,
+// terminals) carry an icon; a shelf that asks for you counts in amber.
+export function ShelfLabel({
   label,
   count,
+  icon: Icon,
+  accent = false,
   collapsed,
   onToggle,
 }: {
   label: string;
   count?: number;
+  icon?: LucideIcon;
+  accent?: boolean;
   collapsed?: boolean;
   onToggle?: () => void;
 }) {
   const text = (
     <>
+      {Icon && <Icon aria-hidden className="h-3 w-3 shrink-0" />}
       {label}
-      {count !== undefined && ` · ${count}`}
+      {count !== undefined && (
+        <>
+          {" · "}
+          <span className={cn(accent && "text-amber-600 dark:text-amber-400")}>
+            {count}
+          </span>
+        </>
+      )}
       {onToggle && (
         <ChevronDown
           className={cn(
@@ -63,15 +77,19 @@ function ShelfLabel({
 function Shelf({
   label,
   count,
+  icon,
+  accent,
   children,
 }: {
   label: string;
   count?: number;
+  icon?: LucideIcon;
+  accent?: boolean;
   children: ReactNode;
 }) {
   return (
     <section aria-label={label}>
-      <ShelfLabel label={label} count={count} />
+      <ShelfLabel label={label} count={count} icon={icon} accent={accent} />
       {children}
     </section>
   );
@@ -80,9 +98,9 @@ function Shelf({
 // A linked machine's sessions no project here holds, under its name.
 export function MachineShelves({ groups }: { groups: MachineGroup[] }) {
   return groups.map((g) => (
-    <Shelf key={g.hostId} label={g.name} count={g.rows.length}>
+    <Shelf key={g.hostId} label={g.name} count={g.rows.length} icon={Server}>
       {g.rows.map((r) => (
-        <SessionRow key={r.session.id} row={r} />
+        <SessionRow key={r.session.id} row={r} inMachineShelf />
       ))}
     </Shelf>
   ));
@@ -108,6 +126,17 @@ export function SessionShelves({
   const shown = shelves.done.slice(0, doneLimit(donePages));
   const hidden = shelves.done.length - shown.length;
   const summary = doneSummary(shelves.done).text;
+  // Live work above, what's resting below a hairline.
+  const live =
+    shelves.orchestrators.length +
+      toStart.length +
+      shelves.pinned.length +
+      shelves.needsYou.length +
+      shelves.working.length +
+      shelves.inReview.length +
+      queued.length +
+      shelves.ongoing.length >
+    0;
   return (
     <>
       {shelves.orchestrators.length + toStart.length > 0 && (
@@ -128,7 +157,7 @@ export function SessionShelves({
         </Shelf>
       )}
       {shelves.needsYou.length > 0 && (
-        <Shelf label="Needs you" count={shelves.needsYou.length}>
+        <Shelf label="Needs you" count={shelves.needsYou.length} accent>
           {shelves.needsYou.map((r) => (
             <SessionRow key={r.session.id} row={r} />
           ))}
@@ -149,7 +178,7 @@ export function SessionShelves({
         </Shelf>
       )}
       {queued.length > 0 && (
-        <Shelf label="Queued" count={queued.length}>
+        <Shelf label="Queued" count={queued.length} icon={ListTodo}>
           {queued.map((r) => (
             <QueuedRow key={r.item.id} row={r} />
           ))}
@@ -162,6 +191,9 @@ export function SessionShelves({
           ))}
         </Shelf>
       )}
+      {live && shelves.snoozed.length + shelves.done.length > 0 && (
+        <div aria-hidden className="border-border mx-2.5 mt-2.5 border-t" />
+      )}
       {shelves.snoozed.length > 0 && (
         <section aria-label="Snoozed">
           <ShelfLabel

package/components/SessionList/SidebarExtras.tsx

@@ -4,7 +4,9 @@ import { DevServerCard } from "@/components/DevServers/DevServerCard";
 import { ElsewhereTmuxList, TmuxSessionRow } from "@/components/Hosts";
 import { useDevServersQuery } from "@/data/dev-servers";
 import { useDiscoveredTmuxQuery } from "@/data/hosts";
+import { SquareTerminal } from "lucide-react";
 import type { ProjectWithRepositories } from "@/lib/projects";
+import { ShelfLabel } from "./SessionShelves";
 
 interface DevServerHandlers {
   onStop: (id: string) => Promise<void>;
@@ -58,7 +60,11 @@ export function SidebarExtras({
       )}
       {tmux.length > 0 && (
         <section aria-label="Terminals">
-          <div className={label}>Terminals · {tmux.length}</div>
+          <ShelfLabel
+            label="Terminals"
+            count={tmux.length}
+            icon={SquareTerminal}
+          />
           {tmux.map((t) => (
             <TmuxSessionRow key={`${t.hostId}:${t.name}`} session={t} />
           ))}

package/components/SessionList/index.tsx

@@ -12,6 +12,7 @@ import type { OrchestratorOverview } from "@/lib/orchestrator/overview";
 import { useSessionListMutations } from "./hooks/useSessionListMutations";
 import { useBulkDelete } from "./hooks/useBulkDelete";
 import { useSidebarData } from "./useSidebarData";
+import { useSessionTips } from "./useSessionTips";
 import { RowProvider, type RowContextValue } from "./RowContext";
 import { SidebarHeader } from "./SidebarHeader";
 import { useAddProject } from "@/components/Projects/AddProject/useAddProject";
@@ -43,6 +44,7 @@ export function SessionList({
   pinControls,
 }: SessionListProps) {
   const data = useSidebarData(sessionStatuses);
+  useSessionTips(data);
   const { shelves, ui, project } = data;
   const mutations = useSessionListMutations({ onSelectSession: onSelect });
   const bulkDelete = useBulkDelete();

package/components/SessionList/useDoneAction.ts

@@ -3,6 +3,7 @@ import type { Session } from "@/lib/db";
 import {
   useArchiveSession,
   useDoneSession,
+  useResurrectSession,
   useUnarchiveSession,
 } from "@/data/done";
 import { useSettleSession } from "@/data/sessions/shelf";
@@ -68,3 +69,16 @@ export function useArchiveAction() {
       onError: (e) => toast.error(e.message, { duration: 12000 }),
     });
 }
+
+// Restore from a session's menu: the same conversation, its worktree back.
+export function useResurrectAction() {
+  const resurrect = useResurrectSession();
+  return (session: Session) => {
+    const id = toast.loading(`Restoring ${session.name}…`);
+    resurrect.mutate(session.id, {
+      onSuccess: (outcome) =>
+        toast.success(outcome.text, { id, duration: 8000 }),
+      onError: (e) => toast.error(e.message, { id, duration: 12000 }),
+    });
+  };
+}

package/components/SessionList/useResurrectAction.test.ts

@@ -0,0 +1,96 @@
+import "@/components/Chat/composer/test-dom";
+import { act, createElement, useEffect } 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 type { Session } from "@/lib/db/types";
+
+const toast = vi.hoisted(() =>
+  Object.assign(vi.fn(), {
+    loading: vi.fn(() => "t1"),
+    success: vi.fn(),
+    error: vi.fn(),
+  })
+);
+vi.mock("sonner", () => ({ toast }));
+
+const { useResurrectAction } = await import("./useDoneAction");
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let root: Root;
+let host: HTMLElement;
+const hook: { current: (s: Session) => void } = { current: () => {} };
+const fetchSpy = vi.fn();
+
+function Probe() {
+  const restore = useResurrectAction();
+  useEffect(() => {
+    hook.current = restore;
+  });
+  return null;
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal("fetch", fetchSpy);
+  host = document.createElement("div");
+  document.body.append(host);
+  root = createRoot(host);
+  act(() =>
+    root.render(
+      createElement(
+        QueryClientProvider,
+        { client: new QueryClient() },
+        createElement(Probe)
+      )
+    )
+  );
+});
+afterEach(() => {
+  act(() => root.unmount());
+  host.remove();
+  vi.unstubAllGlobals();
+});
+
+const task = {
+  id: "s1",
+  name: "Bookmark plan",
+  task_status: "done",
+} as Session;
+const respond = (status: number, body: object) =>
+  fetchSpy.mockResolvedValue({
+    ok: status < 400,
+    status,
+    json: async () => body,
+  });
+const restore = async () => {
+  await act(async () => {
+    hook.current(task);
+    await new Promise((r) => setTimeout(r, 0));
+  });
+};
+
+describe("Restore from a session's menu", () => {
+  it("posts to the resurrect route and shows what came back", async () => {
+    respond(200, { outcome: { text: "Bookmark plan is back" } });
+    await restore();
+    expect(fetchSpy.mock.calls[0][0]).toBe("/api/sessions/s1/resurrect");
+    expect(fetchSpy.mock.calls[0][1]).toMatchObject({ method: "POST" });
+    expect(toast.success).toHaveBeenCalledWith(
+      "Bookmark plan is back",
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+
+  it("shows a refusal's reason", async () => {
+    respond(409, { error: "its PR #3 was merged" });
+    await restore();
+    expect(toast.error).toHaveBeenCalledWith(
+      "its PR #3 was merged",
+      expect.objectContaining({ id: "t1" })
+    );
+  });
+});

package/components/SessionList/useSessionTips.ts

@@ -0,0 +1,62 @@
+"use client";
+
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { useHostNames } from "@/data/hosts";
+import type { SidebarRow } from "@/lib/sidebar/shelves";
+import type { SidebarData } from "./useSidebarData";
+
+function find(rows: readonly SidebarRow[], id: string): SidebarRow | null {
+  for (const row of rows) {
+    if (row.session.id === id) return row;
+    const nested = find(row.workers, id) ?? find(row.quick ?? [], id);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+// A session row's hover tip, built from the latest list only when it
+// opens: nothing runs per row, and registering never re-renders.
+export function useSessionTips(data: SidebarData) {
+  const hostNames = useHostNames();
+  const latest = useRef({ data, hostNames });
+  useLayoutEffect(() => {
+    latest.current = { data, hostNames };
+  });
+  // Loaded after the page, like the tip itself: no first-load cost.
+  useEffect(() => {
+    let off: (() => void) | undefined;
+    let gone = false;
+    Promise.all([
+      import("@/lib/hover-tip"),
+      import("@/lib/sidebar/row-details"),
+    ]).then(([{ registerTip }, { rowDetails }]) => {
+      if (gone) return;
+      off = registerTip("session", (id) => {
+        const { data, hostNames } = latest.current;
+        const row = find(
+          [
+            ...Object.values(data.shelves).flat(),
+            ...data.machines.flatMap((g) => g.rows),
+          ],
+          id
+        );
+        if (!row) return null;
+        const s = row.session;
+        return rowDetails(row, {
+          project: data.projectNames.get(s.project_id ?? ""),
+          startedBy: s.started_by
+            ? data.orchestratorNames.get(s.started_by)
+            : undefined,
+          host:
+            s.host_id && s.host_id !== "local"
+              ? hostNames[s.host_id] || "remote"
+              : undefined,
+        });
+      });
+    });
+    return () => {
+      gone = true;
+      off?.();
+    };
+  }, []);
+}

package/components/Tasks/TaskRow.tsx

@@ -5,6 +5,7 @@ import {
   ChefHat,
   ExternalLink,
   GitMerge,
+  RotateCcw,
   KanbanSquare,
   SquareTerminal,
 } from "lucide-react";
@@ -12,6 +13,7 @@ import { Button } from "@/components/ui/button";
 import type { TaskView } from "@/lib/tasks";
 import { isFinished } from "@/lib/tasks/state";
 import { useArmTask, useDropTask, useSignOffTask } from "@/data/tasks";
+import { useResurrectSession } from "@/data/done";
 import { tmuxAttachActions } from "@/stores/tmuxAttach";
 import { tasksUiActions } from "@/stores/tasksUi";
 import { recipesUiActions } from "@/stores/recipesUi";
@@ -27,6 +29,7 @@ export function TaskRow({ task }: { task: TaskView }) {
   const signOff = useSignOffTask();
   const drop = useDropTask();
   const arm = useArmTask();
+  const restore = useResurrectSession();
   const [confirmDrop, setConfirmDrop] = useState(false);
   const [moveError, setMoveError] = useState<string | null>(null);
   const live = !isFinished(task.state);
@@ -34,6 +37,7 @@ export function TaskRow({ task }: { task: TaskView }) {
     signOff.error?.message ||
     drop.error?.message ||
     arm.error?.message ||
+    restore.error?.message ||
     moveError ||
     task.hostError;
   const settingUp = live && task.setup?.status === "running";
@@ -165,6 +169,20 @@ export function TaskRow({ task }: { task: TaskView }) {
         </div>
       )}
       {live && task.state === "plan-ready" && <PlanReview task={task} />}
+      {!live && task.state !== "merged" && (
+        <div>
+          <Button
+            size="sm"
+            variant="outline"
+            className="h-11 md:h-8"
+            disabled={restore.isPending}
+            onClick={() => restore.mutate(task.id)}
+          >
+            <RotateCcw className="h-3.5 w-3.5" />
+            {restore.isPending ? "Restoring..." : "Restore"}
+          </Button>
+        </div>
+      )}
       {!live && !task.hostId && (
         <div>
           <Button

package/components/ui/HoverTip.tsx

@@ -0,0 +1,20 @@
+"use client";
+
+import { useEffect } from "react";
+
+// Mounted once: the app's single hover tooltip (lib/hover-tip.ts), loaded
+// after the page so it costs the first load nothing.
+export function HoverTip() {
+  useEffect(() => {
+    let off: (() => void) | undefined;
+    let gone = false;
+    import("@/lib/hover-tip").then(({ installHoverTip }) => {
+      if (!gone) off = installHoverTip();
+    });
+    return () => {
+      gone = true;
+      off?.();
+    };
+  }, []);
+  return null;
+}

package/data/done/index.ts

@@ -2,6 +2,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { DoneOutcome } from "@/lib/done";
 import type { BulkResult, PreviewRow } from "@/lib/done/bulk";
 import type { ArchivedView } from "@/lib/done/archive";
+import type { ResurrectOutcome } from "@/lib/resurrect";
 import { sessionKeys } from "../sessions/keys";
 import { taskKeys } from "../tasks";
 
@@ -90,6 +91,22 @@ export function useUnarchiveSession() {
   );
 }
 
+// Brings a dropped, done or archived session back (lib/resurrect).
+export function useResurrectSession() {
+  return useDoneMutation(
+    async (id: string) =>
+      (
+        await json<{ outcome: ResurrectOutcome }>(
+          await post(
+            `/api/sessions/${id}/resurrect`,
+            undefined,
+            DONE_REQUEST_TIMEOUT_MS
+          )
+        )
+      ).outcome
+  );
+}
+
 export function useArchivedQuery(workspaceId?: string, enabled = true) {
   return useQuery({
     queryKey: archivedKeys.list(workspaceId),

package/data/presence/index.ts

@@ -1,7 +1,3 @@
-import {
-  startAuthentication,
-  startRegistration,
-} from "@simplewebauthn/browser";
 import type {
   AuthenticationResponseJSON,
   PublicKeyCredentialCreationOptionsJSON,
@@ -30,12 +26,20 @@ export const passkeysHere = () =>
 export const NO_PASSKEYS_HERE =
   "Approving this needs a passkey, and passkeys need https or localhost: approve it on the machine running AgentOS, or over Connect.";
 
+// The passkey library loads only when a passkey is used, fetched alongside
+// the server's options so the prompt waits on nothing extra.
+const webauthn = () => import("@simplewebauthn/browser");
+
 // Adds a passkey on this browser: free for the very first one, otherwise
 // with a code from a device that has one.
 export async function registerPasskey(enrollCode?: string): Promise<void> {
-  const { options } = await post<{
-    options: PublicKeyCredentialCreationOptionsJSON;
-  }>("/api/presence/register/options", { enrollCode });
+  const [{ startRegistration }, { options }] = await Promise.all([
+    webauthn(),
+    post<{ options: PublicKeyCredentialCreationOptionsJSON }>(
+      "/api/presence/register/options",
+      { enrollCode }
+    ),
+  ]);
   const response = await startRegistration({ optionsJSON: options });
   await post("/api/presence/register/verify", { response, enrollCode });
 }
@@ -55,6 +59,8 @@ export async function provePresence(req: {
     needsPasskey?: boolean;
     canBootstrap?: boolean;
   };
+  const lib = webauthn();
+  lib.catch(() => {}); // awaited below; an early throw mustn't leave it unhandled
   let answer = await post<Answer>("/api/presence/options", req);
   if (answer.needsPasskey) {
     if (!answer.canBootstrap)
@@ -65,5 +71,6 @@ export async function provePresence(req: {
     answer = await post<Answer>("/api/presence/options", req);
   }
   if (!answer.options) throw new Error("No passkey for this host");
+  const { startAuthentication } = await lib;
   return startAuthentication({ optionsJSON: answer.options });
 }

package/lib/db/migrations.ts

@@ -2298,6 +2298,17 @@ export const migrations: Migration[] = [
       `);
     },
   },
+  {
+    key: "20261014T1900_pause_note",
+    up: (db) => {
+      // Why a resume that was asked for hasn't happened yet (waiting for a
+      // slot, held by load), shown on the task row. Additive.
+      const has = (
+        db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+      ).some((c) => c.name === "pause_note");
+      if (!has) db.exec(`ALTER TABLE sessions ADD COLUMN pause_note TEXT`);
+    },
+  },
   {
     key: "20261014T2000_chat_bookmarks",
     up: (db) => {

package/lib/db/types.ts

@@ -92,6 +92,8 @@ export interface Session {
   pause_state?: "pausing" | "paused" | "resuming" | null;
   paused_until?: string | null;
   pause_id?: number | null;
+  // Why a requested resume hasn't happened yet.
+  pause_note?: string | null;
   placed_note?: string | null;
   // Set by done: hidden from the sidebar and the orchestrator, never deleted.
   archived_at: string | null;

package/lib/done/worktree.ts

@@ -13,6 +13,7 @@ import { getProject } from "../projects";
 import { deleteWorktree, isAgentOSWorktree } from "../worktrees";
 import { removalRunning, removalSettled } from "../worktree-removal";
 import { describeChanges, unsavedChanges } from "../worktree-placed";
+import { dropSnapshot, snapshotWorktree } from "../resurrect/snapshot";
 
 export type WorktreeFate =
   | { action: "none" }
@@ -100,7 +101,7 @@ export type FatePreview =
   | { action: "remove"; why: string; repo: string };
 
 type Judged = Pick<Session, "worktree_path" | "base_branch"> &
-  Partial<Pick<Session, "project_id">>;
+  Partial<Pick<Session, "project_id" | "id">>;
 
 // Gone, or still going: removed by whatever else got to it first.
 const gone = (merged: MergedAs | null, still = false) => ({
@@ -215,8 +216,23 @@ export async function settleWorktree(
   merged: MergedAs | null,
   movedAway = false
 ): Promise<WorktreeFate> {
+  // Unmerged work is saved for a restore while the fate is judged, and kept
+  // only if the worktree is really removed.
+  const snapshot =
+    !merged && !movedAway && session.id && session.worktree_path
+      ? snapshotWorktree(session.worktree_path, session.id)
+      : null;
   const fate = await worktreeFate(session, merged, undefined, movedAway);
-  if (fate.action !== "remove") return fate;
+  if (fate.action !== "remove") {
+    if (snapshot && fate.action === "kept") {
+      const { path } = fate;
+      void snapshot.then((made) => {
+        if (made) void dropSnapshot(path, session.id!);
+      });
+    }
+    return fate;
+  }
+  await snapshot;
   const path = session.worktree_path!;
   await deleteWorktree(path, fate.repo, true).catch(() => {});
   if (fs.existsSync(path))