@saadnvd1/agent-os 0.3.543 → 0.3.545

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.545",
   "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;
   },