@saadnvd1/agent-os 0.3.543 → 0.3.545

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/components/views/DesktopView.tsx

@@ -18,6 +18,7 @@ export function DesktopView({
   setShowQuickSwitcher,
   notificationSettings,
   attachToSession,
+  selectSession,
   openSessionInNewTab,
   handleNewSessionInProject,
   handleOpenTerminal,
@@ -38,7 +39,7 @@ export function DesktopView({
         sessionStatuses={sessionStatuses}
         onSelect={(id) => {
           const session = sessions.find((s) => s.id === id);
-          if (session) attachToSession(session);
+          if (session) selectSession(session);
         }}
         onOpenInTab={(id) => {
           const session = sessions.find((s) => s.id === id);
@@ -82,7 +83,7 @@ export function DesktopView({
         activeSessionWorkingDir={activeSession?.working_directory ?? undefined}
         onSelectSession={(sessionId) => {
           const session = sessions.find((s) => s.id === sessionId);
-          if (session) attachToSession(session);
+          if (session) selectSession(session);
         }}
         onSelectFile={(file, line) => {
           // Convert relative path to absolute by prepending working directory

package/components/views/types.ts

@@ -43,6 +43,7 @@ export interface ViewProps {
 
   // Handlers
   attachToSession: (session: Session) => void;
+  selectSession: (session: Session) => void;
   openSessionInNewTab: (session: Session) => void;
   handleNewSessionInProject: (projectId: string) => void;
   handleOpenTerminal: (projectId: string) => void;

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;