@saadnvd1/agent-os 0.3.543 → 0.3.544

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

@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { reopenSession, settleSession } from "@/lib/sidebar/shelf-state";
+
+// POST /api/sessions/:id/settle { settled } - Mark done (true) or Reopen
+// (false). Not an archive: new activity brings a settled session back.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = (await request.json().catch(() => null)) as {
+    settled?: unknown;
+  } | null;
+  if (typeof body?.settled !== "boolean")
+    return NextResponse.json(
+      { error: "settled must be a boolean" },
+      { status: 400 }
+    );
+  if (!(body.settled ? settleSession(id) : reopenSession(id)))
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  return NextResponse.json({ ok: true });
+}

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

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server";
+import {
+  SNOOZE_MAX_MS,
+  snoozeSession,
+  unsnoozeSession,
+} from "@/lib/sidebar/shelf-state";
+
+// POST /api/sessions/:id/snooze { until } - hold it on Snoozed until that
+// ISO time (the reader's own 9am, worked out on their device); null wakes it.
+export async function POST(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = (await request.json().catch(() => null)) as {
+    until?: unknown;
+  } | null;
+  if (body?.until === undefined)
+    return NextResponse.json({ error: "until is required" }, { status: 400 });
+  let ok: boolean;
+  if (body.until === null) ok = unsnoozeSession(id);
+  else {
+    const at =
+      typeof body.until === "string" ? new Date(body.until) : new Date(NaN);
+    const ahead = at.getTime() - Date.now();
+    if (Number.isNaN(ahead) || ahead < -60_000 || ahead > SNOOZE_MAX_MS)
+      return NextResponse.json(
+        { error: "until must be a time within the next 60 days" },
+        { status: 400 }
+      );
+    ok = snoozeSession(id, at);
+  }
+  if (!ok)
+    return NextResponse.json({ error: "Session not found" }, { status: 404 });
+  return NextResponse.json({ ok: true });
+}

package/components/SessionList/OrchestratorPinRow.test.ts

@@ -103,6 +103,7 @@ describe("OrchestratorPinRow", () => {
               need: null,
               unread,
               working: false,
+              activeAt: 0,
               workers: [],
             },
           })

package/components/SessionList/SessionRow.tsx

@@ -2,8 +2,15 @@
 
 import { memo, useState } from "react";
 import { useSnapshot } from "valtio";
-import { CheckSquare, GitFork, Square, Workflow } from "lucide-react";
-import { compactTimeAgo, fromSqliteTime } from "@/lib/session-meta";
+import {
+  AlarmClock,
+  CheckSquare,
+  GitFork,
+  Square,
+  Workflow,
+} from "lucide-react";
+import { compactTimeAgo } from "@/lib/session-meta";
+import { wakeLabel } from "@/lib/sidebar/snooze";
 import { sameRow, type SidebarRow } from "@/lib/sidebar/shelves";
 import { useMinuteTick } from "@/hooks/useMinuteTick";
 import { selectionStore, selectionActions } from "@/stores/sessionSelection";
@@ -55,6 +62,7 @@ export const SessionRow = memo(function SessionRow({
   const menu = (kind: RowMenuKind) => (
     <SessionRowMenu
       session={session}
+      row={row}
       kind={kind}
       onRename={() => setRenaming(true)}
     />
@@ -96,7 +104,7 @@ export const SessionRow = memo(function SessionRow({
         trailing={
           <>
             <RowBadge row={row} />
-            {!row.need && <TimeAgo at={session.updated_at} />}
+            {!row.need && <RowTime row={row} />}
           </>
         }
         menu={menu}
@@ -152,11 +160,19 @@ function sameRowProps(
   return a.muted === b.muted && a.nested === b.nested && sameRow(a.row, b.row);
 }
 
-function TimeAgo({ at }: { at: string }) {
+// Snoozed: when it wakes. Otherwise when it last did something.
+function RowTime({ row }: { row: SidebarRow }) {
   useMinuteTick();
   return (
-    <span className="text-muted-foreground/70 text-xs tabular-nums">
-      {compactTimeAgo(fromSqliteTime(at))}
+    <span className="text-muted-foreground/70 flex items-center gap-1 text-xs tabular-nums">
+      {row.wakesAt ? (
+        <>
+          <AlarmClock aria-hidden className="h-3 w-3" />
+          {wakeLabel(row.wakesAt)}
+        </>
+      ) : (
+        compactTimeAgo(new Date(row.activeAt))
+      )}
     </span>
   );
 }

package/components/SessionList/SessionRowMenu.tsx

@@ -2,6 +2,8 @@
 
 import {
   CheckSquare,
+  AlarmClock,
+  Archive,
   CircleCheck,
   Clock,
   Copy,
@@ -30,6 +32,9 @@ import { schedulesUiActions } from "@/stores/schedulesUi";
 import { recipesUiActions } from "@/stores/recipesUi";
 import { rowGroup } from "@/lib/recipes/chip";
 import { useDoneAction } from "./useDoneAction";
+import { useShelfActions } from "./useShelfActions";
+import { SNOOZE_PRESETS, snoozePreset, wakeLabel } from "@/lib/sidebar/snooze";
+import type { SidebarRow } from "@/lib/sidebar/shelves";
 import { useRowContext } from "./RowContext";
 import { MoveMenuItems } from "@/components/Tasks/MoveMenuItems";
 import { copySessionLink } from "@/hooks/useCopyToClipboard";
@@ -82,15 +87,20 @@ function BlockedItem({ kind, icon: Icon, label, why }: BlockedProps) {
 // The row's ⋯ menu (and right-click menu): everything a session can do.
 export function SessionRowMenu({
   session,
+  row,
   kind,
   onRename,
 }: {
   session: Session;
+  // Where it sits, for Snooze, Mark done and Reopen (not on an orchestrator).
+  row?: SidebarRow;
   kind: keyof typeof PARTS;
   onRename: () => void;
 }) {
   const ctx = useRowContext();
   const markDone = useDoneAction();
+  const shelf = useShelfActions();
+  const plain = !!row && !row.task && !session.task_status;
   const { Item, Separator, Sub, SubTrigger, SubContent } = PARTS[kind];
   const linked = useLinkedHostNames();
   // A linked machine's session: what can't reach it yet shows why.
@@ -291,9 +301,54 @@ export function SessionRowMenu({
       {!session.role && (
         <>
           <Separator />
+          {row?.wakesAt ? (
+            <Item onClick={() => shelf.unsnooze(session)}>
+              <AlarmClock className={icon} />
+              Unsnooze
+            </Item>
+          ) : (
+            !session.pinned &&
+            row && (
+              <Sub>
+                <SubTrigger>
+                  <AlarmClock className={icon} />
+                  Snooze
+                </SubTrigger>
+                <SubContent>
+                  {SNOOZE_PRESETS.map((p) => (
+                    <Item
+                      key={p.key}
+                      onClick={() => shelf.snooze(session, p.key)}
+                    >
+                      {p.label}
+                      <span className="text-muted-foreground ml-3 text-xs">
+                        {wakeLabel(snoozePreset(p.key).getTime())}
+                      </span>
+                    </Item>
+                  ))}
+                </SubContent>
+              </Sub>
+            )
+          )}
+          {plain &&
+            (row.settled ? (
+              <Item onClick={() => shelf.reopen(session)}>
+                <RotateCcw className={icon} />
+                Reopen
+              </Item>
+            ) : (
+              <Item onClick={() => shelf.settle(session)}>
+                <CircleCheck className={icon} />
+                Mark done
+              </Item>
+            ))}
           <Item onClick={() => markDone(session)}>
-            <CircleCheck className={icon} />
-            Done
+            {plain ? (
+              <Archive className={icon} />
+            ) : (
+              <CircleCheck className={icon} />
+            )}
+            {plain ? "Archive" : "Done"}
           </Item>
           <Item
             onClick={() => ctx.onDelete(session.id)}

package/components/SessionList/SessionShelves.tsx

@@ -89,18 +89,20 @@ export function MachineShelves({ groups }: { groups: MachineGroup[] }) {
 }
 
 // The pinned orchestrator (or a row to start one), then Pinned, Needs you,
-// Working, In review, Queued and Done: once for the whole list.
+// Working, In review, Queued, Ongoing, Snoozed and Done: once for the whole list.
 export function SessionShelves({
   shelves,
   queued,
   toStart,
   doneCollapsed,
+  snoozedCollapsed,
   donePages,
 }: {
   shelves: Shelves;
   queued: QueuedRowData[];
   toStart: { workspaceId: string; name: string }[];
   doneCollapsed: boolean;
+  snoozedCollapsed: boolean;
   donePages: number;
 }) {
   const shown = shelves.done.slice(0, doneLimit(donePages));
@@ -153,6 +155,27 @@ export function SessionShelves({
           ))}
         </Shelf>
       )}
+      {shelves.ongoing.length > 0 && (
+        <Shelf label="Ongoing" count={shelves.ongoing.length}>
+          {shelves.ongoing.map((r) => (
+            <SessionRow key={r.session.id} row={r} />
+          ))}
+        </Shelf>
+      )}
+      {shelves.snoozed.length > 0 && (
+        <section aria-label="Snoozed">
+          <ShelfLabel
+            label="Snoozed"
+            count={shelves.snoozed.length}
+            collapsed={snoozedCollapsed}
+            onToggle={sidebarUiActions.toggleSnoozed}
+          />
+          {!snoozedCollapsed &&
+            shelves.snoozed.map((r) => (
+              <SessionRow key={r.session.id} row={r} muted />
+            ))}
+        </section>
+      )}
       {shelves.done.length > 0 && (
         <section aria-label="Done">
           <ShelfLabel

package/components/SessionList/SidebarBody.tsx

@@ -66,6 +66,8 @@ export function SidebarBody({
     shelves.needsYou.length +
     shelves.working.length +
     shelves.inReview.length +
+    shelves.ongoing.length +
+    shelves.snoozed.length +
     data.queued.length +
     shelves.done.length +
     data.machines.length;
@@ -121,6 +123,7 @@ export function SidebarBody({
         queued={data.queued}
         toStart={data.toStart}
         doneCollapsed={ui.doneCollapsed}
+        snoozedCollapsed={ui.snoozedCollapsed}
         donePages={ui.donePages}
       />
       <MachineShelves groups={data.machines} />

package/components/SessionList/index.tsx

@@ -63,6 +63,8 @@ export function SessionList({
         ...shelves.needsYou,
         ...shelves.working,
         ...shelves.inReview,
+        ...shelves.ongoing,
+        ...shelves.snoozed,
         ...shelves.done,
         ...data.machines.flatMap((g) => g.rows),
       ]),

package/components/SessionList/useShelfActions.ts

@@ -0,0 +1,49 @@
+import { toast } from "sonner";
+import type { Session } from "@/lib/db";
+import { useSettleSession, useSnoozeSession } from "@/data/sessions/shelf";
+import {
+  snoozePreset,
+  wakeLabel,
+  type SnoozePreset,
+} from "@/lib/sidebar/snooze";
+
+// A row menu's Snooze, Unsnooze, Mark done and Reopen, each with an Undo.
+export function useShelfActions() {
+  const snooze = useSnoozeSession();
+  const settle = useSettleSession();
+  const unsnooze = (session: Session) =>
+    snooze.mutate({ id: session.id, until: null });
+  return {
+    snooze: (session: Session, preset: SnoozePreset) => {
+      const until = snoozePreset(preset);
+      snooze.mutate(
+        { id: session.id, until },
+        {
+          onSuccess: () =>
+            toast.success(`Snoozed until ${wakeLabel(until.getTime())}`, {
+              action: { label: "Undo", onClick: () => unsnooze(session) },
+            }),
+          onError: (e) => toast.error(e.message),
+        }
+      );
+    },
+    unsnooze,
+    settle: (session: Session) =>
+      settle.mutate(
+        { id: session.id, settled: true },
+        {
+          onSuccess: () =>
+            toast.success("Marked done", {
+              action: {
+                label: "Undo",
+                onClick: () =>
+                  settle.mutate({ id: session.id, settled: false }),
+              },
+            }),
+          onError: (e) => toast.error(e.message),
+        }
+      ),
+    reopen: (session: Session) =>
+      settle.mutate({ id: session.id, settled: false }),
+  };
+}

package/components/SessionList/useSidebarData.ts

@@ -19,6 +19,7 @@ import { rollups, type Rollup } from "@/lib/sidebar/rollup";
 import { queuedRows } from "@/lib/sidebar/queued";
 import { useSelectedWorkspace } from "@/hooks/useSelectedWorkspace";
 import { useOrchestratorsQuery } from "@/data/orchestrators";
+import { useClock } from "@/hooks/useMinuteTick";
 import { sidebarUi } from "@/stores/sidebarUi";
 import type { SessionStatus } from "./SessionList.types";
 
@@ -31,6 +32,8 @@ export function useSidebarData(
   sessionStatuses: Record<string, SessionStatus> | undefined
 ) {
   const ui = useSnapshot(sidebarUi);
+  // Wakes and 3-day settles are read from the clock.
+  const now = useClock();
 
   const sessionsQuery = useSessionsQuery();
   const projectsQuery = useProjectsQuery();
@@ -84,6 +87,7 @@ export function useSidebarData(
       tasks: taskStates,
       projectName,
       query: ui.query,
+      now,
     };
     const input = {
       ...common,
@@ -113,6 +117,7 @@ export function useSidebarData(
           : machineGroups({ ...common, sessions }, linked),
     };
   }, [
+    now,
     linked,
     sessions,
     projects,

package/data/sessions/shelf.ts

@@ -0,0 +1,85 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import type { Session, Group } from "@/lib/db";
+import { toSqliteTime } from "@/lib/session-meta";
+import { sessionKeys } from "./keys";
+
+interface SessionsResponse {
+  sessions: Session[];
+  groups: Group[];
+}
+
+async function post(url: string, body: object) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok)
+    throw new Error(
+      (await res.json().catch(() => null))?.error ?? "Request failed"
+    );
+}
+
+// Snooze, wake, mark done and reopen all change a few columns the shelves
+// read, so the row moves at once and rolls back if the server refuses.
+function useShelfMutation<V extends { id: string }>(
+  send: (v: V) => Promise<void>,
+  patch: (v: V, now: string) => Partial<Session>
+) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: send,
+    onMutate: async (v: V) => {
+      await queryClient.cancelQueries({ queryKey: sessionKeys.list() });
+      const previous = queryClient.getQueryData<SessionsResponse>(
+        sessionKeys.list()
+      );
+      const now = toSqliteTime(new Date());
+      queryClient.setQueryData<SessionsResponse>(
+        sessionKeys.list(),
+        (old) =>
+          old && {
+            ...old,
+            sessions: old.sessions.map((s) =>
+              s.id === v.id ? { ...s, ...patch(v, now) } : s
+            ),
+          }
+      );
+      return { previous };
+    },
+    onError: (_, __, context) => {
+      if (context?.previous)
+        queryClient.setQueryData(sessionKeys.list(), context.previous);
+    },
+    onSettled: () =>
+      queryClient.invalidateQueries({ queryKey: sessionKeys.list() }),
+  });
+}
+
+// until null wakes it.
+export function useSnoozeSession() {
+  return useShelfMutation<{ id: string; until: Date | null }>(
+    ({ id, until }) =>
+      post(`/api/sessions/${id}/snooze`, {
+        until: until?.toISOString() ?? null,
+      }),
+    ({ until }, now) =>
+      until
+        ? {
+            snoozed_until: toSqliteTime(until),
+            snoozed_at: now,
+            settled_at: null,
+          }
+        : { snoozed_until: null, snoozed_at: null, active_at: now }
+  );
+}
+
+export function useSettleSession() {
+  return useShelfMutation<{ id: string; settled: boolean }>(
+    ({ id, settled }) => post(`/api/sessions/${id}/settle`, { settled }),
+    ({ settled }, now) =>
+      settled
+        ? { settled_at: now, snoozed_until: null, snoozed_at: null }
+        : { settled_at: null, active_at: now }
+  );
+}

package/hooks/useMinuteTick.ts

@@ -4,12 +4,15 @@ import { useSyncExternalStore } from "react";
 // so they stay current without their lists redrawing for it.
 const listeners = new Set<() => void>();
 let tick = 0;
+let now = Date.now();
 let timer: ReturnType<typeof setInterval> | undefined;
 
 function subscribe(listener: () => void) {
+  now = Date.now();
   listeners.add(listener);
   timer ??= setInterval(() => {
     tick++;
+    now = Date.now();
     listeners.forEach((l) => l());
   }, 30_000);
   return () => {
@@ -28,3 +31,13 @@ export function useMinuteTick(): number {
     () => tick
   );
 }
+
+// The clock itself (ms), moving with the same tick: for code that reads wakes
+// and settles from the time.
+export function useClock(): number {
+  return useSyncExternalStore(
+    subscribe,
+    () => now,
+    () => now
+  );
+}

package/lib/chat/registry.ts

@@ -1,3 +1,4 @@
+import { touchActive } from "../session-activity";
 import { noteWaiting } from "../notify/push/waiting";
 import { db, type Session } from "../db";
 import type { WorkerClient } from "./worker/client";
@@ -94,6 +95,11 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
   if (m.type === "state" || m.type === "compacting" || m.type === "item")
     markStatusDirty(sessionId, EMIT_SETTLE_MS);
   if (m.type === "state") noteWaiting(sessionId, m.state === "waiting");
+  if (
+    (m.type === "state" && m.state !== "idle") ||
+    (m.type === "item" && m.item.kind === "turn_end")
+  )
+    touchActive(sessionId);
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.

package/lib/chat/worker/host.ts

@@ -549,7 +549,7 @@ export class ChatHost {
     // A new turn makes the last guess stale.
     if (this.suggestion !== null) this.setSuggestion(null);
     db.prepare(
-      `UPDATE sessions SET updated_at = datetime('now') WHERE id = ?`
+      `UPDATE sessions SET updated_at = datetime('now'), active_at = datetime('now') WHERE id = ?`
     ).run(this.session.id);
   }
 

package/lib/db/migrations.ts

@@ -1973,6 +1973,27 @@ const migrations: Migration[] = [
       moveSchedulesToRecipes(db);
     },
   },
+  {
+    id: 82,
+    name: "session_shelf_times",
+    up: (db) => {
+      const cols = (
+        db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+      ).map((c) => c.name);
+      // Last real activity, when it was marked done, and the snooze.
+      for (const col of [
+        "active_at",
+        "settled_at",
+        "snoozed_until",
+        "snoozed_at",
+      ])
+        if (!cols.includes(col))
+          db.exec(`ALTER TABLE sessions ADD COLUMN ${col} TEXT`);
+      db.exec(
+        `UPDATE sessions SET active_at = updated_at WHERE active_at IS NULL`
+      );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/types.ts

@@ -79,6 +79,13 @@ export interface Session {
   chat_context: string | null;
   chat_usage: string | null;
   last_seen_at: string | null;
+  // Last real activity: a message, a run starting, a need (null: updated_at).
+  active_at?: string | null;
+  // Marked done by hand: Done until new activity (not archived).
+  settled_at?: string | null;
+  // Snoozed until this time, from snoozed_at; activity since wakes it early.
+  snoozed_until?: string | null;
+  snoozed_at?: string | null;
   // Set by done: hidden from the sidebar and the orchestrator, never deleted.
   archived_at: string | null;
   // On the sidebar's Pinned shelf (0/1 from SQLite).

package/lib/program-status/store.ts

@@ -85,7 +85,7 @@ function commit(sessionName: string, next: Records): boolean {
   if (same(before, after)) return false;
   if (after && after.state !== "idle" && after.state !== before?.state)
     db.prepare(
-      `UPDATE sessions SET updated_at = datetime('now') WHERE tmux_name = ? OR id = ?`
+      `UPDATE sessions SET updated_at = datetime('now'), active_at = datetime('now') WHERE tmux_name = ? OR id = ?`
     ).run(sessionName, getSessionIdFromName(sessionName));
   return true;
 }

package/lib/security/demo.ts

@@ -129,13 +129,15 @@ const READS = [
 
 // The only writes, each a database write and nothing more in demo mode:
 // pairing a device (start is loopback-only in its route), marking a session
-// seen or pinned, done (archives only: no merge, no clean-up), answering an
+// seen, pinned, snoozed or settled, done (archives only: no merge, no clean-up), answering an
 // ask, and removing the caller's own device.
 const WRITES: [string, RegExp][] = [
   ["POST", "pair/start"],
   ["POST", "pair/claim"],
   ["POST", "sessions/[id]/seen"],
   ["POST", "sessions/[id]/pin"],
+  ["POST", "sessions/[id]/snooze"],
+  ["POST", "sessions/[id]/settle"],
   ["POST", "sessions/[id]/done"],
   ["POST", "workspaces/[id]/orchestrator/asks/[id]"],
   ["DELETE", "devices/[id]"],

package/lib/session-activity.ts

@@ -0,0 +1,19 @@
+import { getDb } from "./db";
+
+// A session did something: a message, a run starting, a need. Written at most
+// once a minute, unless it wakes a snooze or brings a settled session back.
+export function touchActive(sessionId: string): void {
+  try {
+    getDb()
+      .prepare(
+        `UPDATE sessions SET active_at = datetime('now')
+         WHERE id = ? AND (active_at IS NULL
+           OR active_at < datetime('now', '-60 seconds')
+           OR (snoozed_at IS NOT NULL AND active_at <= snoozed_at)
+           OR (settled_at IS NOT NULL AND active_at <= settled_at))`
+      )
+      .run(sessionId);
+  } catch (err) {
+    console.error("[activity] touch failed:", err);
+  }
+}

package/lib/session-meta.ts

@@ -17,6 +17,10 @@ export function fromSqliteTime(value: string): Date {
   return new Date(value.includes("T") ? value : `${value.replace(" ", "T")}Z`);
 }
 
+export function toSqliteTime(date: Date): string {
+  return date.toISOString().slice(0, 19).replace("T", " ");
+}
+
 const STATUS: Record<SessionStatus, { label: string; tone: string }> = {
   idle: { label: "", tone: "text-muted-foreground/60" },
   running: { label: "Working", tone: "text-muted-foreground" },

package/lib/sidebar/machines.ts

@@ -45,6 +45,8 @@ export function machineGroups(
           ...s.needsYou,
           ...s.working,
           ...s.inReview,
+          ...s.ongoing,
+          ...s.snoozed,
           ...s.done,
         ],
       };

package/lib/sidebar/rollup.ts

@@ -31,6 +31,8 @@ export function rollups(
     ...shelves.needsYou,
     ...shelves.working,
     ...shelves.inReview,
+    ...shelves.ongoing,
+    ...shelves.snoozed,
     ...shelves.done,
   ]);
   for (const row of rows) {

package/lib/sidebar/shelf-state.ts

@@ -0,0 +1,47 @@
+import { getDb } from "@/lib/db";
+import { toSqliteTime } from "@/lib/session-meta";
+
+// Marking done and snoozing are view choices like pinning: none of them
+// touch updated_at. Archived sessions are out of the sidebar, so they refuse.
+function update(sql: string, ...args: (string | null)[]): boolean {
+  return (
+    getDb()
+      .prepare(`UPDATE sessions SET ${sql} AND archived_at IS NULL`)
+      .run(...args).changes > 0
+  );
+}
+
+export function settleSession(id: string): boolean {
+  return update(
+    `settled_at = datetime('now'), snoozed_until = NULL, snoozed_at = NULL
+     WHERE id = ?`,
+    id
+  );
+}
+
+// Reopening is activity, so an auto-settled row doesn't fall back into Done.
+export function reopenSession(id: string): boolean {
+  return update(
+    `settled_at = NULL, active_at = datetime('now') WHERE id = ?`,
+    id
+  );
+}
+
+export function snoozeSession(id: string, until: Date): boolean {
+  return update(
+    `snoozed_until = ?, snoozed_at = datetime('now'), settled_at = NULL
+     WHERE id = ?`,
+    toSqliteTime(until),
+    id
+  );
+}
+
+export function unsnoozeSession(id: string): boolean {
+  return update(
+    `snoozed_until = NULL, snoozed_at = NULL, active_at = datetime('now')
+     WHERE id = ?`,
+    id
+  );
+}
+
+export const SNOOZE_MAX_MS = 60 * 24 * 3600_000;

package/lib/sidebar/shelves.ts

@@ -1,5 +1,6 @@
 // The sidebar's one flat list, sorted onto shelves: the workspace's pinned
-// orchestrator, Pinned, Needs you, Working, In review, then Done. Client-safe: no database.
+// orchestrator, Pinned, Needs you, Working, In review, Ongoing, Snoozed, then
+// Done. Client-safe: no database.
 import type { Session } from "@/lib/db/types";
 import { fromSqliteTime } from "@/lib/session-meta";
 import type { PrStage } from "@/lib/tasks/pr-stage";
@@ -23,6 +24,9 @@ export const NEED_LABEL: Record<SessionNeed, string> = {
   failed: "Failed",
 };
 
+// A plain session quiet this long has settled by itself.
+export const SETTLE_AFTER_MS = 3 * 24 * 3600_000;
+
 export const DONE_FIRST_PAGE = 10;
 export const DONE_PAGE = 25;
 
@@ -55,6 +59,12 @@ export interface SidebarRow {
   task?: TaskState;
   // An orchestrator's quick changes (orchestrator/quick.ts), nested under it.
   quick?: SidebarRow[];
+  // Last real activity (ms): sorts Ongoing and is the "2d" on a row.
+  activeAt: number;
+  // While snoozed: when it wakes (ms).
+  wakesAt?: number;
+  // A plain session in Done: marked by hand, or settled by itself.
+  settled?: "manual" | "auto";
 }
 
 export interface Shelves {
@@ -64,6 +74,8 @@ export interface Shelves {
   needsYou: SidebarRow[];
   working: SidebarRow[];
   inReview: SidebarRow[];
+  ongoing: SidebarRow[];
+  snoozed: SidebarRow[];
   done: SidebarRow[];
 }
 
@@ -125,6 +137,8 @@ export interface ShelfInput {
   currentOrchestrators?: ReadonlySet<string>;
   // Only the sessions this orchestrator session started.
   startedBy?: string | null;
+  // The clock (ms): wakes and 3-day settles are read from it.
+  now?: number;
 }
 
 const newestFirst = (a: SidebarRow, b: SidebarRow) =>
@@ -132,6 +146,73 @@ const newestFirst = (a: SidebarRow, b: SidebarRow) =>
 const oldestFirst = (a: SidebarRow, b: SidebarRow) =>
   a.session.created_at.localeCompare(b.session.created_at);
 
+const ms = (t: string | null | undefined) =>
+  t ? fromSqliteTime(t).getTime() : 0;
+
+// When it last did something: a mirrored session only has its machine's
+// updated_at; a snooze that ran out counts as activity at its wake time.
+export function activeMs(
+  session: Pick<
+    Session,
+    "active_at" | "updated_at" | "peer_mirror" | "snoozed_until" | "snoozed_at"
+  >,
+  now: number
+): number {
+  const base = ms(
+    session.peer_mirror
+      ? session.updated_at
+      : (session.active_at ?? session.updated_at)
+  );
+  const wake = ms(session.snoozed_until);
+  if (wake && wake <= now && base <= ms(session.snoozed_at))
+    return Math.max(base, wake);
+  return base;
+}
+
+// When a snooze still holds, until when: any activity since ends it early.
+export function snoozedUntil(
+  session: Parameters<typeof activeMs>[0],
+  now: number
+): number | null {
+  const until = ms(session.snoozed_until);
+  return until > now && activeMs(session, now) <= ms(session.snoozed_at)
+    ? until
+    : null;
+}
+
+export function settledHow(
+  session: Parameters<typeof activeMs>[0] & Pick<Session, "settled_at">,
+  now: number
+): "manual" | "auto" | null {
+  const active = activeMs(session, now);
+  if (session.settled_at && active <= ms(session.settled_at)) return "manual";
+  return now - active >= SETTLE_AFTER_MS ? "auto" : null;
+}
+
+// Woken by its timer and not opened since.
+function wokeUnread(
+  session: Parameters<typeof activeMs>[0] & Pick<Session, "last_seen_at">,
+  now: number
+): boolean {
+  const wake = ms(session.snoozed_until);
+  return (
+    wake > 0 &&
+    wake <= now &&
+    activeMs(session, now) <= wake &&
+    ms(session.last_seen_at) < wake
+  );
+}
+
+// When a row went to Done: marked by hand, quiet for 3 days, or (a task)
+// last changed.
+export function doneAtMs(row: SidebarRow): number {
+  return row.settled === "manual"
+    ? ms(row.session.settled_at)
+    : row.settled === "auto"
+      ? row.activeAt
+      : ms(row.session.updated_at);
+}
+
 const OPEN_RUN = ["queued", "starting", "running"];
 
 // A recipe run that hasn't reported its result yet: its session going quiet
@@ -146,13 +227,16 @@ export function recipeRunOpen(session: Pick<Session, "recipe_run">): boolean {
   }
 }
 
-function toRow(input: ShelfInput, session: Session): SidebarRow {
+function toRow(input: ShelfInput, session: Session, now: number): SidebarRow {
   const status = input.statuses[session.id];
+  const wakesAt = snoozedUntil(session, now);
   return {
     session,
     status,
     need: needOf(session, status, input.tasks[session.id]),
-    unread: !!status?.unread,
+    unread: !!status?.unread || wokeUnread(session, now),
+    activeAt: activeMs(session, now),
+    ...(wakesAt && { wakesAt }),
     working:
       status?.status === "running" ||
       (status?.background ?? 0) > 0 ||
@@ -165,6 +249,7 @@ function toRow(input: ShelfInput, session: Session): SidebarRow {
 }
 
 export function buildShelves(input: ShelfInput): Shelves {
+  const now = input.now ?? Date.now();
   const rows = input.sessions
     .filter(
       (s) =>
@@ -173,7 +258,7 @@ export function buildShelves(input: ShelfInput): Shelves {
         (!input.startedBy || s.started_by === input.startedBy) &&
         matchesQuery(s, input.projectName(s), input.query ?? "")
     )
-    .map((s) => toRow(input, s));
+    .map((s) => toRow(input, s, now));
   const byId = new Map(rows.map((r) => [r.session.id, r]));
 
   const top: SidebarRow[] = [];
@@ -201,6 +286,8 @@ export function buildShelves(input: ShelfInput): Shelves {
     needsYou: [],
     working: [],
     inReview: [],
+    ongoing: [],
+    snoozed: [],
     done: [],
   };
   for (const row of top) {
@@ -210,14 +297,25 @@ export function buildShelves(input: ShelfInput): Shelves {
     else if (pinned && role !== "orchestrator") shelves.pinned.push(row);
     else if (row.need) shelves.needsYou.push(row);
     else if (row.working) shelves.working.push(row);
-    else shelves[quietShelf(row.task)].push(row);
+    else if (row.wakesAt) shelves.snoozed.push(row);
+    else if (row.task || row.session.task_status)
+      shelves[quietShelf(row.task)].push(row);
+    else {
+      const settled = settledHow(row.session, now);
+      if (settled) {
+        row.settled = settled;
+        shelves.done.push(row);
+      } else shelves.ongoing.push(row);
+    }
   }
   shelves.orchestrators.sort(oldestFirst);
   shelves.pinned.sort(oldestFirst);
   shelves.needsYou.sort(newestFirst);
   shelves.working.sort(newestFirst);
   shelves.inReview.sort(newestFirst);
-  shelves.done.sort(newestFirst);
+  shelves.ongoing.sort((a, b) => b.activeAt - a.activeAt);
+  shelves.snoozed.sort((a, b) => a.wakesAt! - b.wakesAt!);
+  shelves.done.sort((a, b) => doneAtMs(b) - doneAtMs(a));
   return shelves;
 }
 
@@ -233,7 +331,7 @@ export function doneSummary(
 ): { today: number; earlier: number; text: string } {
   const day = now.toDateString();
   const today = done.filter(
-    (r) => fromSqliteTime(r.session.updated_at).toDateString() === day
+    (r) => new Date(doneAtMs(r)).toDateString() === day
   ).length;
   const earlier = done.length - today;
   const text = [
@@ -281,6 +379,9 @@ export function sameRow(a: SidebarRow, b: SidebarRow): boolean {
     a.working === b.working &&
     sameStatus(a.status, b.status) &&
     a.task === b.task &&
+    a.activeAt === b.activeAt &&
+    a.wakesAt === b.wakesAt &&
+    a.settled === b.settled &&
     a.workers.length === b.workers.length &&
     a.workers.every((w, i) => sameRow(w, b.workers[i])) &&
     (a.quick?.length ?? 0) === (b.quick?.length ?? 0) &&

package/lib/sidebar/snooze.ts

@@ -0,0 +1,102 @@
+// Snooze presets and how a wake time reads. The reader's own zone decides
+// "9am", so this runs on their device. Client-safe.
+
+export type SnoozePreset = "tomorrow" | "next-week";
+
+export const SNOOZE_PRESETS: { key: SnoozePreset; label: string }[] = [
+  { key: "tomorrow", label: "Tomorrow" },
+  { key: "next-week", label: "Next week" },
+];
+
+const localZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+function wall(ms: number, timeZone: string) {
+  const p = Object.fromEntries(
+    new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+    })
+      .formatToParts(new Date(ms))
+      .map((x) => [x.type, Number(x.value)])
+  );
+  return {
+    y: p.year,
+    m: p.month,
+    d: p.day,
+    h: p.hour,
+    mi: p.minute,
+    s: p.second,
+  };
+}
+
+const offsetAt = (ms: number, timeZone: string) => {
+  const w = wall(ms, timeZone);
+  return (
+    Date.UTC(w.y, w.m - 1, w.d, w.h, w.mi, w.s) - Math.floor(ms / 1000) * 1000
+  );
+};
+
+// The instant a zone's wall clock reads the given date and hour; the offset
+// is read again at the result so a DST change in between is honoured.
+function zoned(y: number, m: number, d: number, h: number, timeZone: string) {
+  const guess = Date.UTC(y, m - 1, d, h);
+  let t = guess - offsetAt(guess, timeZone);
+  t = guess - offsetAt(t, timeZone);
+  return t;
+}
+
+// "Tomorrow" is 9am the next day; "Next week" is 9am next Monday (a Monday
+// waits a full week, a Sunday waits a day).
+export function snoozePreset(
+  preset: SnoozePreset,
+  now: Date = new Date(),
+  timeZone: string = localZone()
+): Date {
+  const { y, m, d } = wall(now.getTime(), timeZone);
+  const weekday = new Date(Date.UTC(y, m - 1, d)).getUTCDay();
+  const ahead = preset === "tomorrow" ? 1 : (1 - weekday + 7) % 7 || 7;
+  const target = new Date(Date.UTC(y, m - 1, d + ahead));
+  return new Date(
+    zoned(
+      target.getUTCFullYear(),
+      target.getUTCMonth() + 1,
+      target.getUTCDate(),
+      9,
+      timeZone
+    )
+  );
+}
+
+const dayNumber = (ms: number, timeZone: string) => {
+  const w = wall(ms, timeZone);
+  return Math.round(Date.UTC(w.y, w.m - 1, w.d) / 86400000);
+};
+
+// "9 AM", "Tomorrow 9 AM", "Mon 9 AM", "Oct 20, 9 AM".
+export function wakeLabel(
+  ms: number,
+  now: number = Date.now(),
+  timeZone: string = localZone()
+): string {
+  const date = new Date(ms);
+  const time = date
+    .toLocaleTimeString("en-US", {
+      timeZone,
+      hour: "numeric",
+      minute: "2-digit",
+    })
+    .replace(/\s/g, " ")
+    .replace(":00", "");
+  const days = dayNumber(ms, timeZone) - dayNumber(now, timeZone);
+  if (days <= 0) return time;
+  if (days === 1) return `Tomorrow ${time}`;
+  if (days < 7)
+    return `${date.toLocaleDateString("en-US", { timeZone, weekday: "short" })} ${time}`;
+  return `${date.toLocaleDateString("en-US", { timeZone, month: "short", day: "numeric" })}, ${time}`;
+}

package/lib/status/collect.ts

@@ -421,7 +421,7 @@ async function collect(full = false): Promise<StatusSnapshot> {
 
   // Batch update sessions and claude_session_id in a single transaction
   const updateStatusStmt = db.prepare(
-    "UPDATE sessions SET updated_at = datetime('now') WHERE id = ?"
+    "UPDATE sessions SET updated_at = datetime('now'), active_at = datetime('now') WHERE id = ?"
   );
   const updateClaudeIdStmt = db.prepare(
     "UPDATE sessions SET claude_session_id = ? WHERE id = ? AND (claude_session_id IS NULL OR claude_session_id != ?)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.543",
+  "version": "0.3.544",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/stores/sidebarUi.ts

@@ -8,6 +8,7 @@ interface Remembered {
   workspaceId: string | null;
   projectId: string | null;
   doneCollapsed: boolean;
+  snoozedCollapsed: boolean;
 }
 
 export const sidebarUi = proxy<
@@ -22,6 +23,7 @@ export const sidebarUi = proxy<
   workspaceId: null,
   projectId: null,
   doneCollapsed: true,
+  snoozedCollapsed: true,
   query: "",
   orchestratorId: null,
   donePages: 0,
@@ -43,13 +45,20 @@ export const sidebarUiActions = {
     sidebarUi.workspaceId = saved.workspaceId ?? null;
     sidebarUi.projectId = saved.projectId ?? null;
     sidebarUi.doneCollapsed = saved.doneCollapsed ?? true;
+    sidebarUi.snoozedCollapsed = saved.snoozedCollapsed ?? true;
     sidebarUi.hydrated = true;
     subscribe(sidebarUi, () => {
       try {
-        const { workspaceId, projectId, doneCollapsed } = sidebarUi;
+        const { workspaceId, projectId, doneCollapsed, snoozedCollapsed } =
+          sidebarUi;
         localStorage.setItem(
           STORAGE_KEY,
-          JSON.stringify({ workspaceId, projectId, doneCollapsed })
+          JSON.stringify({
+            workspaceId,
+            projectId,
+            doneCollapsed,
+            snoozedCollapsed,
+          })
         );
       } catch {
         // Storage can be unavailable (private mode); the view still works.
@@ -76,6 +85,9 @@ export const sidebarUiActions = {
   toggleDone: () => {
     sidebarUi.doneCollapsed = !sidebarUi.doneCollapsed;
   },
+  toggleSnoozed: () => {
+    sidebarUi.snoozedCollapsed = !sidebarUi.snoozedCollapsed;
+  },
   showMoreDone: () => {
     sidebarUi.donePages += 1;
   },