Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
feat(sidebar-v2): thread snoozing (#4311)
Theo Browne202e5609ffb2
diff --git a/apps/mobile/src/features/home/HomeScreen.tsx b/apps/mobile/src/features/home/HomeScreen.tsxindex 108a4b705..54e242c21 100644--- a/apps/mobile/src/features/home/HomeScreen.tsx+++ b/apps/mobile/src/features/home/HomeScreen.tsx@@ -472,6 +472,10 @@ export function HomeScreen(props: HomeScreenProps) {// boundary is actually crossed while the app stays open (mirrors web);// without a clock dependency the partition memoizes a frozen "now".const [nowMinute, setNowMinute] = useState(() => new Date().toISOString().slice(0, 16));+ // Snooze wake times are second-precise; a counter bumped exactly at the+ // next wake boundary re-runs the partition with a fresh clock so a woken+ // thread reappears immediately instead of on the next minute tick.+ const [snoozeWakeTick, bumpSnoozeWakeTick] = useState(0);useEffect(() => {if (!threadListV2Enabled) return;// Refresh immediately on enable: the mount-time value can be hours old@@ -493,8 +497,18 @@ export function HomeScreen(props: HomeScreenProps) {}return supported;}, [serverConfigs]);+ const snoozeEnvironmentIds = useMemo(() => {+ const supported = new Set<EnvironmentId>();+ for (const [environmentId, config] of serverConfigs) {+ if (config.environment.capabilities.threadSnooze === true) {+ supported.add(environmentId);+ }+ }+ return supported;+ }, [serverConfigs]);const threadListV2Layout = useMemo(() => {- if (!threadListV2Enabled) return { items: [], hiddenSettledCount: 0 };+ if (!threadListV2Enabled)+ return { items: [], hiddenSettledCount: 0, snoozedCount: 0, nextSnoozeWakeAt: null };// Settled threads are live shells; archived threads keep their original// "hidden from lists" meaning.return buildThreadListV2Items({@@ -504,20 +518,38 @@ export function HomeScreen(props: HomeScreenProps) {searchQuery: props.searchQuery,changeRequestStateByKey,settlementEnvironmentIds,+ snoozeEnvironmentIds,settledLimit: settledVisibleCount,now: `${nowMinute}:00.000Z`,+ snoozeNow: new Date().toISOString(),});}, [changeRequestStateByKey,nowMinute,+ snoozeWakeTick,settledVisibleCount,settlementEnvironmentIds,+ snoozeEnvironmentIds,props.searchQuery,props.selectedEnvironmentId,props.threads,threadListV2Enabled,v2ScopedProjectGroup,]);+ // Re-partition the moment the earliest snooze expires (clamped to the+ // signed-32-bit setTimeout range; far-future wakes re-arm at the clamp).+ const nextSnoozeWakeAt = threadListV2Layout.nextSnoozeWakeAt;+ useEffect(() => {+ if (nextSnoozeWakeAt === null) return;+ const wakeAtMs = Date.parse(nextSnoozeWakeAt);+ if (Number.isNaN(wakeAtMs)) return;+ const delayMs = Math.min(Math.max(0, wakeAtMs - Date.now()) + 50, 2_147_483_647);+ const id = setTimeout(() => bumpSnoozeWakeTick((tick) => tick + 1), delayMs);+ return () => clearTimeout(id);+ // snoozeWakeTick must re-arm the timer even when nextSnoozeWakeAt is+ // unchanged: after a clamped fire (wake beyond the 32-bit setTimeout+ // range) the boundary string is identical and the chain would die.+ }, [nextSnoozeWakeAt, snoozeWakeTick]);const threadListV2Items = threadListV2Layout.items;const renderV2Item = useCallback(@@ -813,11 +845,31 @@ export function HomeScreen(props: HomeScreenProps) {// Self-contained: v1's listEmpty keys off projectGroups, which ignores the// v2 project scope, so it can be null (results elsewhere) while this list// is empty. Search outranks the scope — "No results" names the actionable- // fact when a query is active. Pending tasks render in the header, so the- // list showing them isn't empty in the user's eyes.+ // fact when a query is active. Snoozed threads outrank the rest: "No+ // threads yet" over an inbox that is merely all-snoozed reads as data+ // loss. Pending tasks render in the header, so the list showing them+ // isn't empty in the user's eyes.+ const v2SnoozedCount = threadListV2Layout.snoozedCount;const v2ListEmpty =v2PendingTasks.length > 0 ? null : hasSearchQuery ? (- <EmptyState title="No results" detail={`No threads matching "${props.searchQuery}".`} />+ v2SnoozedCount > 0 ? (+ // The snoozed threads already passed this search filter: "No+ // results" would claim nothing matched when matches are merely+ // parked.+ <EmptyState+ title={+ v2SnoozedCount === 1 ? "1 matching thread snoozed" : `All matching threads snoozed`+ }+ detail={`Threads matching "${props.searchQuery}" are snoozed and return when their wake time passes.`}+ />+ ) : (+ <EmptyState title="No results" detail={`No threads matching "${props.searchQuery}".`} />+ )+ ) : v2SnoozedCount > 0 ? (+ <EmptyState+ title={v2SnoozedCount === 1 ? "1 thread snoozed" : `${v2SnoozedCount} threads snoozed`}+ detail="Snoozed threads return when their wake time passes."+ />) : v2ScopedProjectGroup !== null ? (<EmptyStatetitle={`No threads in ${v2ScopedProjectGroup.title}`}diff --git a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsxindex 01403047c..799d969da 100644--- a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx+++ b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx@@ -399,6 +399,10 @@ function ThreadNavigationSidebarPane(// crossed while the pane stays open; without a clock dependency the// partition memoizes a frozen "now".const [nowMinute, setNowMinute] = useState(() => new Date().toISOString().slice(0, 16));+ // Snooze wake times are second-precise; a counter bumped exactly at the+ // next wake boundary re-runs the partition with a fresh clock so a woken+ // thread reappears immediately instead of on the next minute tick.+ const [snoozeWakeTick, bumpSnoozeWakeTick] = useState(0);useEffect(() => {if (!threadListV2Enabled) return;// Refresh immediately on enable: the mount-time value can be hours old@@ -420,8 +424,18 @@ function ThreadNavigationSidebarPane(}return supported;}, [serverConfigs]);+ const snoozeEnvironmentIds = useMemo(() => {+ const supported = new Set<EnvironmentId>();+ for (const [environmentId, config] of serverConfigs) {+ if (config.environment.capabilities.threadSnooze === true) {+ supported.add(environmentId);+ }+ }+ return supported;+ }, [serverConfigs]);const threadListV2Layout = useMemo(() => {- if (!threadListV2Enabled) return { items: [], hiddenSettledCount: 0 };+ if (!threadListV2Enabled)+ return { items: [], hiddenSettledCount: 0, snoozedCount: 0, nextSnoozeWakeAt: null };return buildThreadListV2Items({threads: threads.filter((thread) => thread.archivedAt === null),environmentId: options.selectedEnvironmentId,@@ -429,20 +443,38 @@ function ThreadNavigationSidebarPane(searchQuery: props.searchQuery,changeRequestStateByKey,settlementEnvironmentIds,+ snoozeEnvironmentIds,settledLimit: settledVisibleCount,now: `${nowMinute}:00.000Z`,+ snoozeNow: new Date().toISOString(),});}, [changeRequestStateByKey,nowMinute,+ snoozeWakeTick,options.selectedEnvironmentId,props.searchQuery,settledVisibleCount,settlementEnvironmentIds,+ snoozeEnvironmentIds,threadListV2Enabled,threads,selectedProjectScope,]);+ // Re-partition the moment the earliest snooze expires (clamped to the+ // signed-32-bit setTimeout range; far-future wakes re-arm at the clamp).+ const nextSnoozeWakeAt = threadListV2Layout.nextSnoozeWakeAt;+ useEffect(() => {+ if (nextSnoozeWakeAt === null) return;+ const wakeAtMs = Date.parse(nextSnoozeWakeAt);+ if (Number.isNaN(wakeAtMs)) return;+ const delayMs = Math.min(Math.max(0, wakeAtMs - Date.now()) + 50, 2_147_483_647);+ const id = setTimeout(() => bumpSnoozeWakeTick((tick) => tick + 1), delayMs);+ return () => clearTimeout(id);+ // snoozeWakeTick must re-arm the timer even when nextSnoozeWakeAt is+ // unchanged: after a clamped fire (wake beyond the 32-bit setTimeout+ // range) the boundary string is identical and the chain would die.+ }, [nextSnoozeWakeAt, snoozeWakeTick]);const listItems = useMemo<readonly SidebarListItem[]>(() => {if (!threadListV2Enabled) return listLayout.items;// Queued offline tasks render above the thread rows (mirrors the@@ -930,15 +962,28 @@ function ThreadNavigationSidebarPane(}),[filterIcon, filterMenu, props.onOpenSettings],);+ // "No threads yet" over an inbox that is merely all-snoozed reads as+ // data loss; name the snoozed threads instead.+ const snoozedCount = threadListV2Layout.snoozedCount;const listEmpty = (<Text className="px-2 py-4 text-sm text-foreground-muted">{catalogState.isLoadingConnections? "Loading threads…": props.searchQuery.trim().length > 0- ? "No matching threads"- : selectedProjectScope !== null- ? `No threads in ${selectedProjectScope.title}`- : "No threads yet"}+ ? snoozedCount > 0+ ? // Snoozed matches passed this same search filter — "No+ // matching threads" would misreport them as nonexistent.+ snoozedCount === 1+ ? "1 matching thread snoozed"+ : "All matching threads snoozed"+ : "No matching threads"+ : snoozedCount > 0+ ? snoozedCount === 1+ ? "1 thread snoozed"+ : `${snoozedCount} threads snoozed`+ : selectedProjectScope !== null+ ? `No threads in ${selectedProjectScope.title}`+ : "No threads yet"}</Text>);diff --git a/apps/mobile/src/features/threads/threadListV2.test.ts b/apps/mobile/src/features/threads/threadListV2.test.tsindex cdbf2e3c5..e62b9ceda 100644--- a/apps/mobile/src/features/threads/threadListV2.test.ts+++ b/apps/mobile/src/features/threads/threadListV2.test.ts@@ -77,6 +77,85 @@ describe("sortThreadsForListV2", () => {});describe("buildThreadListV2Items", () => {+ it("hides snoozed threads and counts them — visibility parity with web", () => {+ const layout = buildThreadListV2Items({+ threads: [+ makeThread({ id: ThreadId.make("active"), title: "Active" }),+ makeThread({+ id: ThreadId.make("snoozed"),+ title: "Snoozed",+ snoozedUntil: "2026-06-03T09:00:00.000Z",+ snoozedAt: "2026-06-01T12:00:00.000Z",+ }),+ makeThread({+ id: ThreadId.make("woken"),+ title: "Woken",+ // Wake time already passed: back in the active list.+ snoozedUntil: "2026-06-01T18:00:00.000Z",+ snoozedAt: "2026-06-01T12:00:00.000Z",+ }),+ ],+ environmentId: null,+ searchQuery: "",+ now: NOW,+ });++ // Same createdAt → static sort tiebreaks by id; the point is the woken+ // thread is BACK in the card block and the snoozed one is gone.+ expect(layout.items.map((item) => item.thread.id)).toEqual(["active", "woken"]);+ expect(layout.snoozedCount).toBe(1);+ });++ it("classifies snooze with the second-precise clock and reports the next wake", () => {+ const layout = buildThreadListV2Items({+ threads: [+ makeThread({+ id: ThreadId.make("just-woke"),+ title: "Just woke",+ // Woke 30s ago: hidden under the minute-floored clock, visible+ // under the precise one.+ snoozedUntil: "2026-06-02T00:00:30.000Z",+ snoozedAt: "2026-06-01T12:00:00.000Z",+ }),+ makeThread({+ id: ThreadId.make("still-snoozed"),+ title: "Still snoozed",+ snoozedUntil: "2026-06-02T09:00:00.000Z",+ snoozedAt: "2026-06-01T12:00:00.000Z",+ }),+ ],+ environmentId: null,+ searchQuery: "",+ // Minute-floored partition clock vs precise snooze clock.+ now: "2026-06-02T00:01:00.000Z",+ snoozeNow: "2026-06-02T00:01:07.500Z",+ });++ expect(layout.items.map((item) => item.thread.id)).toEqual(["just-woke"]);+ expect(layout.snoozedCount).toBe(1);+ expect(layout.nextSnoozeWakeAt).toBe("2026-06-02T09:00:00.000Z");+ });++ it("keeps snoozed threads visible on environments without the snooze capability", () => {+ const layout = buildThreadListV2Items({+ threads: [+ makeThread({+ id: ThreadId.make("snoozed"),+ title: "Snoozed",+ snoozedUntil: "2026-06-03T09:00:00.000Z",+ snoozedAt: "2026-06-01T12:00:00.000Z",+ }),+ ],+ environmentId: null,+ searchQuery: "",+ snoozeEnvironmentIds: new Set(),+ now: NOW,+ });++ expect(layout.items.map((item) => item.thread.id)).toEqual(["snoozed"]);+ expect(layout.snoozedCount).toBe(0);+ });+it("partitions settled threads into a slim tail with one divider", () => {const { items } = buildThreadListV2Items({threads: [diff --git a/apps/mobile/src/features/threads/threadListV2.ts b/apps/mobile/src/features/threads/threadListV2.tsindex 071e1d93b..efa68153a 100644--- a/apps/mobile/src/features/threads/threadListV2.ts+++ b/apps/mobile/src/features/threads/threadListV2.ts@@ -1,4 +1,4 @@-import { effectiveSettled } from "@t3tools/client-runtime/state/thread-settled";+import { effectiveSettled, effectiveSnoozed } from "@t3tools/client-runtime/state/thread-settled";import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";import type { EnvironmentId, ProjectId } from "@t3tools/contracts";@@ -84,6 +84,13 @@ export interface ThreadListV2Layout {readonly items: ThreadListV2Item[];/** Settled threads beyond the render limit (behind "Show more"). */readonly hiddenSettledCount: number;+ /** Snoozed threads hidden from the list (visibility parity with web's+ collapsed Snoozed shelf; mobile has no shelf UI yet). */+ readonly snoozedCount: number;+ /** Soonest wake time among hidden snoozed threads, or null. Callers arm+ a timeout at this boundary so the list re-partitions the moment a+ snooze expires instead of on the next minute tick. */+ readonly nextSnoozeWakeAt: string | null;}/**@@ -106,13 +113,22 @@ export function buildThreadListV2Items(input: {other environments never classify as settled — the user could neitherun-settle nor pin them. Absent = no gating (tests). */readonly settlementEnvironmentIds?: ReadonlySet<EnvironmentId>;+ /** Environments whose server supports thread.snooze/unsnooze. Same+ contract as settlementEnvironmentIds. */+ readonly snoozeEnvironmentIds?: ReadonlySet<EnvironmentId>;readonly autoSettleAfterDays?: number;/** Max settled rows to render; the rest are counted, not built. */readonly settledLimit?: number;/** Injectable for tests; defaults to now. */readonly now?: string;+ /** Second-precise clock for snooze classification. Callers pass a+ minute-quantized `now` for memoization; snooze wake times are+ second-precise, so classifying with the floored minute would hold a+ woken thread hidden for up to a minute. Defaults to `now`. */+ readonly snoozeNow?: string;}): ThreadListV2Layout {const now = input.now ?? new Date().toISOString();+ const snoozeNow = input.snoozeNow ?? now;const autoSettleAfterDays = input.autoSettleAfterDays ?? 3;const query = input.searchQuery.trim().toLocaleLowerCase();const projectKeys = input.projectRefs@@ -121,6 +137,8 @@ export function buildThreadListV2Items(input: {const active: EnvironmentThreadShell[] = [];const settled: EnvironmentThreadShell[] = [];+ let snoozedCount = 0;+ let nextSnoozeWakeAt: string | null = null;for (const thread of input.threads) {// Callers pass live (unarchived) shells; settled threads are among them// and partition into the tail via effectiveSettled.@@ -130,8 +148,23 @@ export function buildThreadListV2Items(input: {}if (query.length > 0 && !thread.title.toLocaleLowerCase().includes(query)) continue;const supportsSettlement = input.settlementEnvironmentIds?.has(thread.environmentId) ?? true;+ const supportsSnooze = input.snoozeEnvironmentIds?.has(thread.environmentId) ?? true;const changeRequestState =input.changeRequestStateByKey?.get(`${thread.environmentId}:${thread.id}`) ?? null;+ // Visibility parity with web: a snoozed thread leaves the list until it+ // wakes (or raises its hand — effectiveSnoozed refuses blocked/failed+ // work). Snooze outranks settled classification, same as web.+ if (supportsSnooze && effectiveSnoozed(thread, { now: snoozeNow })) {+ snoozedCount += 1;+ if (+ thread.snoozedUntil != null &&+ (nextSnoozeWakeAt === null ||+ parseTimestampMs(thread.snoozedUntil) < parseTimestampMs(nextSnoozeWakeAt))+ ) {+ nextSnoozeWakeAt = thread.snoozedUntil;+ }+ continue;+ }if (supportsSettlement &&effectiveSettled(thread, { now, autoSettleAfterDays, changeRequestState })@@ -168,5 +201,10 @@ export function buildThreadListV2Items(input: {if (last) {items[items.length - 1] = { ...last, isLast: true };}- return { items, hiddenSettledCount: orderedSettled.length - visibleSettled.length };+ return {+ items,+ hiddenSettledCount: orderedSettled.length - visibleSettled.length,+ snoozedCount,+ nextSnoozeWakeAt,+ };}diff --git a/apps/mobile/src/state/use-thread-selection.ts b/apps/mobile/src/state/use-thread-selection.tsindex 80bc1916b..8e340ef33 100644--- a/apps/mobile/src/state/use-thread-selection.ts+++ b/apps/mobile/src/state/use-thread-selection.ts@@ -60,6 +60,8 @@ function threadDetailToShell(archivedAt: thread.archivedAt,settledOverride: thread.settledOverride,settledAt: thread.settledAt,+ snoozedUntil: thread.snoozedUntil ?? null,+ snoozedAt: thread.snoozedAt ?? null,session: thread.session,latestUserMessageAt: latestUserMessageAt(thread),hasPendingApprovals: false,diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.tsindex 181237d76..0eaf5a7c1 100644--- a/apps/server/src/environment/ServerEnvironment.ts+++ b/apps/server/src/environment/ServerEnvironment.ts@@ -141,6 +141,7 @@ export const make = Effect.gen(function* () {repositoryIdentity: true,connectionProbe: true,threadSettlement: true,+ threadSnooze: true,...(serverSelfUpdate === null ? {} : { serverSelfUpdate }),},};diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.tsindex cfb88a06c..1f24a4a02 100644--- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts+++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts@@ -609,6 +609,8 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjectiarchivedAt: null,settledOverride: null,settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,latestUserMessageAt: null,pendingApprovalCount: 0,pendingUserInputCount: 0,@@ -679,6 +681,38 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjectireturn;}+ case "thread.snoozed": {+ const existingRow = yield* projectionThreadRepository.getById({+ threadId: event.payload.threadId,+ });+ if (Option.isNone(existingRow)) {+ return;+ }+ yield* projectionThreadRepository.upsert({+ ...existingRow.value,+ snoozedUntil: event.payload.snoozedUntil,+ snoozedAt: event.payload.snoozedAt,+ updatedAt: event.payload.updatedAt,+ });+ return;+ }++ case "thread.unsnoozed": {+ const existingRow = yield* projectionThreadRepository.getById({+ threadId: event.payload.threadId,+ });+ if (Option.isNone(existingRow)) {+ return;+ }+ yield* projectionThreadRepository.upsert({+ ...existingRow.value,+ snoozedUntil: null,+ snoozedAt: null,+ updatedAt: event.payload.updatedAt,+ });+ return;+ }+case "thread.meta-updated": {const existingRow = yield* projectionThreadRepository.getById({threadId: event.payload.threadId,diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.tsindex 15ded458e..d4a24a209 100644--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts@@ -310,6 +310,8 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {archivedAt: null,settledOverride: null,settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,deletedAt: null,messages: [{@@ -422,6 +424,8 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {archivedAt: null,settledOverride: null,settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,session: {threadId: ThreadId.make("thread-1"),status: "running",diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.tsindex 155e9ab00..3d05bef4b 100644--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts@@ -336,6 +336,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archived_at AS "archivedAt",settled_override AS "settledOverride",settled_at AS "settledAt",+ snoozed_until AS "snoozedUntil",+ snoozed_at AS "snoozedAt",latest_user_message_at AS "latestUserMessageAt",pending_approval_count AS "pendingApprovalCount",pending_user_input_count AS "pendingUserInputCount",@@ -366,6 +368,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archived_at AS "archivedAt",settled_override AS "settledOverride",settled_at AS "settledAt",+ snoozed_until AS "snoozedUntil",+ snoozed_at AS "snoozedAt",latest_user_message_at AS "latestUserMessageAt",pending_approval_count AS "pendingApprovalCount",pending_user_input_count AS "pendingUserInputCount",@@ -398,6 +402,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archived_at AS "archivedAt",settled_override AS "settledOverride",settled_at AS "settledAt",+ snoozed_until AS "snoozedUntil",+ snoozed_at AS "snoozedAt",latest_user_message_at AS "latestUserMessageAt",pending_approval_count AS "pendingApprovalCount",pending_user_input_count AS "pendingUserInputCount",@@ -762,6 +768,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archived_at AS "archivedAt",settled_override AS "settledOverride",settled_at AS "settledAt",+ snoozed_until AS "snoozedUntil",+ snoozed_at AS "snoozedAt",latest_user_message_at AS "latestUserMessageAt",pending_approval_count AS "pendingApprovalCount",pending_user_input_count AS "pendingUserInputCount",@@ -1196,6 +1204,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archivedAt: row.archivedAt,settledOverride: row.settledOverride,settledAt: row.settledAt,+ snoozedUntil: row.snoozedUntil,+ snoozedAt: row.snoozedAt,deletedAt: row.deletedAt,messages: messagesByThread.get(row.threadId) ?? [],proposedPlans: proposedPlansByThread.get(row.threadId) ?? [],@@ -1396,6 +1406,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archivedAt: row.archivedAt,settledOverride: row.settledOverride,settledAt: row.settledAt,+ snoozedUntil: row.snoozedUntil,+ snoozedAt: row.snoozedAt,deletedAt: row.deletedAt,messages: [],proposedPlans: proposedPlansByThread.get(row.threadId) ?? [],@@ -1527,6 +1539,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archivedAt: row.archivedAt,settledOverride: row.settledOverride,settledAt: row.settledAt,+ snoozedUntil: row.snoozedUntil,+ snoozedAt: row.snoozedAt,session: sessionByThread.get(row.threadId) ?? null,latestUserMessageAt: row.latestUserMessageAt,hasPendingApprovals: row.pendingApprovalCount > 0,@@ -1663,6 +1677,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archivedAt: row.archivedAt,settledOverride: row.settledOverride,settledAt: row.settledAt,+ snoozedUntil: row.snoozedUntil,+ snoozedAt: row.snoozedAt,session: sessionByThread.get(row.threadId) ?? null,latestUserMessageAt: row.latestUserMessageAt,hasPendingApprovals: row.pendingApprovalCount > 0,@@ -1905,6 +1921,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archivedAt: threadRow.value.archivedAt,settledOverride: threadRow.value.settledOverride,settledAt: threadRow.value.settledAt,+ snoozedUntil: threadRow.value.snoozedUntil,+ snoozedAt: threadRow.value.snoozedAt,session: Option.isSome(sessionRow) ? mapSessionRow(sessionRow.value) : null,latestUserMessageAt: threadRow.value.latestUserMessageAt,hasPendingApprovals: threadRow.value.pendingApprovalCount > 0,@@ -2001,6 +2019,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {archivedAt: threadRow.value.archivedAt,settledOverride: threadRow.value.settledOverride,settledAt: threadRow.value.settledAt,+ snoozedUntil: threadRow.value.snoozedUntil,+ snoozedAt: threadRow.value.snoozedAt,deletedAt: null,messages: messageRows.map((row) => {const message = {diff --git a/apps/server/src/orchestration/Schemas.ts b/apps/server/src/orchestration/Schemas.tsindex 0d0d7bdd5..3b558d247 100644--- a/apps/server/src/orchestration/Schemas.ts+++ b/apps/server/src/orchestration/Schemas.ts@@ -11,6 +11,8 @@ import {ThreadDeletedPayload as ContractsThreadDeletedPayloadSchema,ThreadUnarchivedPayload as ContractsThreadUnarchivedPayloadSchema,ThreadUnsettledPayload as ContractsThreadUnsettledPayloadSchema,+ ThreadSnoozedPayload as ContractsThreadSnoozedPayloadSchema,+ ThreadUnsnoozedPayload as ContractsThreadUnsnoozedPayloadSchema,ThreadMessageSentPayload as ContractsThreadMessageSentPayloadSchema,ThreadProposedPlanUpsertedPayload as ContractsThreadProposedPlanUpsertedPayloadSchema,ThreadSessionSetPayload as ContractsThreadSessionSetPayloadSchema,@@ -38,6 +40,8 @@ export const ThreadInteractionModeSetPayload = ContractsThreadInteractionModeSetexport const ThreadDeletedPayload = ContractsThreadDeletedPayloadSchema;export const ThreadUnarchivedPayload = ContractsThreadUnarchivedPayloadSchema;export const ThreadUnsettledPayload = ContractsThreadUnsettledPayloadSchema;+export const ThreadSnoozedPayload = ContractsThreadSnoozedPayloadSchema;+export const ThreadUnsnoozedPayload = ContractsThreadUnsnoozedPayloadSchema;export const MessageSentPayloadSchema = ContractsThreadMessageSentPayloadSchema;export const ThreadProposedPlanUpsertedPayload = ContractsThreadProposedPlanUpsertedPayloadSchema;diff --git a/apps/server/src/orchestration/decider.snoozed.test.ts b/apps/server/src/orchestration/decider.snoozed.test.tsnew file mode 100644index 000000000..1012240b1--- /dev/null+++ b/apps/server/src/orchestration/decider.snoozed.test.ts@@ -0,0 +1,286 @@+import {+ CommandId,+ EventId,+ MessageId,+ ProjectId,+ ProviderInstanceId,+ ThreadId,+ type OrchestrationReadModel,+ type OrchestrationThread,+} from "@t3tools/contracts";+import * as NodeServices from "@effect/platform-node/NodeServices";+import { expect, it } from "@effect/vitest";+import * as Effect from "effect/Effect";++import { decideOrchestrationCommand } from "./decider.ts";++const NOW = "2026-01-01T00:00:00.000Z";+// The decider's clock is the Effect test clock, pinned to the epoch, so+// "future" wake times are relative to 1970-01-01T00:00:00.000Z.+const FUTURE_WAKE = "1970-01-02T09:00:00.000Z";+const PAST_WAKE = "1969-12-31T09:00:00.000Z";+const SNOOZED_AT = "1969-12-30T00:00:00.000Z";++function makeReadModel(input: {+ readonly snoozedUntil?: string | null;+ readonly snoozedAt?: string | null;+ readonly archivedAt?: string | null;+ readonly activities?: OrchestrationThread["activities"];+ readonly messages?: OrchestrationThread["messages"];+}): OrchestrationReadModel {+ return {+ snapshotSequence: 0,+ projects: [],+ threads: [+ {+ id: ThreadId.make("thread-1"),+ projectId: ProjectId.make("project-1"),+ title: "Thread",+ modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },+ runtimeMode: "full-access",+ interactionMode: "default",+ branch: null,+ worktreePath: null,+ latestTurn: null,+ createdAt: NOW,+ updatedAt: NOW,+ archivedAt: input.archivedAt ?? null,+ settledOverride: null,+ settledAt: null,+ snoozedUntil: input.snoozedUntil ?? null,+ snoozedAt: input.snoozedAt ?? (input.snoozedUntil != null ? SNOOZED_AT : null),+ deletedAt: null,+ messages: input.messages ?? [],+ proposedPlans: [],+ activities: input.activities ?? [],+ checkpoints: [],+ session: null,+ },+ ],+ updatedAt: NOW,+ };+}++it.layer(NodeServices.layer)("snoozed thread decider", (it) => {+ it.effect("snoozes a thread to a future wake time", () =>+ Effect.gen(function* () {+ const event = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: FUTURE_WAKE,+ },+ readModel: makeReadModel({}),+ });+ const events = Array.isArray(event) ? event : [event];+ expect(events).toHaveLength(1);+ expect(events[0]?.type).toBe("thread.snoozed");+ if (events[0]?.type === "thread.snoozed") {+ expect(events[0].payload.snoozedUntil).toBe(FUTURE_WAKE);+ expect(events[0].payload.snoozedAt).toBe(events[0].payload.updatedAt);+ }+ }),+ );++ it.effect("rejects a wake time that is not in the future", () =>+ Effect.gen(function* () {+ const error = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze-past"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: PAST_WAKE,+ },+ readModel: makeReadModel({}),+ }).pipe(Effect.flip);+ expect(error._tag).toBe("OrchestrationCommandInvariantError");+ }),+ );++ it.effect("rejects an unparseable wake time", () =>+ Effect.gen(function* () {+ // IsoDateTime is structurally a string, so garbage can reach the+ // decider; a NaN wake time must never persist as snooze state.+ const error = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze-garbage"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: "not-a-date",+ },+ readModel: makeReadModel({}),+ }).pipe(Effect.flip);+ expect(error._tag).toBe("OrchestrationCommandInvariantError");+ }),+ );++ it.effect("rejects snoozing blocked-on-you work", () =>+ Effect.gen(function* () {+ const requestActivity = {+ id: EventId.make("activity-req-1"),+ tone: "approval" as const,+ kind: "approval.requested",+ summary: "approval.requested",+ payload: { requestId: "req-1" },+ turnId: null,+ createdAt: NOW,+ } as OrchestrationThread["activities"][number];+ const error = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze-blocked"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: FUTURE_WAKE,+ },+ readModel: makeReadModel({ activities: [requestActivity] }),+ }).pipe(Effect.flip);+ expect(error._tag).toBe("OrchestrationCommandInvariantError");+ }),+ );++ it.effect("re-emits idempotently for a duplicate snooze to the same wake time", () =>+ Effect.gen(function* () {+ const reEmit = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze-again"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: FUTURE_WAKE,+ },+ readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),+ });+ const events = Array.isArray(reEmit) ? reEmit : [reEmit];+ expect(events).toHaveLength(1);+ if (events[0]?.type === "thread.snoozed") {+ // Original snoozedAt preserved; updatedAt must not churn.+ expect(events[0].payload.snoozedAt).toBe(SNOOZED_AT);+ expect(events[0].payload.updatedAt).toBe(NOW);+ }+ }),+ );++ it.effect("re-snoozing to a DIFFERENT wake time stamps fresh", () =>+ Effect.gen(function* () {+ const event = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze-extend"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: "1970-01-03T09:00:00.000Z",+ },+ readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),+ });+ const events = Array.isArray(event) ? event : [event];+ if (events[0]?.type === "thread.snoozed") {+ expect(events[0].payload.snoozedUntil).toBe("1970-01-03T09:00:00.000Z");+ expect(events[0].payload.updatedAt).not.toBe(NOW);+ }+ }),+ );++ it.effect("unsnoozes with reason user and re-emits idempotently when awake", () =>+ Effect.gen(function* () {+ const event = yield* decideOrchestrationCommand({+ command: {+ type: "thread.unsnooze",+ commandId: CommandId.make("cmd-unsnooze"),+ threadId: ThreadId.make("thread-1"),+ reason: "user",+ },+ readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),+ });+ const events = Array.isArray(event) ? event : [event];+ expect(events[0]?.type).toBe("thread.unsnoozed");+ if (events[0]?.type === "thread.unsnoozed") {+ expect(events[0].payload.reason).toBe("user");+ expect(events[0].payload.updatedAt).not.toBe(NOW);+ }++ const awake = yield* decideOrchestrationCommand({+ command: {+ type: "thread.unsnooze",+ commandId: CommandId.make("cmd-unsnooze-awake"),+ threadId: ThreadId.make("thread-1"),+ reason: "user",+ },+ readModel: makeReadModel({}),+ });+ const awakeEvents = Array.isArray(awake) ? awake : [awake];+ expect(awakeEvents[0]?.type).toBe("thread.unsnoozed");+ if (awakeEvents[0]?.type === "thread.unsnoozed") {+ // No state change — keep the existing updatedAt.+ expect(awakeEvents[0].payload.updatedAt).toBe(NOW);+ }+ }),+ );++ it.effect("rejects snoozing a thread with a queued turn start", () =>+ Effect.gen(function* () {+ // The decider clock is the Effect test clock pinned to the epoch: a+ // user message 30s before it with no adopting turn is queued work.+ const queuedMessage = {+ id: MessageId.make("message-queued"),+ role: "user",+ text: "Continue",+ turnId: null,+ streaming: false,+ createdAt: "1969-12-31T23:59:30.000Z",+ updatedAt: "1969-12-31T23:59:30.000Z",+ } as OrchestrationThread["messages"][number];+ const error = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze-queued"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: FUTURE_WAKE,+ },+ readModel: makeReadModel({ messages: [queuedMessage] }),+ }).pipe(Effect.flip);+ expect(error._tag).toBe("OrchestrationCommandInvariantError");+ }),+ );++ it.effect("rejects snoozing an archived thread", () =>+ Effect.gen(function* () {+ const error = yield* decideOrchestrationCommand({+ command: {+ type: "thread.snooze",+ commandId: CommandId.make("cmd-snooze-archived"),+ threadId: ThreadId.make("thread-1"),+ snoozedUntil: FUTURE_WAKE,+ },+ readModel: makeReadModel({ archivedAt: NOW }),+ }).pipe(Effect.flip);+ expect(error._tag).toBe("OrchestrationCommandInvariantError");+ }),+ );++ it.effect("a user message spends the snooze return ticket (activity wake)", () =>+ Effect.gen(function* () {+ const result = yield* decideOrchestrationCommand({+ command: {+ type: "thread.turn.start",+ commandId: CommandId.make("cmd-turn-start"),+ threadId: ThreadId.make("thread-1"),+ message: {+ messageId: MessageId.make("message-1"),+ role: "user",+ text: "Continue",+ attachments: [],+ },+ runtimeMode: "full-access",+ interactionMode: "default",+ createdAt: NOW,+ },+ readModel: makeReadModel({ snoozedUntil: FUTURE_WAKE }),+ });+ const events = Array.isArray(result) ? result : [result];+ const unsnoozed = events.find((entry) => entry.type === "thread.unsnoozed");+ expect(unsnoozed).toBeDefined();+ if (unsnoozed?.type === "thread.unsnoozed") {+ expect(unsnoozed.payload.reason).toBe("activity");+ }+ }),+ );+});diff --git a/apps/server/src/orchestration/decider.ts b/apps/server/src/orchestration/decider.tsindex cba967afc..100369ae6 100644--- a/apps/server/src/orchestration/decider.ts+++ b/apps/server/src/orchestration/decider.ts@@ -53,6 +53,13 @@ function isStaleRequestFailureDetail(payload: Record<string, unknown> | null): b);}+// Scans the read model's activities, which the projector caps at the most+// recent 500. That bound is safe here: an OPEN approval/user-input request+// blocks its turn, so the thread cannot accumulate hundreds of later+// activities while one is outstanding — a request that has scrolled out of+// the window is one whose turn kept running, i.e. it was resolved or went+// stale. (The projection pipeline's pendingApprovalCount reads the same+// capped stream and stays consistent with this view.)function hasOpenBlockingRequest(thread: {readonly activities: ReadonlyArray<{ readonly kind: string; readonly payload: unknown }>;}): boolean {@@ -79,6 +86,62 @@ function hasOpenBlockingRequest(thread: {return openRequestIds.size > 0;}+/**+ * A queued turn start — a user message no turn has picked up yet — is work+ * in flight even though session is still null (turn.start emits+ * message-sent + turn-start-requested; the session arrives later). Detection+ * mirrors the client's hasQueuedTurnStart: the newest user message is+ * strictly newer than every latestTurn timestamp (adoption stamps the new+ * turn's requestedAt with the message time, clearing this), and only within+ * the adoption grace window — historical threads whose last user message+ * postdates their turn timestamps (older-server data, mid-turn messages)+ * must not be blocked forever. A failed session start (status "error")+ * clears the block immediately.+ *+ * The age check is bounded on BOTH sides: message timestamps are+ * client-supplied, so a client clock ahead of the server yields a negative+ * age. Without the lower bound that negative age satisfies `<= grace` for+ * as long as the skew lasts, extending the block far past the intended two+ * minutes.+ */+function threadHasQueuedTurnStart(+ thread: {+ readonly messages: ReadonlyArray<{ readonly role: string; readonly createdAt: string }>;+ readonly latestTurn: {+ readonly requestedAt: string;+ readonly startedAt: string | null;+ readonly completedAt: string | null;+ } | null;+ readonly session: { readonly status: string } | null;+ },+ occurredAt: string,+): boolean {+ const latestUserMessageAtMs = thread.messages.reduce(+ (latest, message) =>+ message.role === "user" ? Math.max(latest, Date.parse(message.createdAt)) : latest,+ Number.NEGATIVE_INFINITY,+ );+ const latestTurnAtMs =+ thread.latestTurn === null+ ? Number.NEGATIVE_INFINITY+ : Math.max(+ ...[+ thread.latestTurn.requestedAt,+ thread.latestTurn.startedAt,+ thread.latestTurn.completedAt,+ ].map((candidate) =>+ candidate == null ? Number.NEGATIVE_INFINITY : Date.parse(candidate),+ ),+ );+ const queuedAgeMs = Date.parse(occurredAt) - latestUserMessageAtMs;+ return (+ thread.session?.status !== "error" &&+ Number.isFinite(latestUserMessageAtMs) &&+ latestUserMessageAtMs > latestTurnAtMs &&+ Math.abs(queuedAgeMs) <= QUEUED_TURN_START_GRACE_MS+ );+}+function withEventBase(input: Pick<OrchestrationCommand, "commandId"> & {readonly aggregateKind: OrchestrationEvent["aggregateKind"];@@ -411,46 +474,8 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand");}const occurredAt = yield* nowIso;- // A queued turn start — a user message no turn has picked up yet — is- // work in flight even though session is still null (turn.start emits- // message-sent + turn-start-requested; the session arrives later).- // Settling in that window would hide just-requested work. Detection- // mirrors the client's hasQueuedTurnStart: the newest user message is- // strictly newer than every latestTurn timestamp (adoption stamps the- // new turn's requestedAt with the message time, clearing this), and- // only within the adoption grace window — historical threads whose- // last user message postdates their turn timestamps (older-server- // data, mid-turn messages) must stay settleable. A failed session- // start (status "error") clears the block immediately.- const latestUserMessageAtMs = thread.messages.reduce(- (latest, message) =>- message.role === "user" ? Math.max(latest, Date.parse(message.createdAt)) : latest,- Number.NEGATIVE_INFINITY,- );- const latestTurnAtMs =- thread.latestTurn === null- ? Number.NEGATIVE_INFINITY- : Math.max(- ...[- thread.latestTurn.requestedAt,- thread.latestTurn.startedAt,- thread.latestTurn.completedAt,- ].map((candidate) =>- candidate == null ? Number.NEGATIVE_INFINITY : Date.parse(candidate),- ),- );- // The age check is bounded on BOTH sides: message timestamps are- // client-supplied, so a client clock ahead of the server yields a- // negative age. Without the lower bound that negative age satisfies- // `<= grace` for as long as the skew lasts, extending the settle- // block far past the intended two minutes.- const queuedAgeMs = Date.parse(occurredAt) - latestUserMessageAtMs;- const hasQueuedTurnStart =- thread.session?.status !== "error" &&- Number.isFinite(latestUserMessageAtMs) &&- latestUserMessageAtMs > latestTurnAtMs &&- Math.abs(queuedAgeMs) <= QUEUED_TURN_START_GRACE_MS;- if (hasQueuedTurnStart) {+ // Settling inside the adoption window would hide just-requested work.+ if (threadHasQueuedTurnStart(thread, occurredAt)) {return yield* Effect.fail(new OrchestrationCommandInvariantError({commandType: command.type,@@ -508,6 +533,103 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"};}+ case "thread.snooze": {+ const thread = yield* requireThreadNotArchived({+ readModel,+ command,+ threadId: command.threadId,+ });+ const occurredAt = yield* nowIso;+ // A wake time in the past would create a thread that is snoozed and+ // woken at once — the row would never leave the inbox but still carry+ // snooze state. Reject instead of silently normalizing. The negated+ // comparison also catches unparseable wake times (IsoDateTime is+ // structurally just a string): NaN fails every comparison, and an+ // unparseable snoozedUntil must never persist.+ if (!(Date.parse(command.snoozedUntil) > Date.parse(occurredAt))) {+ return yield* Effect.fail(+ new OrchestrationCommandInvariantError({+ commandType: command.type,+ detail: `thread ${command.threadId} snooze wake time ${command.snoozedUntil} is not in the future`,+ }),+ );+ }+ // Blocked-on-you work must not be snoozed away: a pending approval or+ // user-input request is the agent waiting on the user, and hiding it+ // defeats the request. (A running session IS snoozable — snooze only+ // affects visibility, never the agent.)+ if (hasOpenBlockingRequest(thread)) {+ return yield* Effect.fail(+ new OrchestrationCommandInvariantError({+ commandType: command.type,+ detail: `thread ${command.threadId} has a pending approval or user-input request and cannot be snoozed`,+ }),+ );+ }+ // A queued turn start — a user message no turn has adopted yet — is+ // invisible pending work: no session, no pending flags. Snoozing in+ // that window would hide a just-requested turn exactly the way settle+ // would.+ if (threadHasQueuedTurnStart(thread, occurredAt)) {+ return yield* Effect.fail(+ new OrchestrationCommandInvariantError({+ commandType: command.type,+ detail: `thread ${command.threadId} has a queued turn start and cannot be snoozed`,+ }),+ );+ }+ // Re-snoozing an already-snoozed thread to the SAME wake time is a+ // duplicate (double-click, raced clients): re-emit with the original+ // timestamps so the projection is a no-op. A different wake time is a+ // real change and stamps fresh.+ const existingSnoozedAt =+ thread.snoozedUntil === command.snoozedUntil && thread.snoozedAt != null+ ? thread.snoozedAt+ : null;+ return {+ ...(yield* withEventBase({+ aggregateKind: "thread",+ aggregateId: command.threadId,+ occurredAt,+ commandId: command.commandId,+ })),+ type: "thread.snoozed",+ payload: {+ threadId: command.threadId,+ snoozedUntil: command.snoozedUntil,+ snoozedAt: existingSnoozedAt ?? occurredAt,+ updatedAt: existingSnoozedAt !== null ? thread.updatedAt : occurredAt,+ },+ };+ }++ case "thread.unsnooze": {+ const thread = yield* requireThreadNotArchived({+ readModel,+ command,+ threadId: command.threadId,+ });+ // Idempotent by re-emission (see thread.settle): waking a thread that+ // is not snoozed lands on the same null state without churning+ // updatedAt.+ const alreadyAwake = thread.snoozedUntil == null;+ const occurredAt = yield* nowIso;+ return {+ ...(yield* withEventBase({+ aggregateKind: "thread",+ aggregateId: command.threadId,+ occurredAt,+ commandId: command.commandId,+ })),+ type: "thread.unsnoozed",+ payload: {+ threadId: command.threadId,+ reason: command.reason,+ updatedAt: alreadyAwake ? thread.updatedAt : occurredAt,+ },+ };+ }+case "thread.meta.update": {const thread = yield* requireThread({readModel,@@ -663,24 +785,42 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"// Real activity resets ANY override: it wakes an explicitly settled// thread, and it clears a keep-active pin back to neutral so the// thread can auto-settle again after this burst of work goes stale.- if (targetThread.settledOverride === null) {- return [userMessageEvent, turnStartRequestedEvent];+ // A snooze clears the same way — sending a message to a snoozed+ // thread is the user re-engaging, so the return ticket is spent.+ const lifecycleResetEvents: Array<Omit<OrchestrationEvent, "sequence">> = [];+ if (targetThread.settledOverride !== null) {+ lifecycleResetEvents.push({+ ...(yield* withEventBase({+ aggregateKind: "thread",+ aggregateId: command.threadId,+ occurredAt: command.createdAt,+ commandId: command.commandId,+ })),+ type: "thread.unsettled",+ payload: {+ threadId: command.threadId,+ reason: "activity",+ updatedAt: command.createdAt,+ },+ });}- const unsettledEvent: Omit<OrchestrationEvent, "sequence"> = {- ...(yield* withEventBase({- aggregateKind: "thread",- aggregateId: command.threadId,- occurredAt: command.createdAt,- commandId: command.commandId,- })),- type: "thread.unsettled",- payload: {- threadId: command.threadId,- reason: "activity",- updatedAt: command.createdAt,- },- };- return [unsettledEvent, userMessageEvent, turnStartRequestedEvent];+ if (targetThread.snoozedUntil != null) {+ lifecycleResetEvents.push({+ ...(yield* withEventBase({+ aggregateKind: "thread",+ aggregateId: command.threadId,+ occurredAt: command.createdAt,+ commandId: command.commandId,+ })),+ type: "thread.unsnoozed",+ payload: {+ threadId: command.threadId,+ reason: "activity",+ updatedAt: command.createdAt,+ },+ });+ }+ return [...lifecycleResetEvents, userMessageEvent, turnStartRequestedEvent];}case "thread.turn.interrupt": {@@ -822,7 +962,12 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"};// Only a session coming alive is activity worth waking a settled thread// for — status writes like ready/stopped/error arrive after the fact and- // must not fight a user's explicit settle.+ // must not fight a user's explicit settle. Snooze is deliberately NOT+ // cleared here: snooze never pauses the agent, so its session starting+ // or erroring is not the user re-engaging. Blocked/failed work still+ // surfaces immediately — effectiveSnoozed refuses to classify a thread+ // with a raised hand (approval / input / failure / fresh completion)+ // as snoozed, without spending the return ticket.const isSessionActivity =command.session.status === "starting" || command.session.status === "running";// Real activity resets ANY override (settled wakes, active unpins).diff --git a/apps/server/src/orchestration/projector.test.ts b/apps/server/src/orchestration/projector.test.tsindex e9a55c079..9c07a3120 100644--- a/apps/server/src/orchestration/projector.test.ts+++ b/apps/server/src/orchestration/projector.test.ts@@ -91,6 +91,8 @@ describe("orchestration projector", () => {archivedAt: null,settledOverride: null,settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,deletedAt: null,messages: [],proposedPlans: [],diff --git a/apps/server/src/orchestration/projector.ts b/apps/server/src/orchestration/projector.tsindex c8f47dceb..0504cb36f 100644--- a/apps/server/src/orchestration/projector.ts+++ b/apps/server/src/orchestration/projector.ts@@ -23,8 +23,10 @@ import {ThreadProposedPlanUpsertedPayload,ThreadRuntimeModeSetPayload,ThreadSettledPayload,+ ThreadSnoozedPayload,ThreadUnarchivedPayload,ThreadUnsettledPayload,+ ThreadUnsnoozedPayload,ThreadRevertedPayload,ThreadSessionSetPayload,ThreadTurnDiffCompletedPayload,@@ -290,6 +292,8 @@ export function projectEvent(archivedAt: null,settledOverride: null,settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,deletedAt: null,messages: [],activities: [],@@ -365,6 +369,30 @@ export function projectEvent(})),);+ case "thread.snoozed":+ return decodeForEvent(ThreadSnoozedPayload, event.payload, event.type, "payload").pipe(+ Effect.map((payload) => ({+ ...nextBase,+ threads: updateThread(nextBase.threads, payload.threadId, {+ snoozedUntil: payload.snoozedUntil,+ snoozedAt: payload.snoozedAt,+ updatedAt: payload.updatedAt,+ }),+ })),+ );++ case "thread.unsnoozed":+ return decodeForEvent(ThreadUnsnoozedPayload, event.payload, event.type, "payload").pipe(+ Effect.map((payload) => ({+ ...nextBase,+ threads: updateThread(nextBase.threads, payload.threadId, {+ snoozedUntil: null,+ snoozedAt: null,+ updatedAt: payload.updatedAt,+ }),+ })),+ );+case "thread.meta-updated":return decodeForEvent(ThreadMetaUpdatedPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => ({diff --git a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts b/apps/server/src/persistence/Layers/ProjectionRepositories.test.tsindex 497aa8b7d..4763f5656 100644--- a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts+++ b/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts@@ -93,6 +93,8 @@ projectionRepositoriesLayer("Projection repositories", (it) => {archivedAt: null,settledOverride: null,settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,latestUserMessageAt: null,pendingApprovalCount: 0,pendingUserInputCount: 0,@@ -153,6 +155,8 @@ projectionRepositoriesLayer("Projection repositories", (it) => {archivedAt: null,settledOverride: "settled",settledAt: "2026-03-25T00:00:00.000Z",+ snoozedUntil: "2026-03-26T09:00:00.000Z",+ snoozedAt: "2026-03-25T00:00:00.000Z",latestUserMessageAt: null,pendingApprovalCount: 0,pendingUserInputCount: 0,@@ -169,12 +173,17 @@ projectionRepositoriesLayer("Projection repositories", (it) => {}assert.strictEqual(row.settledOverride, "settled");assert.strictEqual(row.settledAt, "2026-03-25T00:00:00.000Z");+ assert.strictEqual(row.snoozedUntil, "2026-03-26T09:00:00.000Z");+ assert.strictEqual(row.snoozedAt, "2026-03-25T00:00:00.000Z");- // Un-settle to the keep-active pin and confirm the flip persists.+ // Un-settle to the keep-active pin and wake the snooze; confirm the+ // flips persist.yield* threads.upsert({...row,settledOverride: "active",settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,});const repersisted = yield* threads.getById({threadId: ThreadId.make("thread-settled"),@@ -182,6 +191,8 @@ projectionRepositoriesLayer("Projection repositories", (it) => {const updated = Option.getOrNull(repersisted);assert.strictEqual(updated?.settledOverride, "active");assert.strictEqual(updated?.settledAt, null);+ assert.strictEqual(updated?.snoozedUntil, null);+ assert.strictEqual(updated?.snoozedAt, null);}),);});diff --git a/apps/server/src/persistence/Layers/ProjectionThreads.ts b/apps/server/src/persistence/Layers/ProjectionThreads.tsindex e0c85e914..7e86d49ea 100644--- a/apps/server/src/persistence/Layers/ProjectionThreads.ts+++ b/apps/server/src/persistence/Layers/ProjectionThreads.ts@@ -45,6 +45,8 @@ const makeProjectionThreadRepository = Effect.gen(function* () {archived_at,settled_override,settled_at,+ snoozed_until,+ snoozed_at,latest_user_message_at,pending_approval_count,pending_user_input_count,@@ -66,6 +68,8 @@ const makeProjectionThreadRepository = Effect.gen(function* () {${row.archivedAt},${row.settledOverride},${row.settledAt},+ ${row.snoozedUntil},+ ${row.snoozedAt},${row.latestUserMessageAt},${row.pendingApprovalCount},${row.pendingUserInputCount},@@ -87,6 +91,8 @@ const makeProjectionThreadRepository = Effect.gen(function* () {archived_at = excluded.archived_at,settled_override = excluded.settled_override,settled_at = excluded.settled_at,+ snoozed_until = excluded.snoozed_until,+ snoozed_at = excluded.snoozed_at,latest_user_message_at = excluded.latest_user_message_at,pending_approval_count = excluded.pending_approval_count,pending_user_input_count = excluded.pending_user_input_count,@@ -115,6 +121,8 @@ const makeProjectionThreadRepository = Effect.gen(function* () {archived_at AS "archivedAt",settled_override AS "settledOverride",settled_at AS "settledAt",+ snoozed_until AS "snoozedUntil",+ snoozed_at AS "snoozedAt",latest_user_message_at AS "latestUserMessageAt",pending_approval_count AS "pendingApprovalCount",pending_user_input_count AS "pendingUserInputCount",@@ -145,6 +153,8 @@ const makeProjectionThreadRepository = Effect.gen(function* () {archived_at AS "archivedAt",settled_override AS "settledOverride",settled_at AS "settledAt",+ snoozed_until AS "snoozedUntil",+ snoozed_at AS "snoozedAt",latest_user_message_at AS "latestUserMessageAt",pending_approval_count AS "pendingApprovalCount",pending_user_input_count AS "pendingUserInputCount",diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.tsindex cacb2c85b..d25895671 100644--- a/apps/server/src/persistence/Migrations.ts+++ b/apps/server/src/persistence/Migrations.ts@@ -46,6 +46,7 @@ import Migration0030 from "./Migrations/030_ProjectionThreadShellArchiveIndexes.import Migration0031 from "./Migrations/031_AuthAuthorizationScopes.ts";import Migration0032 from "./Migrations/032_AuthPairingProofKeyThumbprint.ts";import Migration0033 from "./Migrations/033_ProjectionThreadsSettled.ts";+import Migration0034 from "./Migrations/034_ProjectionThreadsSnoozed.ts";/*** Migration loader with all migrations defined inline.@@ -91,6 +92,7 @@ export const migrationEntries = [[31, "AuthAuthorizationScopes", Migration0031],[32, "AuthPairingProofKeyThumbprint", Migration0032],[33, "ProjectionThreadsSettled", Migration0033],+ [34, "ProjectionThreadsSnoozed", Migration0034],] as const;export const makeMigrationLoader = (throughId?: number) =>diff --git a/apps/server/src/persistence/Migrations/034_ProjectionThreadsSnoozed.ts b/apps/server/src/persistence/Migrations/034_ProjectionThreadsSnoozed.tsnew file mode 100644index 000000000..5259ae445--- /dev/null+++ b/apps/server/src/persistence/Migrations/034_ProjectionThreadsSnoozed.ts@@ -0,0 +1,23 @@+import * as Effect from "effect/Effect";+import * as SqlClient from "effect/unstable/sql/SqlClient";++export default Effect.gen(function* () {+ const sql = yield* SqlClient.SqlClient;+ const columns = yield* sql<{ readonly name: string }>`+ PRAGMA table_info(projection_threads)+ `;++ if (!columns.some((column) => column.name === "snoozed_until")) {+ yield* sql`+ ALTER TABLE projection_threads+ ADD COLUMN snoozed_until TEXT+ `;+ }++ if (!columns.some((column) => column.name === "snoozed_at")) {+ yield* sql`+ ALTER TABLE projection_threads+ ADD COLUMN snoozed_at TEXT+ `;+ }+});diff --git a/apps/server/src/persistence/Services/ProjectionThreads.ts b/apps/server/src/persistence/Services/ProjectionThreads.tsindex 8057d4349..056425ae8 100644--- a/apps/server/src/persistence/Services/ProjectionThreads.ts+++ b/apps/server/src/persistence/Services/ProjectionThreads.ts@@ -38,6 +38,8 @@ export const ProjectionThread = Schema.Struct({archivedAt: Schema.NullOr(IsoDateTime),settledOverride: Schema.NullOr(Schema.Literals(["settled", "active"])),settledAt: Schema.NullOr(IsoDateTime),+ snoozedUntil: Schema.NullOr(IsoDateTime),+ snoozedAt: Schema.NullOr(IsoDateTime),latestUserMessageAt: Schema.NullOr(IsoDateTime),pendingApprovalCount: NonNegativeInt,pendingUserInputCount: NonNegativeInt,diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex 63750e910..ab1256cdd 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -25,7 +25,7 @@ import {connectionStatusTitle,type EnvironmentConnectionPresentation,} from "@t3tools/client-runtime/connection";-import { effectiveSettled } from "@t3tools/client-runtime/state/thread-settled";+import { effectiveSettled, effectiveSnoozed } from "@t3tools/client-runtime/state/thread-settled";import {parseScopedThreadKey,scopedThreadKey,@@ -140,6 +140,7 @@ import { resolveShortcutCommand, shortcutLabelForCommand } from "../keybindings"import PlanSidebar from "./PlanSidebar";import ThreadTerminalDrawer from "./ThreadTerminalDrawer";import {+ AlarmClockIcon,CheckCircle2Icon,ChevronDownIcon,GitBranchIcon,@@ -3844,7 +3845,24 @@ function ChatViewContent(props: ChatViewProps) {hasDedicatedWorktree: (activeThread?.worktreePath ?? null) !== null,});const supportsSettlement = serverConfig?.environment.capabilities.threadSettlement === true;+ const supportsSnooze = serverConfig?.environment.capabilities.threadSnooze === true;const nowMinute = useNowMinute();+ const activeThreadSnoozed =+ activeThreadShell !== null &&+ supportsSnooze &&+ effectiveSnoozed(activeThreadShell, { now: new Date().toISOString() });+ const [snoozeWakeTick, bumpSnoozeWakeTick] = useState(0);+ useEffect(() => {+ void snoozeWakeTick;+ if (!activeThreadSnoozed) return;+ const wakeAtMs = Date.parse(activeThreadShell?.snoozedUntil ?? "");+ if (!Number.isFinite(wakeAtMs)) return;+ const id = window.setTimeout(+ () => bumpSnoozeWakeTick((tick) => tick + 1),+ Math.min(Math.max(0, wakeAtMs - Date.now()) + 50, 2_147_483_647),+ );+ return () => window.clearTimeout(id);+ }, [activeThreadShell?.snoozedUntil, activeThreadSnoozed, snoozeWakeTick]);const activeThreadSettled = useMemo(() => {if (activeThreadShell === null || !supportsSettlement) return false;return effectiveSettled(activeThreadShell, {@@ -3890,6 +3908,34 @@ function ChatViewContent(props: ChatViewProps) {setUnsettlingThreadKey((current) => (current === threadKey ? null : current));}}, [activeThreadRef, unsettleThreadMutation]);+ const unsnoozeThreadMutation = useAtomCommand(threadEnvironment.unsnooze, {+ reportFailure: false,+ });+ const [unsnoozingThreadKey, setUnsnoozingThreadKey] = useState<string | null>(null);+ const isUnsnoozing = unsnoozingThreadKey !== null && unsnoozingThreadKey === activeThreadKey;+ const handleUnsnoozeActiveThread = useCallback(async () => {+ if (!activeThreadRef) return;+ const threadKey = scopedThreadKey(activeThreadRef);+ setUnsnoozingThreadKey(threadKey);+ try {+ const result = await unsnoozeThreadMutation({+ environmentId: activeThreadRef.environmentId,+ input: { threadId: activeThreadRef.threadId, reason: "user" },+ });+ if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {+ const error = squashAtomCommandFailure(result);+ toastManager.add(+ stackedThreadToast({+ type: "error",+ title: "Failed to wake thread",+ description: error instanceof Error ? error.message : "An error occurred.",+ }),+ );+ }+ } finally {+ setUnsnoozingThreadKey((current) => (current === threadKey ? null : current));+ }+ }, [activeThreadRef, unsnoozeThreadMutation]);const [isRestoringThreadBranch, setIsRestoringThreadBranch] = useState(false);const [branchRestoreConfirmOpen, setBranchRestoreConfirmOpen] = useState(false);// Once revealed for a given mismatch, the banner stays mounted until the@@ -3999,29 +4045,48 @@ function ChatViewContent(props: ChatViewProps) {]);// The stack renders items[0] front-most and tucks the rest behind hover, so// ordering is priority: system banners, then the branch-mismatch notice,- // and the informational settled banner last — it must never cover another.- const settledComposerBannerItem = useMemo<ComposerBannerStackItem | null>(() => {- if (!activeThreadSettled) {+ // and the informational parked-thread banner last — it must never cover another.+ const parkedThreadBannerItem = useMemo<ComposerBannerStackItem | null>(() => {+ if (!activeThreadSnoozed && !activeThreadSettled) {return null;}+ const isSnoozed = activeThreadSnoozed;return {- id: `thread-settled:${activeThread?.id ?? "unknown"}`,+ id: `thread-${isSnoozed ? "snoozed" : "settled"}:${activeThread?.id ?? "unknown"}`,variant: "info",- icon: <CheckCircle2Icon />,- title: "This thread is settled",- description: "Sending a message moves it back to Active in the sidebar.",+ icon: isSnoozed ? <AlarmClockIcon /> : <CheckCircle2Icon />,+ title: `This thread is ${isSnoozed ? "snoozed" : "settled"}`,+ description: isSnoozed+ ? "Sending a message wakes it and moves it back to Active in the sidebar."+ : "Sending a message moves it back to Active in the sidebar.",actions: (<Buttonsize="xs"variant="outline"- disabled={isUnsettling}- onClick={() => void handleUnsettleActiveThread()}+ disabled={isSnoozed ? isUnsnoozing : isUnsettling}+ onClick={() =>+ void (isSnoozed ? handleUnsnoozeActiveThread() : handleUnsettleActiveThread())+ }>- {isUnsettling ? "Un-settling..." : "Un-settle"}+ {isSnoozed+ ? isUnsnoozing+ ? "Waking..."+ : "Wake now"+ : isUnsettling+ ? "Un-settling..."+ : "Un-settle"}</Button>),};- }, [activeThread?.id, activeThreadSettled, handleUnsettleActiveThread, isUnsettling]);+ }, [+ activeThread?.id,+ activeThreadSettled,+ activeThreadSnoozed,+ handleUnsnoozeActiveThread,+ handleUnsettleActiveThread,+ isUnsnoozing,+ isUnsettling,+ ]);const handleRestoreThreadBranch = useCallback(() => {if (gitStatusQuery.data?.hasWorkingTreeChanges) {setBranchRestoreConfirmOpen(true);@@ -4030,9 +4095,9 @@ function ChatViewContent(props: ChatViewProps) {void handleSwitchCheckoutToThread();}, [gitStatusQuery.data?.hasWorkingTreeChanges, handleSwitchCheckoutToThread]);const composerBannerItems = useMemo<ComposerBannerStackItem[]>(() => {- const settledItems = settledComposerBannerItem === null ? [] : [settledComposerBannerItem];+ const parkedThreadItems = parkedThreadBannerItem === null ? [] : [parkedThreadBannerItem];if (!localCheckoutBranchMismatch || !showBranchMismatchBanner || !activeBranchMismatchKey) {- return [...systemComposerBannerItems, ...settledItems];+ return [...systemComposerBannerItems, ...parkedThreadItems];}return [...systemComposerBannerItems,@@ -4075,14 +4140,14 @@ function ChatViewContent(props: ChatViewProps) {setBranchMismatchDismissTick((tick) => tick + 1);},},- ...settledItems,+ ...parkedThreadItems,];}, [activeBranchMismatchKey,handleRestoreThreadBranch,isRestoringThreadBranch,localCheckoutBranchMismatch,- settledComposerBannerItem,+ parkedThreadBannerItem,showBranchMismatchBanner,systemComposerBannerItems,]);diff --git a/apps/web/src/components/Sidebar.snooze.test.ts b/apps/web/src/components/Sidebar.snooze.test.tsnew file mode 100644index 000000000..4a4518a25--- /dev/null+++ b/apps/web/src/components/Sidebar.snooze.test.ts@@ -0,0 +1,94 @@+import { describe, expect, it } from "vite-plus/test";++import { resolveSnoozePresets, snoozeWakeDescription, snoozeWakeLabel } from "./Sidebar.snooze";++// Local-time constructor so preset math is timezone-stable in tests.+function localDate(year: number, month: number, day: number, hour: number, minute = 0): Date {+ return new Date(year, month - 1, day, hour, minute, 0, 0);+}++describe("resolveSnoozePresets", () => {+ it("offers hour, evening, tomorrow, next week in the morning", () => {+ // Wednesday 2026-04-08 10:00 local.+ const presets = resolveSnoozePresets(localDate(2026, 4, 8, 10));+ expect(presets.map((preset) => preset.id)).toEqual([+ "hour",+ "evening",+ "tomorrow",+ "next-week",+ ]);+ const evening = presets.find((preset) => preset.id === "evening");+ expect(new Date(evening!.snoozedUntil).getHours()).toBe(18);+ const tomorrow = presets.find((preset) => preset.id === "tomorrow");+ const tomorrowDate = new Date(tomorrow!.snoozedUntil);+ expect(tomorrowDate.getDate()).toBe(9);+ expect(tomorrowDate.getHours()).toBe(9);+ const nextWeek = presets.find((preset) => preset.id === "next-week");+ const nextWeekDate = new Date(nextWeek!.snoozedUntil);+ expect(nextWeekDate.getDay()).toBe(1);+ expect(nextWeekDate.getDate()).toBe(13);+ });++ it("whenLabel complements the label instead of repeating it", () => {+ const presets = resolveSnoozePresets(localDate(2026, 4, 8, 10));+ for (const preset of presets) {+ // Day words live in the label column; the time column is time-only+ // (plus a weekday for next week, which names a different day).+ expect(preset.whenLabel.toLowerCase()).not.toContain("tomorrow");+ }+ const tomorrow = presets.find((preset) => preset.id === "tomorrow");+ expect(tomorrow!.whenLabel).toMatch(/9/);+ const nextWeek = presets.find((preset) => preset.id === "next-week");+ expect(nextWeek!.whenLabel).toMatch(/Mon/);+ });++ it("drops the evening preset once evening is near or past", () => {+ expect(resolveSnoozePresets(localDate(2026, 4, 8, 17, 30)).map((preset) => preset.id)).toEqual([+ "hour",+ "tomorrow",+ "next-week",+ ]);+ expect(resolveSnoozePresets(localDate(2026, 4, 8, 21)).map((preset) => preset.id)).toEqual([+ "hour",+ "tomorrow",+ "next-week",+ ]);+ });++ it("puts next week a full week out when today is Monday", () => {+ // Monday 2026-04-06.+ const presets = resolveSnoozePresets(localDate(2026, 4, 6, 10));+ const nextWeek = new Date(presets.find((preset) => preset.id === "next-week")!.snoozedUntil);+ expect(nextWeek.getDay()).toBe(1);+ expect(nextWeek.getDate()).toBe(13);+ });+});++describe("snoozeWakeLabel", () => {+ const now = localDate(2026, 4, 8, 10);++ it("formats minutes, hours, and days, rounding up", () => {+ expect(snoozeWakeLabel(new Date(now.getTime() + 30 * 60_000).toISOString(), now)).toBe("30m");+ expect(snoozeWakeLabel(new Date(now.getTime() + 90 * 60_000).toISOString(), now)).toBe("2h");+ expect(snoozeWakeLabel(new Date(now.getTime() + 26 * 3_600_000).toISOString(), now)).toBe("2d");+ });++ it("reports now for past and malformed wake times", () => {+ expect(snoozeWakeLabel(new Date(now.getTime() - 1000).toISOString(), now)).toBe("now");+ expect(snoozeWakeLabel("not-a-date", now)).toBe("now");+ });+});++describe("snoozeWakeDescription", () => {+ const now = localDate(2026, 4, 8, 10);++ it("uses bare time today, 'tomorrow' next day, weekday within the week", () => {+ expect(snoozeWakeDescription(localDate(2026, 4, 8, 18).toISOString(), now)).not.toContain(+ "tomorrow",+ );+ expect(snoozeWakeDescription(localDate(2026, 4, 9, 9).toISOString(), now)).toContain(+ "tomorrow",+ );+ expect(snoozeWakeDescription(localDate(2026, 4, 13, 9).toISOString(), now)).toMatch(/Mon/);+ });+});diff --git a/apps/web/src/components/Sidebar.snooze.ts b/apps/web/src/components/Sidebar.snooze.tsnew file mode 100644index 000000000..dd56cec72--- /dev/null+++ b/apps/web/src/components/Sidebar.snooze.ts@@ -0,0 +1,127 @@+/**+ * Snooze preset resolution for the sidebar snooze menu. Pure functions so+ * the preset math (evening/tomorrow/next-week boundaries) is unit-testable+ * without a DOM.+ *+ * Presets deliberately skew short: agent-thread rhythms are hours (a CI+ * run, a teammate review, the next work session), not days.+ */+import { parseTimestampDate } from "../timestampFormat";++type SnoozePresetId = "hour" | "evening" | "tomorrow" | "next-week";++export interface SnoozePreset {+ readonly id: SnoozePresetId;+ readonly label: string;+ /** Menu-row time column. Complements the label instead of repeating it:+ "Tomorrow" pairs with "9:00 AM", not "tomorrow 9:00 AM". */+ readonly whenLabel: string;+ /** ISO wake time. */+ readonly snoozedUntil: string;+}++function timeOfDayLabel(date: Date): string {+ return date.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });+}++const EVENING_HOUR = 18;+const MORNING_HOUR = 9;+const HOUR_MS = 60 * 60 * 1_000;+const DAY_MS = 24 * HOUR_MS;++function atHour(base: Date, hour: number): Date {+ const next = new Date(base);+ next.setHours(hour, 0, 0, 0);+ return next;+}++// Calendar-day advance instead of adding DAY_MS: fixed millisecond offsets+// land on the wrong local day across DST transitions (a spring-forward day+// is 23 hours, so 23:30 + 24h skips the whole next day).+function addDays(base: Date, days: number): Date {+ const next = new Date(base);+ next.setDate(next.getDate() + days);+ return next;+}++/**+ * Presets for "snooze until", computed against local time. "This evening"+ * only appears while it is still meaningfully before evening; after that+ * the list starts at "Tomorrow".+ */+export function resolveSnoozePresets(now: Date): ReadonlyArray<SnoozePreset> {+ const inAnHour = new Date(now.getTime() + HOUR_MS);+ const presets: SnoozePreset[] = [+ {+ id: "hour",+ label: "In 1 hour",+ whenLabel: timeOfDayLabel(inAnHour),+ snoozedUntil: inAnHour.toISOString(),+ },+ ];++ const evening = atHour(now, EVENING_HOUR);+ // Suppress the evening preset once it is within an hour (or past): it+ // would duplicate "In 1 hour" or point at the past.+ if (evening.getTime() - now.getTime() > HOUR_MS) {+ presets.push({+ id: "evening",+ label: "This evening",+ whenLabel: timeOfDayLabel(evening),+ snoozedUntil: evening.toISOString(),+ });+ }++ const tomorrow = atHour(addDays(now, 1), MORNING_HOUR);+ presets.push({+ id: "tomorrow",+ label: "Tomorrow",+ whenLabel: timeOfDayLabel(tomorrow),+ snoozedUntil: tomorrow.toISOString(),+ });++ // Next Monday 9:00 (a week out when today is Monday).+ const daysUntilMonday = (1 - now.getDay() + 7) % 7 || 7;+ const nextWeek = atHour(addDays(now, daysUntilMonday), MORNING_HOUR);+ presets.push({+ id: "next-week",+ label: "Next week",+ whenLabel: `${nextWeek.toLocaleDateString(undefined, { weekday: "short" })} ${timeOfDayLabel(nextWeek)}`,+ snoozedUntil: nextWeek.toISOString(),+ });++ return presets;+}++/**+ * Compact "wakes in" label for snoozed rows: "2h", "18h", "3d". Minutes+ * round up so a snooze never reads "0m" while still hidden.+ */+export function snoozeWakeLabel(snoozedUntil: string, now: Date): string {+ const wake = parseTimestampDate(snoozedUntil);+ if (wake === null) return "now";+ const remainingMs = wake.getTime() - now.getTime();+ if (remainingMs <= 0) return "now";+ if (remainingMs < HOUR_MS) return `${Math.max(1, Math.ceil(remainingMs / 60_000))}m`;+ if (remainingMs < DAY_MS) return `${Math.ceil(remainingMs / HOUR_MS)}h`;+ return `${Math.ceil(remainingMs / DAY_MS)}d`;+}++/**+ * Human wake time for menus and toasts: "tomorrow 9:00", "Mon 9:00",+ * "17:30" (today).+ */+export function snoozeWakeDescription(snoozedUntil: string, now: Date): string {+ const wake = parseTimestampDate(snoozedUntil);+ if (wake === null) return "";+ const time = wake.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });+ const startOfToday = new Date(now);+ startOfToday.setHours(0, 0, 0, 0);+ const dayDelta = Math.floor((wake.getTime() - startOfToday.getTime()) / DAY_MS);+ if (dayDelta === 0) return time;+ if (dayDelta === 1) return `tomorrow ${time}`;+ const weekday = wake.toLocaleDateString(undefined, { weekday: "short" });+ if (dayDelta < 7) return `${weekday} ${time}`;+ const date = wake.toLocaleDateString(undefined, { month: "short", day: "numeric" });+ return `${date}, ${time}`;+}diff --git a/apps/web/src/components/SidebarV2.tsx b/apps/web/src/components/SidebarV2.tsxindex c29953590..e01849134 100644--- a/apps/web/src/components/SidebarV2.tsx+++ b/apps/web/src/components/SidebarV2.tsx@@ -1,6 +1,11 @@import { autoAnimate } from "@formkit/auto-animate";import { useAtomValue } from "@effect/atom-react";-import { effectiveSettled } from "@t3tools/client-runtime/state/thread-settled";+import {+ canSnooze,+ effectiveSettled,+ effectiveSnoozed,+ threadWokeAt,+} from "@t3tools/client-runtime/state/thread-settled";import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/models";import {scopeProjectRef,@@ -9,11 +14,15 @@ import {} from "@t3tools/client-runtime/environment";import type { ScopedThreadRef, SidebarProjectGroupingMode } from "@t3tools/contracts";import {+ AlarmClockIcon,+ AlarmClockOffIcon,CheckIcon,ChevronDownIcon,+ ChevronRightIcon,CircleAlertIcon,CircleCheckIcon,CircleDashedIcon,+ ClockIcon,CopyIcon,FolderIcon,FolderPlusIcon,@@ -36,6 +45,7 @@ import {useState,type KeyboardEvent as ReactKeyboardEvent,type MouseEvent as ReactMouseEvent,+ type ReactNode,} from "react";import { useParams, useRouter } from "@tanstack/react-router";@@ -88,11 +98,12 @@ import { projectEnvironment } from "../state/projects";import { useEnvironmentQuery } from "../state/query";import { useAtomCommand } from "../state/use-atom-command";import { buildThreadRouteParams, resolveThreadRouteTarget } from "../threadRoutes";-import { formatRelativeTimeLabel } from "../timestampFormat";+import { formatRelativeTimeLabel, parseTimestampDate } from "../timestampFormat";import type { SidebarThreadSummary } from "../types";import { cn } from "~/lib/utils";import {formatWorkingDurationLabel,+ firstValidTimestampMs,hasUnseenCompletion,isTrailingDoubleClick,orderItemsByPreferredIds,@@ -107,6 +118,12 @@ import {} from "./Sidebar.logic";import { resolveLocalCheckoutBranchMismatch } from "./BranchToolbar.logic";import { prStatusIndicator, resolveThreadPr } from "./ThreadStatusIndicators";+import {+ resolveSnoozePresets,+ snoozeWakeDescription,+ snoozeWakeLabel,+ type SnoozePreset,+} from "./Sidebar.snooze";import { ProjectFavicon } from "./ProjectFavicon";import { ProviderInstanceIcon } from "./chat/ProviderInstanceIcon";import { getTriggerDisplayModelLabel } from "./chat/providerIconUtils";@@ -130,6 +147,7 @@ import { Menu, MenuPopup, MenuRadioGroup, MenuRadioItem, MenuTrigger } from "./uimport { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "./ui/select";import { SidebarContent, SidebarGroup, SidebarMenuButton, useSidebar } from "./ui/sidebar";import { SidebarChromeFooter, SidebarChromeHeader } from "./sidebar/SidebarChrome";+import { Popover, PopoverPopup, PopoverTrigger } from "./ui/popover";import { Tooltip, TooltipPopup, TooltipProvider, TooltipTrigger } from "./ui/tooltip";import { useComposerDraftStore } from "../composerDraftStore";@@ -275,15 +293,74 @@ function SidebarV2ThreadTooltip({);}+/**+ * Hover entry point for snooze: a clock button opening the preset menu.+ * Controlled by the row (which also uses the open state to pin its hover+ * actions while the menu is up).+ */+function SnoozePopoverButton(props: {+ open: boolean;+ onOpenChange: (open: boolean) => void;+ onSnooze: (preset: SnoozePreset) => void;+}) {+ const { open, onOpenChange, onSnooze } = props;+ // Presets resolve at open time so "In 1 hour" is relative to the click,+ // not to when the row mounted.+ const presets = useMemo(() => (open ? resolveSnoozePresets(new Date()) : []), [open]);+ return (+ <Popover open={open} onOpenChange={onOpenChange}>+ <PopoverTrigger+ render={+ <button+ type="button"+ aria-label="Snooze thread"+ onClick={(event) => event.stopPropagation()}+ onDoubleClick={(event) => event.stopPropagation()}+ className="inline-flex h-full cursor-pointer items-center gap-0.5 rounded-md bg-transparent px-1.5 text-xs text-muted-foreground hover:text-foreground"+ />+ }+ >+ <ClockIcon className="size-3" />+ </PopoverTrigger>+ <PopoverPopup side="bottom" align="end" className="w-56" viewportClassName="p-1">+ {presets.map((preset) => (+ <button+ key={preset.id}+ type="button"+ onClick={(event) => {+ event.stopPropagation();+ onOpenChange(false);+ onSnooze(preset);+ }}+ className="flex w-full cursor-pointer items-center gap-2 rounded-md px-2 py-1.5 text-left text-xs text-foreground/90 hover:bg-accent hover:text-foreground"+ >+ <span className="flex-1">{preset.label}</span>+ <span className="font-mono text-[10px] text-muted-foreground/60 tabular-nums">+ {preset.whenLabel}+ </span>+ </button>+ ))}+ </PopoverPopup>+ </Popover>+ );+}+const SidebarV2Row = memo(function SidebarV2Row(props: {thread: SidebarThreadSummary;variant: "card" | "slim";// Slim rows are either settled (action: un-settle) or merely quiet// (seen Ready threads — action: settle).- variantAction: "settle" | "unsettle";+ variantAction: "settle" | "unsettle" | "unsnooze";// False on environments whose server predates thread.settle/unsettle:// the lifecycle affordances hide entirely rather than fail on click.settlementSupported: boolean;+ // Same contract for thread.snooze/unsnooze.+ snoozeSupported: boolean;+ // Compact wake countdown ("2h") for rows in the snoozed shelf.+ snoozeWakeLabelText: string | null;+ // When a snooze ended (timer or early wake); drives the Woke pill until+ // the user visits the thread.+ wokeAt: string | null;isActive: boolean;jumpLabel: string | null;currentEnvironmentId: string | null;@@ -302,6 +379,8 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {onContextMenu: (threadRef: ScopedThreadRef, position: { x: number; y: number }) => void;onSettle: (threadRef: ScopedThreadRef) => void;onUnsettle: (threadRef: ScopedThreadRef) => void;+ onSnooze: (threadRef: ScopedThreadRef, preset: SnoozePreset) => void;+ onUnsnooze: (threadRef: ScopedThreadRef) => void;onChangeRequestState: (threadKey: string, state: "open" | "closed" | "merged" | null) => void;}) {const {@@ -312,10 +391,12 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {onContextMenu,onRenameTitleChange,onSettle,+ onSnooze,onStartRename,onThreadActivate,onThreadClick,onUnsettle,+ onUnsnooze,renamingTitle,thread,variant,@@ -334,15 +415,25 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {// flag must not light up every historical thread as unread.const isUnread = hasUnseenCompletion({ ...thread, lastVisitedAt });const status = resolveSidebarV2Status(thread);+ // A woken thread reappears at its original position (the sort is+ // deliberately static), so the pill has to carry the weight. Snoozing is+ // an explicit act, so unlike Done, a never-visited woke thread still+ // shows the pill; visiting clears it. An unparseable visit timestamp+ // counts as never-visited — corrupt local data must not eat the wake+ // signal.+ const lastVisitedDate = lastVisitedAt === undefined ? null : parseTimestampDate(lastVisitedAt);+ const wokeAtDate = props.wokeAt === null ? null : parseTimestampDate(props.wokeAt);+ const isWoke = wokeAtDate !== null && (lastVisitedDate === null || lastVisitedDate < wokeAtDate);// In-flight rows (working, or waiting on approval/input) fade as a whole:// there is nothing for the user to do yet, so prominence is reserved for- // rows that need a human — done (unread), read-but-unsettled, and failed.- // The status label keeps its hue, so waiting rows stay findable. In-flight- // rows recede the same as read-ready ones (inbox-zero: working threads- // aren't your problem yet) — only the colored status label stands out.+ // rows that need a human — done (unread), read-but-unsettled, failed, and+ // freshly woken. The status label keeps its hue, so waiting rows stay+ // findable. In-flight rows recede the same as read-ready ones (inbox-zero:+ // working threads aren't your problem yet) — only the colored status label+ // stands out.const isInFlight = status === "working" || status === "approval" || status === "input";const shouldRecede =- (status === "ready" || isInFlight) && !isUnread && !props.isActive && !isSelected;+ (status === "ready" || isInFlight) && !isUnread && !isWoke && !props.isActive && !isSelected;// Status hues follow the system-wide convention set by sidebar v1 and the// mobile Live Activity/widgets (amber approval, indigo input, sky working)// so a thread reads the same color everywhere it surfaces.@@ -372,13 +463,19 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {icon: null,className: "text-red-700 dark:text-red-300",}- : isUnread+ : isWoke? {- label: "Done",- icon: "done" as const,- className: "text-emerald-700 dark:text-emerald-300",+ label: "Woke",+ icon: "woke" as const,+ className: "text-amber-700 dark:text-amber-300",}- : null;+ : isUnread+ ? {+ label: "Done",+ icon: "done" as const,+ className: "text-emerald-700 dark:text-emerald-300",+ }+ : null;const gitCwd = thread.worktreePath ?? props.projectCwd;const gitStatus = useEnvironmentQuery(@@ -507,6 +604,36 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {},[onUnsettle, threadRef],);+ const handleUnsnoozeClick = useCallback(+ (event: ReactMouseEvent) => {+ event.preventDefault();+ event.stopPropagation();+ onUnsnooze(threadRef);+ },+ [onUnsnooze, threadRef],+ );+ const handleSnoozePreset = useCallback(+ (preset: SnoozePreset) => {+ onSnooze(threadRef, preset);+ },+ [onSnooze, threadRef],+ );+ // While the snooze popover is open the pointer leaves the row, which+ // would fade the hover actions out from under the open menu; pin them.+ const [snoozeMenuOpenRaw, setSnoozeMenuOpen] = useState(false);+ // Snooze is offered only where it can succeed: capability-gated and never+ // on blocked-on-you work or queued turns (the server rejects both).+ const showSnoozeButton =+ props.snoozeSupported && canSnooze(thread, { now: new Date().toISOString() });+ // If the thread becomes blocked while the popover is open, the button+ // unmounts without firing onOpenChange(false). Deriving the flag keeps a+ // stale true from permanently hiding the status label / pinning the+ // hover actions, and the effect clears the raw state so the popover+ // doesn't resurrect if the button later remounts.+ const snoozeMenuOpen = snoozeMenuOpenRaw && showSnoozeButton;+ useEffect(() => {+ if (!showSnoozeButton) setSnoozeMenuOpen(false);+ }, [showSnoozeButton]);const handlePrClick = useCallback((event: ReactMouseEvent<HTMLElement>) => {if (pr?.url) openPrLink(event, pr.url);@@ -555,7 +682,7 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {variant === "card"? cn("truncate",- isUnread+ isUnread || isWoke? "text-foreground": shouldRecede? "text-muted-foreground/80"@@ -565,7 +692,7 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {): cn("truncate group-hover/v2-row:text-foreground",- props.isActive+ props.isActive || isWoke? "text-foreground": isUnread? "text-muted-foreground"@@ -640,13 +767,43 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {{prBadge}<span className="relative ml-auto flex h-6 min-w-8 shrink-0 items-center justify-end"><span className="inline-flex justify-end tabular-nums text-muted-foreground/55 transition-opacity group-hover/v2-row:opacity-0">- <span className="text-xs">- {variantAction === "unsettle"- ? settledTimeLabel(thread)- : threadTimeLabel(thread)}- </span>+ {variantAction === "unsnooze" && props.snoozeWakeLabelText !== null ? (+ // Snoozed rows show when they come BACK, not when they were+ // last touched — the return ticket is the row's whole story.+ <span className="text-xs text-blue-600 tabular-nums dark:text-blue-400">+ {props.snoozeWakeLabelText}+ </span>+ ) : isWoke ? (+ // A wake can land straight in the settled tail (e.g. PR+ // merged while snoozed); the signal must survive the trip.+ <span+ role="status"+ aria-label="Woke from snooze"+ className="inline-flex items-center gap-1 text-xs font-medium text-amber-700 dark:text-amber-300"+ >+ <AlarmClockIcon aria-hidden className="size-3" />+ Woke+ </span>+ ) : (+ <span className="text-xs">+ {variantAction === "unsettle"+ ? settledTimeLabel(thread)+ : threadTimeLabel(thread)}+ </span>+ )}</span>- {!props.settlementSupported ? null : variantAction === "unsettle" ? (+ {variantAction === "unsnooze" ? (+ !props.snoozeSupported ? null : (+ <button+ type="button"+ aria-label="Wake thread now"+ onClick={handleUnsnoozeClick}+ className="absolute inset-y-0 right-0 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-2 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:opacity-100 group-hover/v2-row:opacity-100"+ >+ <AlarmClockOffIcon className="size-3" />+ </button>+ )+ ) : !props.settlementSupported ? null : variantAction === "unsettle" ? (<buttontype="button"aria-label="Un-settle thread"@@ -716,7 +873,12 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {<span className="flex-1" />)}<span className="relative ml-auto flex h-5 min-w-8 shrink-0 items-center justify-end pl-1 text-xs">- <span className="tabular-nums text-muted-foreground/65 transition-opacity group-hover/v2-row:opacity-0">+ <span+ className={cn(+ "tabular-nums text-muted-foreground/65 transition-opacity group-hover/v2-row:opacity-0",+ snoozeMenuOpen && "opacity-0",+ )}+ >{topStatus ? (<spanclassName={cn(@@ -728,6 +890,8 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {<CircleDashedIcon aria-hidden className="size-4 shrink-0" />) : topStatus.icon === "done" ? (<CircleCheckIcon aria-hidden className="size-4 shrink-0" />+ ) : topStatus.icon === "woke" ? (+ <AlarmClockIcon aria-hidden className="size-4 shrink-0" />) : null}{/* The label alone is the live region: a role="status"wrapper around the ticking duration would make@@ -743,16 +907,32 @@ const SidebarV2Row = memo(function SidebarV2Row(props: {threadTimeLabel(thread))}</span>- {props.settlementSupported ? (- <button- type="button"- aria-label="Settle thread"- onClick={handleSettleClick}- className="absolute inset-y-0 right-0 inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-2 text-xs text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:opacity-100 group-hover/v2-row:opacity-100"+ {props.settlementSupported || showSnoozeButton ? (+ <span+ className={cn(+ "absolute inset-y-0 right-0 flex items-stretch gap-0.5 opacity-0 transition-opacity focus-within:opacity-100 group-hover/v2-row:opacity-100",+ snoozeMenuOpen && "opacity-100",+ )}>- <CheckIcon className="size-3" />- Settle- </button>+ {showSnoozeButton ? (+ <SnoozePopoverButton+ open={snoozeMenuOpen}+ onOpenChange={setSnoozeMenuOpen}+ onSnooze={handleSnoozePreset}+ />+ ) : null}+ {props.settlementSupported ? (+ <button+ type="button"+ aria-label="Settle thread"+ onClick={handleSettleClick}+ className="inline-flex cursor-pointer items-center gap-1 rounded-md bg-transparent px-2 text-xs text-muted-foreground hover:text-foreground"+ >+ <CheckIcon className="size-3" />+ Settle+ </button>+ ) : null}+ </span>) : null}</span></div>@@ -819,7 +999,8 @@ export default function SidebarV2() {const confirmThreadDelete = useClientSettings((s) => s.confirmThreadDelete);const sidebarProjectSortOrder = useClientSettings((s) => s.sidebarProjectSortOrder);const projectGroupingSettings = useClientSettings(selectProjectGroupingSettings);- const { settleThread, unsettleThread, deleteThread } = useThreadActions();+ const { settleThread, unsettleThread, snoozeThread, unsnoozeThread, deleteThread } =+ useThreadActions();const updateThreadMetadata = useAtomCommand(threadEnvironment.updateMetadata, {reportFailure: false,});@@ -954,6 +1135,12 @@ export default function SidebarV2() {// now is quantized to the minute so effectiveSettled memoization doesn't// churn on every render; auto-settle thresholds are day-granular anyway.const nowMinute = useNowMinute();+ // Snooze wake times are second-precise, so classifying with the quantized+ // minute would hold a woken thread on the shelf for up to a minute. The+ // tick is a plain counter bumped exactly at the next wake boundary (armed+ // below, after the partition knows the boundary); the partition reads a+ // fresh clock whenever it recomputes.+ const [snoozeWakeTick, bumpSnoozeWakeTick] = useState(0);// PR states stream in per-row (rows own the VCS subscriptions); a merged or// closed PR auto-settles its thread on the next partition.@@ -1165,8 +1352,14 @@ export default function SidebarV2() {// merging, no optimistic holds. Archived threads remain hidden here —// archive keeps its original "remove from sidebar" meaning.const serverConfigs = useAtomValue(environmentServerConfigsAtom);- const { activeThreads, settledThreads } = useMemo(() => {+ const { activeThreads, snoozedThreads, settledThreads, snoozeNow } = useMemo(() => {const now = `${nowMinute}:00.000Z`;+ // Snooze classification uses a REAL clock, not the quantized minute:+ // wake times are second-precise and a woken thread must not linger on+ // the shelf for the rest of the minute. snoozeWakeTick re-runs this+ // memo exactly at the next wake boundary.+ void snoozeWakeTick;+ const preciseNow = new Date().toISOString();const visible = threads.filter((thread) =>thread.archivedAt === null &&@@ -1174,6 +1367,7 @@ export default function SidebarV2() {scopedProjectKeys.has(`${thread.environmentId}:${thread.projectId}`)),);const active: EnvironmentThreadShell[] = [];+ const snoozed: EnvironmentThreadShell[] = [];const settled: EnvironmentThreadShell[] = [];for (const thread of visible) {// Threads on servers without the settlement capability (old server,@@ -1182,9 +1376,16 @@ export default function SidebarV2() {// strand rows in a tail with no working affordances.const supportsSettlement =serverConfigs.get(thread.environmentId)?.environment.capabilities.threadSettlement === true;+ const supportsSnooze =+ serverConfigs.get(thread.environmentId)?.environment.capabilities.threadSnooze === true;const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id));const changeRequestState = changeRequestStateByKey.get(threadKey) ?? null;- if (+ // Snooze outranks settled classification: an explicitly snoozed thread+ // belongs to the shelf even if it would also auto-settle (the shelf's+ // wake time is a stronger statement about when it matters again).+ if (supportsSnooze && effectiveSnoozed(thread, { now: preciseNow })) {+ snoozed.push(thread);+ } else if (supportsSettlement &&effectiveSettled(thread, { now, autoSettleAfterDays, changeRequestState })) {@@ -1195,7 +1396,14 @@ export default function SidebarV2() {}return {activeThreads: sortThreadsForSidebarV2(active),+ // Soonest wake first: "what comes back next" is the shelf's question.+ snoozedThreads: snoozed.toSorted(+ (left, right) =>+ firstValidTimestampMs(left.snoozedUntil ?? null) -+ firstValidTimestampMs(right.snoozedUntil ?? null),+ ),settledThreads: sortSettledThreadsForSidebarV2(settled),+ snoozeNow: preciseNow,};}, [autoSettleAfterDays,@@ -1203,9 +1411,28 @@ export default function SidebarV2() {nowMinute,scopedProjectKeys,serverConfigs,+ snoozeWakeTick,threads,]);+ // Arm a timeout for the earliest upcoming wake so the shelf empties the+ // moment a snooze expires instead of on the next minute tick. Sorted+ // soonest-first, so entry 0 is the boundary.+ useEffect(() => {+ const nextWakeAtMs =+ snoozedThreads.length > 0 && snoozedThreads[0]?.snoozedUntil != null+ ? Date.parse(snoozedThreads[0].snoozedUntil)+ : Number.NaN;+ if (Number.isNaN(nextWakeAtMs)) return;+ // setTimeout delays are signed 32-bit: anything larger overflows and+ // fires immediately, turning a far-future wake (event-condition snoozes+ // synced from elsewhere) into a tight re-arm loop. Clamped, the timer+ // just re-arms every ~24.8 days until the wake is in range.+ const delayMs = Math.min(Math.max(0, nextWakeAtMs - Date.now()) + 50, 2_147_483_647);+ const id = window.setTimeout(() => bumpSnoozeWakeTick((tick) => tick + 1), delayMs);+ return () => window.clearTimeout(id);+ }, [snoozedThreads]);+// The settled tail renders in pages: history shouldn't dominate the// sidebar, and the common lookups are recent. Expansion resets when the// filter context changes so a scope/search flip never inherits a deep@@ -1239,10 +1466,40 @@ export default function SidebarV2() {() => setSettledVisibleCount((count) => count + SETTLED_TAIL_PAGE_COUNT),[],);+ const [settledShelfExpanded, setSettledShelfExpanded] = useState(true);+ const toggleSettledShelf = useCallback(() => setSettledShelfExpanded((value) => !value), []);+ const renderedSettledThreads = useMemo(() => {+ if (settledShelfExpanded) return visibleSettledThreads;+ if (routeThreadKey === null) return [];+ const routeThread = visibleSettledThreads.find(+ (thread) =>+ scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)) === routeThreadKey,+ );+ return routeThread === undefined ? [] : [routeThread];+ }, [routeThreadKey, settledShelfExpanded, visibleSettledThreads]);++ // The snoozed shelf is collapsed by default: out of the way, never gone.+ // Collapsed threads don't render (and so don't participate in jump+ // shortcuts or multi-select), matching the settled tail's paging model.+ const [snoozedShelfExpanded, setSnoozedShelfExpanded] = useState(false);+ const toggleSnoozedShelf = useCallback(() => setSnoozedShelfExpanded((value) => !value), []);+ const visibleSnoozedThreads = useMemo(() => {+ if (snoozedShelfExpanded) return snoozedThreads;+ // The open thread must never vanish behind the collapsed shelf: a+ // snoozed thread reached by route (deep link, open before snoozing+ // elsewhere) keeps its row — with highlight and wake affordance — same+ // exception the settled tail's "Show more" makes.+ if (routeThreadKey === null) return [];+ const routeThread = snoozedThreads.find(+ (thread) =>+ scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)) === routeThreadKey,+ );+ return routeThread === undefined ? [] : [routeThread];+ }, [routeThreadKey, snoozedShelfExpanded, snoozedThreads]);const orderedThreads = useMemo(- () => [...activeThreads, ...visibleSettledThreads],- [activeThreads, visibleSettledThreads],+ () => [...activeThreads, ...visibleSnoozedThreads, ...renderedSettledThreads],+ [activeThreads, visibleSnoozedThreads, renderedSettledThreads],);const orderedThreadKeys = useMemo(() =>@@ -1287,6 +1544,17 @@ export default function SidebarV2() {);const settledThreadKeysRef = useRef(settledThreadKeys);settledThreadKeysRef.current = settledThreadKeys;+ const snoozedThreadKeys = useMemo(+ () =>+ new Set(+ snoozedThreads.map((thread) =>+ scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),+ ),+ ),+ [snoozedThreads],+ );+ const snoozedThreadKeysRef = useRef(snoozedThreadKeys);+ snoozedThreadKeysRef.current = snoozedThreadKeys;const jumpLabelByKey = useMemo(() => {const mapping = new Map<string, string>();@@ -1382,6 +1650,36 @@ export default function SidebarV2() {// A settle per thread at a time: double clicks and repeated menu picks// must not dispatch a second settle that fails and toasts a false error.const settlingThreadKeysRef = useRef(new Set<string>());+ // Parking the thread you're looking at (settle or snooze) moves you+ // forward: the next remaining card (never a settled or snoozed row, never+ // one leaving in the same batch), or a fresh draft in this project when it+ // was the last active one. Callers snapshot the plan BEFORE the command+ // mutates the partition; background parks never navigate (null plan).+ const planForwardNavigation = useCallback(+ (threadKey: string, coParkingKeys?: ReadonlySet<string>): (() => void) | null => {+ if (routeThreadKeyRef.current !== threadKey) return null;+ const shell = threadByKeyRef.current.get(threadKey);+ const orderedKeys = orderedThreadKeysRef.current;+ const settledKeys = settledThreadKeysRef.current;+ const snoozedKeys = snoozedThreadKeysRef.current;+ const currentIndex = orderedKeys.indexOf(threadKey);+ const nextCardKey =+ currentIndex === -1+ ? null+ : ([...orderedKeys.slice(currentIndex + 1), ...orderedKeys.slice(0, currentIndex)].find(+ (key) => !settledKeys.has(key) && !snoozedKeys.has(key) && !coParkingKeys?.has(key),+ ) ?? null);+ const nextThread = nextCardKey ? threadByKeyRef.current.get(nextCardKey) : null;+ return nextThread+ ? () => navigateToThread(scopeThreadRef(nextThread.environmentId, nextThread.id))+ : shell+ ? () =>+ void handleNewThreadRef.current(scopeProjectRef(shell.environmentId, shell.projectId))+ : () => void router.navigate({ to: "/" });+ },+ [navigateToThread, router],+ );+const attemptSettle = useCallback((threadRef: ScopedThreadRef, opts: { coSettlingKeys?: ReadonlySet<string> } = {}) => {void (async () => {@@ -1389,34 +1687,7 @@ export default function SidebarV2() {if (settlingThreadKeysRef.current.has(threadKey)) return;settlingThreadKeysRef.current.add(threadKey);try {- // Settling the thread you're looking at moves you forward: the next- // remaining card (never a settled row, never one settling in the- // same batch), or a fresh draft in this project when it was the- // last active one. Snapshot the target before the settle mutates- // the partition. Background settles never navigate.- const shell = threadByKeyRef.current.get(threadKey);- let navigateAfterSettle: (() => void) | null = null;- if (routeThreadKey === threadKey) {- const orderedKeys = orderedThreadKeysRef.current;- const settledKeys = settledThreadKeysRef.current;- const currentIndex = orderedKeys.indexOf(threadKey);- const nextCardKey =- currentIndex === -1- ? null- : ([- ...orderedKeys.slice(currentIndex + 1),- ...orderedKeys.slice(0, currentIndex),- ].find((key) => !settledKeys.has(key) && !opts.coSettlingKeys?.has(key)) ?? null);- const nextThread = nextCardKey ? threadByKeyRef.current.get(nextCardKey) : null;- navigateAfterSettle = nextThread- ? () => navigateToThread(scopeThreadRef(nextThread.environmentId, nextThread.id))- : shell- ? () =>- void handleNewThreadRef.current(- scopeProjectRef(shell.environmentId, shell.projectId),- )- : () => void router.navigate({ to: "/" });- }+ const navigateAfterSettle = planForwardNavigation(threadKey, opts.coSettlingKeys);const result = await settleThread(threadRef);if (result._tag === "Failure") {// Never navigate away from a thread that did not settle.@@ -1442,7 +1713,7 @@ export default function SidebarV2() {}})();},- [navigateToThread, routeThreadKey, router, settleThread],+ [planForwardNavigation, settleThread],);const attemptUnsettle = useCallback((threadRef: ScopedThreadRef) => {@@ -1462,6 +1733,80 @@ export default function SidebarV2() {},[unsettleThread],);+ const attemptUnsnooze = useCallback(+ (threadRef: ScopedThreadRef) => {+ void (async () => {+ const result = await unsnoozeThread(threadRef);+ if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {+ const error = squashAtomCommandFailure(result);+ toastManager.add(+ stackedThreadToast({+ type: "error",+ title: "Failed to wake thread",+ description: error instanceof Error ? error.message : "An error occurred.",+ }),+ );+ }+ })();+ },+ [unsnoozeThread],+ );+ // One snooze per thread at a time — same double-dispatch guard as settle.+ const snoozingThreadKeysRef = useRef(new Set<string>());+ const attemptSnooze = useCallback(+ (+ threadRef: ScopedThreadRef,+ preset: SnoozePreset,+ opts: { coSnoozingKeys?: ReadonlySet<string> } = {},+ ) => {+ void (async () => {+ const threadKey = scopedThreadKey(threadRef);+ if (snoozingThreadKeysRef.current.has(threadKey)) return;+ snoozingThreadKeysRef.current.add(threadKey);+ try {+ // Snoozing the open thread moves you forward, same as settle —+ // both park the thread you're done with for now.+ const navigateAfterSnooze = planForwardNavigation(threadKey, opts.coSnoozingKeys);+ const result = await snoozeThread(threadRef, preset.snoozedUntil);+ if (result._tag === "Failure") {+ // Never navigate away from a thread that did not snooze.+ if (!isAtomCommandInterrupted(result)) {+ const error = squashAtomCommandFailure(result);+ toastManager.add(+ stackedThreadToast({+ type: "error",+ title: "Failed to snooze thread",+ description: error instanceof Error ? error.message : "An error occurred.",+ }),+ );+ }+ return;+ }+ // Snooze hides the row, so the toast is the only confirmation —+ // and the Undo is the escape hatch for a mis-click.+ toastManager.add(+ stackedThreadToast({+ type: "success",+ title: `Snoozed until ${snoozeWakeDescription(preset.snoozedUntil, new Date())}`,+ timeout: 5_000,+ actionProps: {+ children: "Undo",+ onClick: () => attemptUnsnooze(threadRef),+ },+ }),+ );+ // Only move forward if the user is still on the snoozed thread —+ // a navigation made during the await wins over ours.+ if (routeThreadKeyRef.current === threadKey) {+ navigateAfterSnooze?.();+ }+ } finally {+ snoozingThreadKeysRef.current.delete(threadKey);+ }+ })();+ },+ [attemptUnsnooze, planForwardNavigation, snoozeThread],+ );const removeFromSelection = useThreadSelectionStore((s) => s.removeFromSelection);const handleMultiSelectContextMenu = useCallback(@@ -1477,10 +1822,35 @@ export default function SidebarV2() {);if (threadKeys.length === 0) return;const count = threadKeys.length;+ // Snooze (N) is offered when every selected thread can actually take+ // it — a mixed selection with blocked-on-you work would half-apply.+ const selectionNow = new Date().toISOString();+ const snoozableThreads = threadKeys.flatMap((threadKey) => {+ const thread = threadByKeyRef.current.get(threadKey);+ return thread ? [thread] : [];+ });+ const canSnoozeSelection = snoozableThreads.every(+ (thread) =>+ serverConfigs.get(thread.environmentId)?.environment.capabilities.threadSnooze === true &&+ canSnooze(thread, { now: selectionNow }),+ );+ const snoozePresets = resolveSnoozePresets(new Date());const clicked = await settlePromise(() =>api.contextMenu.show([{ id: "settle", label: `Settle (${count})` },+ ...(canSnoozeSelection+ ? [+ {+ id: "snooze",+ label: `Snooze (${count})`,+ children: snoozePresets.map((preset) => ({+ id: `snooze:${preset.id}`,+ label: `${preset.label} (${preset.whenLabel})`,+ })),+ },+ ]+ : []),{ id: "mark-unread", label: `Mark unread (${count})` },{ id: "delete", label: `Delete (${count})`, destructive: true },],@@ -1488,6 +1858,23 @@ export default function SidebarV2() {),);if (clicked._tag === "Failure") return;+ if (clicked.value?.startsWith("snooze:")) {+ const preset = snoozePresets.find(+ (candidate) => `snooze:${candidate.id}` === clicked.value,+ );+ if (preset) {+ // Post-snooze navigation must skip threads snoozing in this same+ // batch — they are all leaving the card block together.+ const coSnoozingKeys = new Set(threadKeys);+ for (const thread of snoozableThreads) {+ attemptSnooze(scopeThreadRef(thread.environmentId, thread.id), preset, {+ coSnoozingKeys,+ });+ }+ clearSelection();+ }+ return;+ }if (clicked.value === "settle") {// Post-settle navigation must skip threads settling in this same// batch — they are all leaving the card block together. Rows that@@ -1552,11 +1939,13 @@ export default function SidebarV2() {},[attemptSettle,+ attemptSnooze,clearSelection,confirmThreadDelete,deleteThread,markThreadUnread,removeFromSelection,+ serverConfigs,],);@@ -1580,7 +1969,12 @@ export default function SidebarV2() {const supportsSettlement =serverConfigs.get(thread.environmentId)?.environment.capabilities.threadSettlement ===true;+ const supportsSnooze =+ serverConfigs.get(thread.environmentId)?.environment.capabilities.threadSnooze === true;const isSettled = settledThreadKeysRef.current.has(threadKey);+ const isSnoozed = snoozedThreadKeysRef.current.has(threadKey);+ // Presets resolve at menu-open time (same as the popover).+ const snoozePresets = resolveSnoozePresets(new Date());const clicked = await settlePromise(() =>api.contextMenu.show([@@ -1599,6 +1993,21 @@ export default function SidebarV2() {: { id: "settle", label: "Settle thread" },]: []),+ ...(supportsSnooze+ ? [+ isSnoozed+ ? { id: "unsnooze", label: "Wake thread" }+ : {+ id: "snooze",+ label: "Snooze",+ disabled: !canSnooze(thread, { now: new Date().toISOString() }),+ children: snoozePresets.map((preset) => ({+ id: `snooze:${preset.id}`,+ label: `${preset.label} (${preset.whenLabel})`,+ })),+ },+ ]+ : []),{ id: "rename", label: "Rename thread" },{ id: "mark-unread", label: "Mark unread" },{ id: "delete", label: "Delete", destructive: true, icon: "trash" },@@ -1607,6 +2016,13 @@ export default function SidebarV2() {),);if (clicked._tag === "Failure") return;+ if (clicked.value?.startsWith("snooze:")) {+ const preset = snoozePresets.find(+ (candidate) => `snooze:${candidate.id}` === clicked.value,+ );+ if (preset) attemptSnooze(threadRef, preset);+ return;+ }switch (clicked.value) {case "new-thread-on-branch": {// Explicit branch carry-over: reuse the thread's worktree when it@@ -1637,6 +2053,9 @@ export default function SidebarV2() {case "unsettle":attemptUnsettle(threadRef);return;+ case "unsnooze":+ attemptUnsnooze(threadRef);+ return;case "rename":startThreadRename(threadRef, thread.title);return;@@ -1676,7 +2095,9 @@ export default function SidebarV2() {},[attemptSettle,+ attemptSnooze,attemptUnsettle,+ attemptUnsnooze,confirmThreadDelete,deleteThread,handleMultiSelectContextMenu,@@ -1930,7 +2351,7 @@ export default function SidebarV2() {</div></SidebarGroup>) : null}- <SidebarGroup className="min-h-0 flex-1 overflow-y-auto px-2 py-1">+ <SidebarGroup className="min-h-0 flex-1 overflow-y-auto px-2 py-1 [scrollbar-gutter:stable]"><TooltipProviderkey="sidebar-thread-tooltips-150"delay={150}@@ -1938,88 +2359,156 @@ export default function SidebarV2() {timeout={400}><ul ref={attachListAutoAnimateRef} role="list" className="flex flex-col gap-px">- {orderedThreads.flatMap((thread, threadIndex) => {- const threadKey = scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id));- const isSettledRow = settledThreadKeys.has(threadKey);- // Settled is the ONLY thing that collapses a row: every- // not-settled thread is a full card. Density comes from users- // (or the auto rules) actually settling work, not from the- // sidebar second-guessing what still matters.- const isCard = !isSettledRow;- const previousThread = threadIndex > 0 ? orderedThreads[threadIndex - 1] : null;- const previousWasCard =- previousThread != null &&- !settledThreadKeys.has(- scopedThreadKey(- scopeThreadRef(previousThread.environmentId, previousThread.id),- ),+ {(() => {+ const renderThreadRow = (+ thread: EnvironmentThreadShell,+ section: "active" | "snoozed" | "settled",+ ) => {+ const threadKey = scopedThreadKey(+ scopeThreadRef(thread.environmentId, thread.id),);- const showSettledGap = !isCard && previousWasCard;- const row = (- <SidebarV2Row- // Keyed per variant on purpose: when a thread settles, the- // card fades out in place and the slim row fades in at its- // settled position instead of one element FLIP-sliding- // through every row in between (rows here are translucent,- // so a crossing row reads as text painted over text).- key={`${threadKey}:${isCard ? "card" : "slim"}`}- thread={thread}- variant={isCard ? "card" : "slim"}- // Every settled row can un-settle: explicit settles clear- // the override, auto-settled rows get pinned active.- variantAction={isSettledRow ? "unsettle" : "settle"}- settlementSupported={- serverConfigs.get(thread.environmentId)?.environment.capabilities- .threadSettlement === true- }- isActive={routeThreadKey === threadKey}- jumpLabel={showJumpHints ? (jumpLabelByKey.get(threadKey) ?? null) : null}- currentEnvironmentId={primaryEnvironmentId}- environmentLabel={environmentLabelById.get(thread.environmentId) ?? null}- projectCwd={- projectCwdByKey.get(`${thread.environmentId}:${thread.projectId}`) ?? null- }- projectTitle={- projectDisplayNameByKey.get(`${thread.environmentId}:${thread.projectId}`) ??- null- }- providerEntryByInstanceId={providerEntryByInstanceId}- onThreadClick={handleThreadClick}- onThreadActivate={navigateToThread}- onStartRename={startThreadRename}- onRenameTitleChange={setRenamingTitle}- onCommitRename={commitThreadRename}- onCancelRename={cancelThreadRename}- isRenaming={renamingThreadKey === threadKey}- renamingTitle={renamingThreadKey === threadKey ? renamingTitle : ""}- onContextMenu={handleThreadContextMenu}- onSettle={attemptSettle}- onUnsettle={attemptUnsettle}- onChangeRequestState={handleChangeRequestState}- />+ // Settled and snoozed are the ONLY things that collapse a+ // row: every other thread is a full card. Density comes+ // from users (or the auto rules) actually parking work,+ // not from the sidebar second-guessing what still matters.+ const isCard = section === "active";+ const rowVariant = isCard ? "card" : "slim";+ return (+ <SidebarV2Row+ // Keyed per variant on purpose: when a thread settles,+ // the card fades out in place and the slim row fades+ // in at its settled position instead of one element+ // FLIP-sliding through every row in between (rows here+ // are translucent, so a crossing row reads as text+ // painted over text).+ key={`${threadKey}:${rowVariant}`}+ thread={thread}+ variant={rowVariant}+ // Snoozed rows wake; settled rows un-settle (explicit+ // settles clear the override, auto-settled rows get+ // pinned active); cards settle.+ variantAction={+ section === "snoozed"+ ? "unsnooze"+ : section === "settled"+ ? "unsettle"+ : "settle"+ }+ settlementSupported={+ serverConfigs.get(thread.environmentId)?.environment.capabilities+ .threadSettlement === true+ }+ snoozeSupported={+ serverConfigs.get(thread.environmentId)?.environment.capabilities+ .threadSnooze === true+ }+ snoozeWakeLabelText={+ section === "snoozed" && thread.snoozedUntil != null+ ? snoozeWakeLabel(thread.snoozedUntil, new Date())+ : null+ }+ // All sections: a woken thread can classify straight+ // into the settled tail (PR merged while snoozed), and+ // the wake signal must survive the trip. Still-snoozed+ // rows resolve to null on their own.+ wokeAt={threadWokeAt(thread, { now: snoozeNow })}+ isActive={routeThreadKey === threadKey}+ jumpLabel={showJumpHints ? (jumpLabelByKey.get(threadKey) ?? null) : null}+ currentEnvironmentId={primaryEnvironmentId}+ environmentLabel={environmentLabelById.get(thread.environmentId) ?? null}+ projectCwd={+ projectCwdByKey.get(`${thread.environmentId}:${thread.projectId}`) ?? null+ }+ projectTitle={+ projectDisplayNameByKey.get(+ `${thread.environmentId}:${thread.projectId}`,+ ) ?? null+ }+ providerEntryByInstanceId={providerEntryByInstanceId}+ onThreadClick={handleThreadClick}+ onThreadActivate={navigateToThread}+ onStartRename={startThreadRename}+ onRenameTitleChange={setRenamingTitle}+ onCommitRename={commitThreadRename}+ onCancelRename={cancelThreadRename}+ isRenaming={renamingThreadKey === threadKey}+ renamingTitle={renamingThreadKey === threadKey ? renamingTitle : ""}+ onContextMenu={handleThreadContextMenu}+ onSettle={attemptSettle}+ onUnsettle={attemptUnsettle}+ onSnooze={attemptSnooze}+ onUnsnooze={attemptUnsnooze}+ onChangeRequestState={handleChangeRequestState}+ />+ );+ };+ const items: ReactNode[] = activeThreads.map((thread) =>+ renderThreadRow(thread, "active"),);- if (!showSettledGap) return [row];- // The divider is its own keyed list item (not part of the first- // settled row): it keeps one stable DOM node at the boundary,- // so settling a thread slides it instead of teleporting it- // along with whichever row happens to be first in the tail —- // and row heights stay independent of neighbor classification.- return [- <li- key="settled-divider"- aria-hidden- data-thread-selection-safe- className="list-none"- >- <div className="mb-1 mt-3 flex items-center gap-2 px-2.5">- <span className="text-xs font-medium text-muted-foreground/50">Settled</span>- <span className="h-px flex-1 bg-sidebar-border/60" />- </div>- </li>,- row,- ];- })}- {hiddenSettledCount > 0 ? (+ // Snoozed shelf: between the inbox and Settled — out of the+ // way, never gone. The header always renders while anything+ // is snoozed (the count is the whole footprint when+ // collapsed); rows only when expanded. Vanishes entirely at+ // count 0.+ if (snoozedThreads.length > 0) {+ items.push(+ <li key="snoozed-shelf-header" data-thread-selection-safe className="list-none">+ <button+ type="button"+ onClick={toggleSnoozedShelf}+ aria-expanded={snoozedShelfExpanded}+ data-testid="sidebar-v2-snoozed-shelf-toggle"+ className="mb-1 mt-3 flex w-full cursor-pointer items-center gap-2 px-2.5 text-left"+ >+ <span className="text-xs font-medium text-blue-600 dark:text-blue-400">+ {snoozedShelfExpanded ? "Snoozed" : `Snoozed (${snoozedThreads.length})`}+ </span>+ <span className="h-px flex-1 bg-blue-500/20 dark:bg-blue-400/15" />+ <ChevronDownIcon+ aria-hidden+ className={cn(+ "size-3 text-blue-600 transition-transform dark:text-blue-400",+ snoozedShelfExpanded && "rotate-180",+ )}+ />+ </button>+ </li>,+ );+ for (const thread of visibleSnoozedThreads) {+ items.push(renderThreadRow(thread, "snoozed"));+ }+ }+ if (settledThreads.length > 0) {+ items.push(+ <li key="settled-shelf-header" data-thread-selection-safe className="list-none">+ <button+ type="button"+ onClick={toggleSettledShelf}+ aria-expanded={settledShelfExpanded}+ data-testid="sidebar-v2-settled-shelf-toggle"+ className="mb-1 mt-3 flex w-full cursor-pointer items-center gap-2 px-2.5 text-left"+ >+ <span className="text-xs font-medium text-muted-foreground/50">+ {settledShelfExpanded ? "Settled" : `Settled (${settledThreads.length})`}+ </span>+ <span className="h-px flex-1 bg-sidebar-border/60" />+ <ChevronDownIcon+ aria-hidden+ className={cn(+ "size-3 text-muted-foreground/50 transition-transform",+ settledShelfExpanded && "rotate-180",+ )}+ />+ </button>+ </li>,+ );+ }+ for (const thread of renderedSettledThreads) {+ items.push(renderThreadRow(thread, "settled"));+ }+ return items;+ })()}+ {settledShelfExpanded && hiddenSettledCount > 0 ? (<li className="list-none"><buttontype="button"@@ -2035,7 +2524,7 @@ export default function SidebarV2() {) : null}</ul></TooltipProvider>- {orderedThreads.length === 0 ? (+ {activeThreads.length + snoozedThreads.length + settledThreads.length === 0 ? (<div className="flex flex-col items-center gap-2 px-2 py-6 text-center text-xs text-muted-foreground/60">{projects.length === 0 ? (<>diff --git a/apps/web/src/hooks/useThreadActions.ts b/apps/web/src/hooks/useThreadActions.tsindex de31ff09a..91a3779a0 100644--- a/apps/web/src/hooks/useThreadActions.ts+++ b/apps/web/src/hooks/useThreadActions.ts@@ -4,7 +4,7 @@ import {scopeThreadRef,} from "@t3tools/client-runtime/environment";import { settlePromise, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";-import { canSettle } from "@t3tools/client-runtime/state/thread-settled";+import { canSettle, canSnooze } from "@t3tools/client-runtime/state/thread-settled";import { EnvironmentId, type ScopedThreadRef, ThreadId } from "@t3tools/contracts";import * as Cause from "effect/Cause";import * as Schema from "effect/Schema";@@ -22,6 +22,7 @@ import { refreshArchivedThreadsForEnvironment } from "../lib/archivedThreadsStatimport { readLocalApi } from "../localApi";import {readEnvironmentSupportsSettlement,+ readEnvironmentSupportsSnooze,readEnvironmentThreadRefs,readProject,readThreadShell,@@ -69,6 +70,30 @@ export class ThreadSettleBlockedError extends Schema.TaggedErrorClass<ThreadSett}}+export class ThreadSnoozeUnsupportedError extends Schema.TaggedErrorClass<ThreadSnoozeUnsupportedError>()(+ "ThreadSnoozeUnsupportedError",+ {+ environmentId: EnvironmentId,+ threadId: ThreadId,+ },+) {+ override get message(): string {+ return "This environment's server does not support snoozing yet. Update the server to use Snooze.";+ }+}++export class ThreadSnoozeBlockedError extends Schema.TaggedErrorClass<ThreadSnoozeBlockedError>()(+ "ThreadSnoozeBlockedError",+ {+ environmentId: EnvironmentId,+ threadId: ThreadId,+ },+) {+ override get message(): string {+ return "This thread is waiting on you. Respond to the pending request before snoozing it.";+ }+}+export function useThreadActions() {const closeTerminal = useAtomCommand(terminalEnvironment.close);const archiveThreadMutation = useAtomCommand(threadEnvironment.archive, {@@ -86,6 +111,12 @@ export function useThreadActions() {const unsettleThreadMutation = useAtomCommand(threadEnvironment.unsettle, {reportFailure: false,});+ const snoozeThreadMutation = useAtomCommand(threadEnvironment.snooze, {+ reportFailure: false,+ });+ const unsnoozeThreadMutation = useAtomCommand(threadEnvironment.unsnooze, {+ reportFailure: false,+ });const stopThreadSession = useAtomCommand(threadEnvironment.stopSession);const removeWorktree = useAtomCommand(vcsEnvironment.removeWorktree, {reportFailure: false,@@ -441,6 +472,61 @@ export function useThreadActions() {[unsettleThreadMutation],);+ const snoozeThread = useCallback(+ async (target: ScopedThreadRef, snoozedUntil: string) => {+ // Version skew: never send the command to a server that predates it.+ if (!readEnvironmentSupportsSnooze(target.environmentId)) {+ return AsyncResult.failure(+ Cause.fail(+ new ThreadSnoozeUnsupportedError({+ environmentId: target.environmentId,+ threadId: target.threadId,+ }),+ ),+ );+ }+ const resolved = resolveThreadTarget(target);+ // Blocked-on-you work and queued turns can't be snoozed away —+ // client-side twin of the server invariants so the UI rejects before+ // a round trip.+ if (resolved && !canSnooze(resolved.thread, { now: new Date().toISOString() })) {+ return AsyncResult.failure(+ Cause.fail(+ new ThreadSnoozeBlockedError({+ environmentId: resolved.threadRef.environmentId,+ threadId: resolved.threadRef.threadId,+ }),+ ),+ );+ }+ return snoozeThreadMutation({+ environmentId: target.environmentId,+ input: { threadId: target.threadId, snoozedUntil },+ });+ },+ [resolveThreadTarget, snoozeThreadMutation],+ );++ const unsnoozeThread = useCallback(+ async (target: ScopedThreadRef) => {+ if (!readEnvironmentSupportsSnooze(target.environmentId)) {+ return AsyncResult.failure(+ Cause.fail(+ new ThreadSnoozeUnsupportedError({+ environmentId: target.environmentId,+ threadId: target.threadId,+ }),+ ),+ );+ }+ return unsnoozeThreadMutation({+ environmentId: target.environmentId,+ input: { threadId: target.threadId, reason: "user" },+ });+ },+ [unsnoozeThreadMutation],+ );+const confirmAndDeleteThread = useCallback(async (target: ScopedThreadRef) => {const localApi = readLocalApi();@@ -477,14 +563,18 @@ export function useThreadActions() {confirmAndDeleteThread,settleThread,unsettleThread,+ snoozeThread,+ unsnoozeThread,}),[archiveThread,confirmAndDeleteThread,deleteThread,settleThread,+ snoozeThread,unarchiveThread,unsettleThread,+ unsnoozeThread,],);}diff --git a/apps/web/src/state/entities.ts b/apps/web/src/state/entities.tsindex e85fc1d11..9bd20070c 100644--- a/apps/web/src/state/entities.ts+++ b/apps/web/src/state/entities.ts@@ -207,6 +207,15 @@ export function readEnvironmentSupportsSettlement(environmentId: EnvironmentId):);}+/** Whether the environment's server understands thread.snooze/unsnooze.+ Same version-skew contract as settlement. */+export function readEnvironmentSupportsSnooze(environmentId: EnvironmentId): boolean {+ return (+ appAtomRegistry.get(environmentServerConfigsAtom).get(environmentId)?.environment.capabilities+ .threadSnooze === true+ );+}+export function readThreadDetail(ref: ScopedThreadRef): EnvironmentThread | null {return appAtomRegistry.get(environmentThreadDetails.detailAtom(ref));}diff --git a/apps/web/src/timestampFormat.ts b/apps/web/src/timestampFormat.tsindex 31cc41798..cce5b141c 100644--- a/apps/web/src/timestampFormat.ts+++ b/apps/web/src/timestampFormat.ts@@ -40,7 +40,7 @@ function getTimestampFormatter(return formatter;}-function parseTimestampDate(isoDate: string): Date | null {+export function parseTimestampDate(isoDate: string): Date | null {const date = new Date(isoDate);return Number.isNaN(date.getTime()) ? null : date;}diff --git a/packages/client-runtime/src/operations/commands.ts b/packages/client-runtime/src/operations/commands.tsindex ef7678548..ad25d6544 100644--- a/packages/client-runtime/src/operations/commands.ts+++ b/packages/client-runtime/src/operations/commands.ts@@ -37,6 +37,8 @@ export type ArchiveThreadInput = CommandInput<"thread.archive">;export type UnarchiveThreadInput = CommandInput<"thread.unarchive">;export type SettleThreadInput = CommandInput<"thread.settle">;export type UnsettleThreadInput = CommandInput<"thread.unsettle">;+export type SnoozeThreadInput = CommandInput<"thread.snooze">;+export type UnsnoozeThreadInput = CommandInput<"thread.unsnooze">;export type UpdateThreadMetadataInput = CommandInput<"thread.meta.update">;export type SetThreadRuntimeModeInput = CommandInput<"thread.runtime-mode.set">;export type SetThreadInteractionModeInput = CommandInput<"thread.interaction-mode.set">;@@ -175,6 +177,26 @@ export const unsettleThread: (input: UnsettleThreadInput) => CommandEffect = Eff});});+export const snoozeThread: (input: SnoozeThreadInput) => CommandEffect = Effect.fn(+ "EnvironmentCommands.snoozeThread",+)(function* (input) {+ return yield* dispatch({+ ...input,+ type: "thread.snooze",+ commandId: yield* commandId(input),+ });+});++export const unsnoozeThread: (input: UnsnoozeThreadInput) => CommandEffect = Effect.fn(+ "EnvironmentCommands.unsnoozeThread",+)(function* (input) {+ return yield* dispatch({+ ...input,+ type: "thread.unsnooze",+ commandId: yield* commandId(input),+ });+});+export const updateThreadMetadata: (input: UpdateThreadMetadataInput) => CommandEffect = Effect.fn("EnvironmentCommands.updateThreadMetadata",)(function* (input) {diff --git a/packages/client-runtime/src/state/threadCommands.ts b/packages/client-runtime/src/state/threadCommands.tsindex ea87298e9..6c128eb01 100644--- a/packages/client-runtime/src/state/threadCommands.ts+++ b/packages/client-runtime/src/state/threadCommands.ts@@ -13,10 +13,12 @@ import {type SetThreadInteractionModeInput,type SetThreadRuntimeModeInput,type SettleThreadInput,+ type SnoozeThreadInput,type StartThreadTurnInput,type StopThreadSessionInput,type UnarchiveThreadInput,type UnsettleThreadInput,+ type UnsnoozeThreadInput,type UpdateThreadMetadataInput,archiveThread,createThread,@@ -28,10 +30,12 @@ import {setThreadInteractionMode,setThreadRuntimeMode,settleThread,+ snoozeThread,startThreadTurn,stopThreadSession,unarchiveThread,unsettleThread,+ unsnoozeThread,updateThreadMetadata,} from "../operations/commands.ts";import type { EnvironmentRegistry } from "../connection/registry.ts";@@ -47,10 +51,12 @@ export type {SetThreadInteractionModeInput,SetThreadRuntimeModeInput,SettleThreadInput,+ SnoozeThreadInput,StartThreadTurnInput,StopThreadSessionInput,UnarchiveThreadInput,UnsettleThreadInput,+ UnsnoozeThreadInput,UpdateThreadMetadataInput,} from "../operations/commands.ts";@@ -100,6 +106,18 @@ export function createThreadEnvironmentAtoms<R, E>(scheduler,concurrency,}),+ snooze: createEnvironmentCommand(runtime, {+ label: "environment-data:commands:thread:snooze",+ execute: (input: SnoozeThreadInput) => snoozeThread(input),+ scheduler,+ concurrency,+ }),+ unsnooze: createEnvironmentCommand(runtime, {+ label: "environment-data:commands:thread:unsnooze",+ execute: (input: UnsnoozeThreadInput) => unsnoozeThread(input),+ scheduler,+ concurrency,+ }),updateMetadata: createEnvironmentCommand(runtime, {label: "environment-data:commands:thread:update-metadata",execute: (input: UpdateThreadMetadataInput) => updateThreadMetadata(input),diff --git a/packages/client-runtime/src/state/threadDetail.ts b/packages/client-runtime/src/state/threadDetail.tsindex 770738ad9..eac5ab87d 100644--- a/packages/client-runtime/src/state/threadDetail.ts+++ b/packages/client-runtime/src/state/threadDetail.ts@@ -59,6 +59,8 @@ export function mergeEnvironmentThread(archivedAt: shell.archivedAt,settledOverride: shell.settledOverride,settledAt: shell.settledAt,+ snoozedUntil: shell.snoozedUntil,+ snoozedAt: shell.snoozedAt,session: shell.session,};}diff --git a/packages/client-runtime/src/state/threadReducer.ts b/packages/client-runtime/src/state/threadReducer.tsindex 7fdee37c0..ce0dca52f 100644--- a/packages/client-runtime/src/state/threadReducer.ts+++ b/packages/client-runtime/src/state/threadReducer.ts@@ -74,6 +74,8 @@ export function applyThreadDetailEvent(archivedAt: null,settledOverride: null,settledAt: null,+ snoozedUntil: null,+ snoozedAt: null,deletedAt: null,messages: [],proposedPlans: [],@@ -124,6 +126,28 @@ export function applyThreadDetailEvent(},};+ case "thread.snoozed":+ return {+ kind: "updated",+ thread: {+ ...thread,+ snoozedUntil: event.payload.snoozedUntil,+ snoozedAt: event.payload.snoozedAt,+ updatedAt: event.payload.updatedAt,+ },+ };++ case "thread.unsnoozed":+ return {+ kind: "updated",+ thread: {+ ...thread,+ snoozedUntil: null,+ snoozedAt: null,+ updatedAt: event.payload.updatedAt,+ },+ };+// ── Thread metadata ─────────────────────────────────────────────case "thread.meta-updated":return {diff --git a/packages/client-runtime/src/state/threadSettled.ts b/packages/client-runtime/src/state/threadSettled.tsindex 85d1649c2..0d077c892 100644--- a/packages/client-runtime/src/state/threadSettled.ts+++ b/packages/client-runtime/src/state/threadSettled.ts@@ -90,6 +90,130 @@ export function canSettle(return true;}+/**+ * The snooze lifecycle fields plus everything needed to detect a raised+ * hand. Snooze is an overlay on the active state: a snoozed thread stays+ * "active" in the data model and is only suppressed from the inbox until+ * its wake time passes or the thread demands attention.+ */+export type ThreadSnoozeShell = Pick<+ OrchestrationThreadShell,+ | "snoozedUntil"+ | "snoozedAt"+ | "hasPendingApprovals"+ | "hasPendingUserInput"+ | "session"+ | "latestTurn"+>;++/**+ * A snoozed thread "raises its hand" when something happens that outranks+ * the user's snooze: the agent is blocked on them (approval / user input),+ * the session failed, or a run completed after the snooze was set — the+ * v1 taste of event-based snooze ("something happened" wakes early).+ * Raising a hand never clears the server-side snooze fields; it only stops+ * the thread from CLASSIFYING as snoozed, exactly like blocked work and+ * effectiveSettled.+ */+export function threadRaisedHandWhileSnoozed(shell: ThreadSnoozeShell): boolean {+ if (shell.hasPendingApprovals || shell.hasPendingUserInput) return true;+ // Only a FRESH failure raises the hand: a thread snoozed while already+ // failed stays snoozed — that snooze was the user saying "I saw it, not+ // now". session.updatedAt stamps the status edge, so an error newer than+ // the snooze is new information.+ if (+ shell.session?.status === "error" &&+ (shell.snoozedAt == null || Date.parse(shell.session.updatedAt) > Date.parse(shell.snoozedAt))+ ) {+ return true;+ }+ if (+ shell.snoozedAt != null &&+ shell.latestTurn?.state === "completed" &&+ shell.latestTurn.completedAt != null &&+ Date.parse(shell.latestTurn.completedAt) > Date.parse(shell.snoozedAt)+ ) {+ return true;+ }+ return false;+}++/**+ * A thread may be snoozed unless the agent is blocked on the user: hiding a+ * pending approval or user-input request defeats the request, and a queued+ * turn start (a message no turn has adopted yet) is invisible pending work+ * the same way it is for settle. A running session IS snoozable — snooze+ * only affects visibility, never the agent. Client-side twin of the server+ * invariants so the UI can reject before a round trip.+ */+export function canSnooze(+ shell: Pick<+ OrchestrationThreadShell,+ "hasPendingApprovals" | "hasPendingUserInput" | "latestUserMessageAt" | "latestTurn" | "session"+ >,+ options: { readonly now: string },+): boolean {+ if (shell.hasPendingApprovals || shell.hasPendingUserInput) return false;+ if (hasQueuedTurnStart(shell, options)) return false;+ return true;+}++/**+ * Snoozed resolution: hidden from the inbox while the wake time is in the+ * future and the thread has not raised its hand. Timer wakes are derived —+ * no server event fires when snoozedUntil passes; the stale fields simply+ * stop classifying as snoozed (and feed the woke indicator until the user+ * visits or re-engages).+ */+export function effectiveSnoozed(+ shell: ThreadSnoozeShell,+ options: { readonly now: string },+): boolean {+ if (shell.snoozedUntil == null) return false;+ const wakeAtMs = Date.parse(shell.snoozedUntil);+ // Malformed data never hides a thread.+ if (Number.isNaN(wakeAtMs)) return false;+ if (wakeAtMs <= Date.parse(options.now)) return false;+ return !threadRaisedHandWhileSnoozed(shell);+}++/**+ * When a previously-snoozed thread woke, or null if it never snoozed / is+ * still snoozed. Used for the "Woke" indicator: the thread reappears in its+ * original sort position (the inbox sort is deliberately static), so the+ * wake signal has to carry the weight. Compare against the client's+ * lastVisitedAt — visiting clears the indicator like it clears unread.+ *+ * Timer wakes report the wake time itself; raised-hand wakes report the+ * triggering timestamp so a visit BEFORE the early wake doesn't suppress+ * the indicator.+ */+export function threadWokeAt(+ shell: ThreadSnoozeShell,+ options: { readonly now: string },+): string | null {+ if (shell.snoozedUntil == null) return null;+ const wakeAtMs = Date.parse(shell.snoozedUntil);+ if (Number.isNaN(wakeAtMs)) return null;+ // An early hand-raise wake stays authoritative even after the scheduled+ // wake time passes: reporting snoozedUntil then would resurface a Woke+ // indicator the user already cleared by visiting (snoozedUntil is newer+ // than that visit's lastVisitedAt).+ if (threadRaisedHandWhileSnoozed(shell)) {+ if (+ shell.snoozedAt != null &&+ shell.latestTurn?.state === "completed" &&+ shell.latestTurn.completedAt != null &&+ Date.parse(shell.latestTurn.completedAt) > Date.parse(shell.snoozedAt)+ ) {+ return shell.latestTurn.completedAt;+ }+ return shell.session?.updatedAt ?? shell.snoozedAt ?? null;+ }+ // No raised hand: woke iff the timer elapsed (still-snoozed → null).+ return wakeAtMs <= Date.parse(options.now) ? shell.snoozedUntil : null;+}+/*** A merged/closed change request settles its thread only once the thread has* been idle this long. Without the idle guard the merge signal is permanent:diff --git a/packages/client-runtime/src/state/threadSnoozed.test.ts b/packages/client-runtime/src/state/threadSnoozed.test.tsnew file mode 100644index 000000000..c26d23e26--- /dev/null+++ b/packages/client-runtime/src/state/threadSnoozed.test.ts@@ -0,0 +1,237 @@+import { ThreadId } from "@t3tools/contracts";+import { TurnId } from "@t3tools/contracts";+import { describe, expect, it } from "vite-plus/test";++import {+ canSnooze,+ effectiveSnoozed,+ threadRaisedHandWhileSnoozed,+ threadWokeAt,+ type ThreadSnoozeShell,+} from "./threadSettled.ts";++const NOW = "2026-04-10T12:00:00.000Z";+const SNOOZED_AT = "2026-04-10T09:00:00.000Z";+const FUTURE_WAKE = "2026-04-11T09:00:00.000Z";+const PAST_WAKE = "2026-04-10T10:00:00.000Z";++function makeShell(input: {+ readonly snoozedUntil?: string | null;+ readonly snoozedAt?: string | null;+ readonly sessionStatus?: "starting" | "running" | "ready" | "error";+ readonly pending?: "approval" | "user-input";+ readonly turnCompletedAt?: string | null;+}): ThreadSnoozeShell {+ const threadId = ThreadId.make("thread-1");+ return {+ snoozedUntil: input.snoozedUntil ?? null,+ snoozedAt: input.snoozedAt ?? (input.snoozedUntil != null ? SNOOZED_AT : null),+ hasPendingApprovals: input.pending === "approval",+ hasPendingUserInput: input.pending === "user-input",+ session:+ input.sessionStatus === undefined+ ? null+ : {+ threadId,+ status: input.sessionStatus,+ providerName: "Codex",+ runtimeMode: "full-access",+ activeTurnId: null,+ lastError: input.sessionStatus === "error" ? "boom" : null,+ updatedAt: "2026-04-10T11:00:00.000Z",+ },+ latestTurn:+ input.turnCompletedAt === undefined+ ? null+ : {+ turnId: TurnId.make("turn-1"),+ state: "completed",+ requestedAt: SNOOZED_AT,+ startedAt: null,+ completedAt: input.turnCompletedAt,+ assistantMessageId: null,+ },+ };+}++describe("effectiveSnoozed", () => {+ it("hides a thread whose wake time is in the future", () => {+ expect(effectiveSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE }), { now: NOW })).toBe(true);+ });++ it("stops classifying as snoozed once the wake time passes (timer wake, no event)", () => {+ expect(effectiveSnoozed(makeShell({ snoozedUntil: PAST_WAKE }), { now: NOW })).toBe(false);+ });++ it("never snoozes a thread with no snooze state", () => {+ expect(effectiveSnoozed(makeShell({}), { now: NOW })).toBe(false);+ });++ it("never hides on malformed wake data", () => {+ expect(effectiveSnoozed(makeShell({ snoozedUntil: "not-a-date" }), { now: NOW })).toBe(false);+ });++ it("wakes early when the agent is blocked on the user", () => {+ expect(+ effectiveSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE, pending: "approval" }), {+ now: NOW,+ }),+ ).toBe(false);+ expect(+ effectiveSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE, pending: "user-input" }), {+ now: NOW,+ }),+ ).toBe(false);+ });++ it("wakes early on a failure that happened after the snooze", () => {+ // makeShell stamps session.updatedAt at 11:00, after SNOOZED_AT (9:00).+ expect(+ effectiveSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE, sessionStatus: "error" }), {+ now: NOW,+ }),+ ).toBe(false);+ });++ it("stays snoozed when the failure predates the snooze — the user saw it", () => {+ expect(+ effectiveSnoozed(+ makeShell({+ snoozedUntil: FUTURE_WAKE,+ sessionStatus: "error",+ // Snoozed AFTER the error's status edge.+ snoozedAt: "2026-04-10T11:30:00.000Z",+ }),+ { now: NOW },+ ),+ ).toBe(true);+ });++ it("stays snoozed while the session keeps working — snooze never pauses the agent", () => {+ expect(+ effectiveSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE, sessionStatus: "running" }), {+ now: NOW,+ }),+ ).toBe(true);+ });++ it("wakes early when a run completes after the snooze was set", () => {+ expect(+ effectiveSnoozed(+ makeShell({ snoozedUntil: FUTURE_WAKE, turnCompletedAt: "2026-04-10T10:30:00.000Z" }),+ { now: NOW },+ ),+ ).toBe(false);+ });++ it("ignores runs that completed before the snooze — the user saw that result", () => {+ expect(+ effectiveSnoozed(+ makeShell({ snoozedUntil: FUTURE_WAKE, turnCompletedAt: "2026-04-10T08:00:00.000Z" }),+ { now: NOW },+ ),+ ).toBe(true);+ });+});++describe("threadRaisedHandWhileSnoozed", () => {+ it("is false for a quiet snoozed thread", () => {+ expect(threadRaisedHandWhileSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE }))).toBe(false);+ });++ it("is true for approvals, input, and failures", () => {+ expect(+ threadRaisedHandWhileSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE, pending: "approval" })),+ ).toBe(true);+ expect(+ threadRaisedHandWhileSnoozed(makeShell({ snoozedUntil: FUTURE_WAKE, pending: "user-input" })),+ ).toBe(true);+ expect(+ threadRaisedHandWhileSnoozed(+ makeShell({ snoozedUntil: FUTURE_WAKE, sessionStatus: "error" }),+ ),+ ).toBe(true);+ });+});++describe("canSnooze", () => {+ it("allows snoozing quiet and working threads alike", () => {+ expect(canSnooze({ ...makeShell({}), latestUserMessageAt: null }, { now: NOW })).toBe(true);+ expect(+ canSnooze(+ { ...makeShell({ sessionStatus: "running" }), latestUserMessageAt: null },+ { now: NOW },+ ),+ ).toBe(true);+ });++ it("refuses blocked-on-you work", () => {+ expect(+ canSnooze({ ...makeShell({ pending: "approval" }), latestUserMessageAt: null }, { now: NOW }),+ ).toBe(false);+ expect(+ canSnooze(+ { ...makeShell({ pending: "user-input" }), latestUserMessageAt: null },+ { now: NOW },+ ),+ ).toBe(false);+ });++ it("refuses a queued turn start — same invisible-pending-work rule as settle", () => {+ // Fresh user message, no turn has adopted it, within the grace window.+ expect(+ canSnooze(+ { ...makeShell({}), latestUserMessageAt: "2026-04-10T11:59:30.000Z" },+ { now: NOW },+ ),+ ).toBe(false);+ // Outside the grace window the message is stale data, not queued work.+ expect(+ canSnooze(+ { ...makeShell({}), latestUserMessageAt: "2026-04-10T11:00:00.000Z" },+ { now: NOW },+ ),+ ).toBe(true);+ });+});++describe("threadWokeAt", () => {+ it("is null for never-snoozed and still-snoozed threads", () => {+ expect(threadWokeAt(makeShell({}), { now: NOW })).toBe(null);+ expect(threadWokeAt(makeShell({ snoozedUntil: FUTURE_WAKE }), { now: NOW })).toBe(null);+ });++ it("reports the wake time for a timer wake", () => {+ expect(threadWokeAt(makeShell({ snoozedUntil: PAST_WAKE }), { now: NOW })).toBe(PAST_WAKE);+ });++ it("reports the completion time for an early run-completed wake", () => {+ expect(+ threadWokeAt(+ makeShell({ snoozedUntil: FUTURE_WAKE, turnCompletedAt: "2026-04-10T10:30:00.000Z" }),+ { now: NOW },+ ),+ ).toBe("2026-04-10T10:30:00.000Z");+ });++ it("falls back to session activity for blocked/failed early wakes", () => {+ expect(+ threadWokeAt(makeShell({ snoozedUntil: FUTURE_WAKE, sessionStatus: "error" }), {+ now: NOW,+ }),+ ).toBe("2026-04-10T11:00:00.000Z");+ });++ it("keeps the early wake authoritative after the scheduled time passes", () => {+ // Woke early at 10:30 via run-completed; the scheduled wake (PAST_WAKE+ // 10:00 relative to a later now) has ALSO passed. Reporting the+ // scheduled time would resurface a Woke pill the user already cleared+ // by visiting between the early wake and now.+ expect(+ threadWokeAt(+ makeShell({ snoozedUntil: PAST_WAKE, turnCompletedAt: "2026-04-10T09:30:00.000Z" }),+ { now: NOW },+ ),+ ).toBe("2026-04-10T09:30:00.000Z");+ });+});diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.tsindex 936b97f6c..7f4b6c165 100644--- a/packages/contracts/src/environment.ts+++ b/packages/contracts/src/environment.ts@@ -44,6 +44,9 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({pre-settlement servers, so clients treat missing as unsupported andnever send the commands under version skew. */threadSettlement: Schema.optionalKey(Schema.Boolean),+ /** Server understands thread.snooze / thread.unsnooze commands. Same+ version-skew contract as threadSettlement. */+ threadSnooze: Schema.optionalKey(Schema.Boolean),/** The update path clients should offer for this server. Absent onservers that must be relaunched manually (dev checkouts, Windowsforeground runs, pre-update servers). */diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.tsindex e1ddbdbd0..84b7a8fa0 100644--- a/packages/contracts/src/orchestration.ts+++ b/packages/contracts/src/orchestration.ts@@ -361,6 +361,12 @@ export const OrchestrationThread = Schema.Struct({Schema.withDecodingDefault(Effect.succeed(null)),),settledAt: Schema.NullOr(IsoDateTime).pipe(Schema.withDecodingDefault(Effect.succeed(null))),+ // Snooze is an overlay on the active lifecycle, not a fourth destination:+ // a snoozed thread stays "active" in the model and is only suppressed from+ // the inbox until snoozedUntil passes (or the thread raises its hand).+ // Optional so payloads from pre-snooze servers still decode.+ snoozedUntil: Schema.optional(Schema.NullOr(IsoDateTime)),+ snoozedAt: Schema.optional(Schema.NullOr(IsoDateTime)),deletedAt: Schema.NullOr(IsoDateTime),messages: Schema.Array(OrchestrationMessage),proposedPlans: Schema.Array(OrchestrationProposedPlan).pipe(@@ -411,6 +417,8 @@ export const OrchestrationThreadShell = Schema.Struct({Schema.withDecodingDefault(Effect.succeed(null)),),settledAt: Schema.NullOr(IsoDateTime).pipe(Schema.withDecodingDefault(Effect.succeed(null))),+ snoozedUntil: Schema.optional(Schema.NullOr(IsoDateTime)),+ snoozedAt: Schema.optional(Schema.NullOr(IsoDateTime)),session: Schema.NullOr(OrchestrationSession),latestUserMessageAt: Schema.NullOr(IsoDateTime),hasPendingApprovals: Schema.Boolean,@@ -583,6 +591,27 @@ const ThreadUnsettleCommand = Schema.Struct({reason: Schema.Literal("user"),});+const ThreadSnoozeCommand = Schema.Struct({+ type: Schema.Literal("thread.snooze"),+ commandId: CommandId,+ threadId: ThreadId,+ // The wake time. Event-based wake conditions (PR merged, review posted)+ // will arrive as an optional condition field alongside this; time-based+ // snooze is just the first kind of condition.+ snoozedUntil: IsoDateTime,+});++const ThreadUnsnoozeCommand = Schema.Struct({+ type: Schema.Literal("thread.unsnooze"),+ commandId: CommandId,+ threadId: ThreadId,+ // Commands only carry "user": activity wakes are decided server-side (the+ // decider emits thread.unsnoozed(reason: "activity") directly), and timer+ // wakes need no event at all — clients derive visibility from snoozedUntil,+ // so a passed wake time simply stops classifying as snoozed.+ reason: Schema.Literal("user"),+});+const ThreadMetaUpdateCommand = Schema.Struct({type: Schema.Literal("thread.meta.update"),commandId: CommandId,@@ -727,6 +756,8 @@ const DispatchableClientOrchestrationCommand = Schema.Union([ThreadUnarchiveCommand,ThreadSettleCommand,ThreadUnsettleCommand,+ ThreadSnoozeCommand,+ ThreadUnsnoozeCommand,ThreadMetaUpdateCommand,ThreadRuntimeModeSetCommand,ThreadInteractionModeSetCommand,@@ -750,6 +781,8 @@ export const ClientOrchestrationCommand = Schema.Union([ThreadUnarchiveCommand,ThreadSettleCommand,ThreadUnsettleCommand,+ ThreadSnoozeCommand,+ ThreadUnsnoozeCommand,ThreadMetaUpdateCommand,ThreadRuntimeModeSetCommand,ThreadInteractionModeSetCommand,@@ -854,6 +887,8 @@ export const OrchestrationEventType = Schema.Literals(["thread.unarchived","thread.settled","thread.unsettled",+ "thread.snoozed",+ "thread.unsnoozed","thread.meta-updated","thread.runtime-mode-set","thread.interaction-mode-set",@@ -945,6 +980,23 @@ export const ThreadUnsettledPayload = Schema.Struct({updatedAt: IsoDateTime,});+export const ThreadSnoozedPayload = Schema.Struct({+ threadId: ThreadId,+ snoozedUntil: IsoDateTime,+ snoozedAt: IsoDateTime,+ updatedAt: IsoDateTime,+});++export const ThreadUnsnoozedPayload = Schema.Struct({+ threadId: ThreadId,+ // user: explicit "wake now". activity: real work arrived (user message /+ // session coming alive) and the decider cleared the snooze — mirrors+ // thread.unsettled's activity resets. Timer wakes emit no event: clients+ // derive them from snoozedUntil passing.+ reason: Schema.Literals(["user", "activity"]),+ updatedAt: IsoDateTime,+});+export const ThreadMetaUpdatedPayload = Schema.Struct({threadId: ThreadId,title: Schema.optional(TrimmedNonEmptyString),@@ -1122,6 +1174,16 @@ export const OrchestrationEvent = Schema.Union([type: Schema.Literal("thread.unsettled"),payload: ThreadUnsettledPayload,}),+ Schema.Struct({+ ...EventBaseFields,+ type: Schema.Literal("thread.snoozed"),+ payload: ThreadSnoozedPayload,+ }),+ Schema.Struct({+ ...EventBaseFields,+ type: Schema.Literal("thread.unsnoozed"),+ payload: ThreadUnsnoozedPayload,+ }),Schema.Struct({...EventBaseFields,type: Schema.Literal("thread.meta-updated"),