feat(web,hub): show scheduled fire time in session-list clock tooltip

The schedule clock tooltip previously said only "Will fire when due."
while the row already showed a relative updated-at pill. Extend the
session-list API with nextScheduledAt (MIN future scheduled_at per
session, same filter as futureScheduledMessageCount) and render:

- single scheduled: "Fires in 5m · Jun 16, 1:45 PM"
- multiple: "Next in 5m · Jun 16, 1:45 PM · +2 more"

Extract formatScheduledTime from QueuedMessagesBar into web/lib/
scheduledTime.ts alongside formatFutureRelativeTime and the tooltip
composer. SSE upsert preserves nextScheduledAt until the list refetch
that already runs on schedule-related events.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: heavygee

hub/src/store/messageStore.ts

@@ -15,6 +15,7 @@ import {
     getImmediateQueuedLocalMessages,
     countFutureScheduledBySessionIds,
     countFutureScheduledLocalMessages,
+    minFutureScheduledAtBySessionIds,
     countMessages,
     markMessagesInvoked,
     mergeSessionMessages,
@@ -83,6 +84,10 @@ export class MessageStore {
         return countFutureScheduledBySessionIds(this.db, sessionIds, now)
     }
 
+    minFutureScheduledAtBySessionIds(sessionIds: string[], now: number = Date.now()): Map<string, number> {
+        return minFutureScheduledAtBySessionIds(this.db, sessionIds, now)
+    }
+
     countMessages(sessionId: string): number {
         return countMessages(this.db, sessionId)
     }

hub/src/store/messages.test.ts

@@ -342,5 +342,9 @@ describe('countFutureScheduledLocalMessages', () => {
         const counts = store.messages.countFutureScheduledBySessionIds([sessionA.id, sessionB.id], now)
         expect(counts.get(sessionA.id)).toBe(2)
         expect(counts.get(sessionB.id)).toBeUndefined()
+
+        const nextAt = store.messages.minFutureScheduledAtBySessionIds([sessionA.id, sessionB.id], now)
+        expect(nextAt.get(sessionA.id)).toBe(now + 60_000)
+        expect(nextAt.get(sessionB.id)).toBeUndefined()
     })
 })

hub/src/store/messages.ts

@@ -361,6 +361,35 @@ export function countFutureScheduledBySessionIds(
     return counts
 }
 
+/** Earliest future scheduled_at per session (session-list clock tooltip). */
+export function minFutureScheduledAtBySessionIds(
+    db: Database,
+    sessionIds: string[],
+    now: number
+): Map<string, number> {
+    const nextAt = new Map<string, number>()
+    if (sessionIds.length === 0) {
+        return nextAt
+    }
+
+    const placeholders = sessionIds.map(() => '?').join(',')
+    const rows = db.prepare(`
+        SELECT session_id, MIN(scheduled_at) AS next_at
+        FROM messages
+        WHERE session_id IN (${placeholders})
+          AND invoked_at IS NULL
+          AND local_id IS NOT NULL
+          AND scheduled_at IS NOT NULL
+          AND scheduled_at > ?
+        GROUP BY session_id
+    `).all(...sessionIds, now) as { session_id: string; next_at: number }[]
+
+    for (const row of rows) {
+        nextAt.set(row.session_id, row.next_at)
+    }
+    return nextAt
+}
+
 export function getMaxSeq(db: Database, sessionId: string): number {
     const row = db.prepare(
         'SELECT COALESCE(MAX(seq), 0) AS maxSeq FROM messages WHERE session_id = ?'

hub/src/sync/syncEngine.ts

@@ -190,6 +190,10 @@ export class SyncEngine {
         return this.store.messages.countFutureScheduledBySessionIds(sessionIds, now)
     }
 
+    getNextScheduledAtBySessionIds(sessionIds: string[], now: number = Date.now()): Map<string, number> {
+        return this.store.messages.minFutureScheduledAtBySessionIds(sessionIds, now)
+    }
+
     getSession(sessionId: string): Session | undefined {
         return this.sessionCache.getSession(sessionId) ?? this.sessionCache.refreshSession(sessionId) ?? undefined
     }

hub/src/web/routes/sessions.ts

@@ -81,11 +81,13 @@ export function createSessionsRoutes(getSyncEngine: () => SyncEngine | null): Ho
                 return b.updatedAt - a.updatedAt
             })
         const scheduledCounts = engine.getFutureScheduledMessageCounts(sessionRecords.map((session) => session.id))
+        const nextScheduledAt = engine.getNextScheduledAtBySessionIds(sessionRecords.map((session) => session.id))
         const sessions = sessionRecords.map((session) => {
             const summary = toSessionSummary(session)
             return {
                 ...summary,
-                futureScheduledMessageCount: scheduledCounts.get(session.id) ?? 0
+                futureScheduledMessageCount: scheduledCounts.get(session.id) ?? 0,
+                nextScheduledAt: nextScheduledAt.get(session.id) ?? null
             }
         })
 

shared/src/sessionSummary.ts

@@ -56,6 +56,8 @@ export type SessionSummary = {
     pendingRequests: PendingRequest[]
     backgroundTaskCount: number
     futureScheduledMessageCount: number
+    /** Epoch ms of the soonest uninvoked future scheduled message, or null. */
+    nextScheduledAt: number | null
     model: string | null
     effort: string | null
 }
@@ -141,6 +143,7 @@ export function toSessionSummary(session: Session): SessionSummary {
         pendingRequests: getPendingRequests(session),
         backgroundTaskCount: session.backgroundTaskCount ?? 0,
         futureScheduledMessageCount: 0,
+        nextScheduledAt: null,
         model: session.model,
         effort: session.effort
     }

web/src/components/AssistantChat/QueuedMessagesBar.test.tsx

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import type { DecryptedMessage } from '@/types/api'
-import { computeCanCancel, computeEditPendingSchedule, formatScheduledTime, getQueuedMessageEditText, getQueuedMessagePreview, sortQueuedMessages } from './QueuedMessagesBar'
+import { computeCanCancel, computeEditPendingSchedule, getQueuedMessageEditText, getQueuedMessagePreview, sortQueuedMessages } from './QueuedMessagesBar'
+import { formatScheduledTime } from '@/lib/scheduledTime'
 
 /**
  * Unit tests for computeCanCancel — the race guard that prevents sending

web/src/components/AssistantChat/QueuedMessagesBar.tsx

@@ -10,6 +10,7 @@ import { useCancelQueuedMessage } from '@/hooks/mutations/useCancelQueuedMessage
 import { useTranslation } from '@/lib/use-translation'
 import { useToast } from '@/lib/toast-context'
 import type { PendingSchedule } from '@/components/AssistantChat/ScheduleTimePicker'
+import { formatScheduledTime } from '@/lib/scheduledTime'
 
 function ClockIcon() {
     return (
@@ -147,22 +148,6 @@ export function computeCanCancel({
  * Edit = client-side cancel + prefill composer with message text (Codex dialect).
  * Cancel = DELETE /sessions/:id/messages/:messageId with optimistic removal.
  */
-/** @internal Exported for unit testing. */
-export function formatScheduledTime(scheduledAt: number): string {
-    const date = new Date(scheduledAt)
-    const now = new Date()
-    const opts: Intl.DateTimeFormatOptions = {
-        month: 'short',
-        day: 'numeric',
-        hour: '2-digit',
-        minute: '2-digit',
-    }
-    if (date.getFullYear() !== now.getFullYear()) {
-        opts.year = 'numeric'
-    }
-    return date.toLocaleString(undefined, opts)
-}
-
 export function QueuedMessagesBar({
     sessionId,
     api,

web/src/components/SessionAttentionIndicator.test.tsx

@@ -25,6 +25,7 @@ function makeSummary(overrides: Partial<SessionSummary> & { id: string }): Sessi
         pendingRequests: [],
         backgroundTaskCount: 0,
         futureScheduledMessageCount: 0,
+        nextScheduledAt: null,
         model: null,
         effort: null,
         ...overrides

web/src/components/SessionList.directory-action.test.tsx

@@ -21,6 +21,7 @@ function makeSession(overrides: Partial<SessionSummary> & { id: string }): Sessi
         pendingRequests: [],
         backgroundTaskCount: 0,
         futureScheduledMessageCount: 0,
+        nextScheduledAt: null,
         model: null,
         effort: null,
         ...overrides