@devries-cameron20 / t3code Mirror · read-only / commits / 93a9e079b1
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 14:30 UTC

feat(threads): choose your own snooze options in settings (#26208)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Theo Browne committed Oct 27, 2026 at 18:58 UTC 93a9e079b107a13b0c312920b917b5f61a8f720c
22 files changed +909 -126
apps/mobile/src/features/home/HomeScreen.tsx
+2
@@ -432,6 +432,7 @@ export function HomeScreen(props: HomeScreenProps) {
432 machineByEnvironmentId,
433 settlementEnvironmentIds,
434 snoozeEnvironmentIds,
435 + snoozePresetsByEnvironmentId,
436 pinningEnvironmentIds,
437 autoSettleOptOutEnvironmentIds,
438 pinReorderEnvironmentIds,
@@ -602,6 +603,7 @@ export function HomeScreen(props: HomeScreenProps) {
603 settlementSupported={settlementEnvironmentIds.has(thread.environmentId)}
604 onSettleThread={handleSettleThread}
605 snoozeSupported={snoozeEnvironmentIds.has(thread.environmentId)}
606 + snoozePresets={snoozePresetsByEnvironmentId.get(thread.environmentId)}
607 pinningSupported={pinningEnvironmentIds.has(thread.environmentId)}
608 autoSettleOptOutSupported={autoSettleOptOutEnvironmentIds.has(thread.environmentId)}
609 reorderSupported={
apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx
+2
@@ -281,6 +281,7 @@ function ThreadNavigationSidebarPane(
281 machineByEnvironmentId,
282 settlementEnvironmentIds,
283 snoozeEnvironmentIds,
284 + snoozePresetsByEnvironmentId,
285 pinningEnvironmentIds,
286 autoSettleOptOutEnvironmentIds,
287 pinReorderEnvironmentIds,
@@ -588,6 +589,7 @@ function ThreadNavigationSidebarPane(
589 settlementSupported={settlementEnvironmentIds.has(thread.environmentId)}
590 onSettleThread={settleThread}
591 snoozeSupported={snoozeEnvironmentIds.has(thread.environmentId)}
592 + snoozePresets={snoozePresetsByEnvironmentId.get(thread.environmentId)}
593 pinningSupported={pinningEnvironmentIds.has(thread.environmentId)}
594 autoSettleOptOutSupported={autoSettleOptOutEnvironmentIds.has(thread.environmentId)}
595 reorderSupported={
apps/mobile/src/features/threads/thread-list-v2-items.tsx
+5
@@ -26,6 +26,7 @@ import {
26 resolveThreadWorkingStartedAt,
27 } from "@t3tools/client-runtime/state/models";
28 import { AuthOrchestrationOperateScope, type EnvironmentMachineKind } from "@t3tools/contracts";
29 +import type { SnoozePresetSetting } from "@t3tools/contracts/settings";
30 import { canSnooze } from "@t3tools/client-runtime/state/thread-settled";
31 import { threadChipCopyTarget } from "@t3tools/client-runtime/thread-reference";
32 import type { MenuAction } from "@react-native-menu/menu";
@@ -611,6 +612,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
612 readonly onSetThreadAutoSettle: (thread: EnvironmentThreadShell, enabled: boolean) => void;
613 readonly settlementSupported: boolean;
614 readonly snoozeSupported: boolean;
615 + readonly snoozePresets: ReadonlyArray<SnoozePresetSetting> | undefined;
616 readonly pinningSupported: boolean;
617 readonly autoSettleOptOutSupported: boolean;
618 readonly titleRegenerationSupported: boolean;
@@ -762,6 +764,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
764 const snoozePresets = resolveThreadListV2SnoozePresets({
765 secondary: swipeActions.secondary,
766 now: props.snoozePresetMinute || snoozeGateNow,
767 + presets: props.snoozePresets,
768 });
769 const snoozePresetActions = useMemo<MenuAction[]>(
770 () => [
@@ -941,6 +944,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
944 event: nativeEvent.event,
945 displayedPresets: snoozePresets,
946 now: new Date(),
947 + presets: props.snoozePresets,
948 });
949 if (snoozeSelection._tag === "selected") {
950 handleSnooze(snoozeSelection.preset.snoozedUntil);
@@ -969,6 +973,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: {
973 handleUnsnooze,
974 setCustomSnoozeOpen,
975 snoozePresets,
976 + props.snoozePresets,
977 ],
978 );
979 const primaryAction = useMemo(() => {
apps/mobile/src/features/threads/threadListV2.test.ts
+13 -7
@@ -59,19 +59,21 @@ function makeThread(
59 const NOW = "2026-06-02T00:00:00.000Z";
60
61 describe("resolveThreadListV2SnoozeMenuSelection", () => {
62 - it("recomputes presets that remain available instead of using old timestamps", () => {
63 - const displayedPresets = resolveSnoozePresets(new Date(2026, 4, 8, 10));
62 + it("recomputes the environment's presets instead of using old timestamps", () => {
63 + const presets = [{ kind: "after", minutes: 360 }] as const;
64 + const displayedPresets = resolveSnoozePresets(new Date(2026, 4, 8, 10), { presets });
65 const selectedAt = new Date(2026, 4, 8, 10, 30);
66 const selection = resolveThreadListV2SnoozeMenuSelection({
66 - event: "snooze:hour",
67 + event: "snooze:after:360",
68 displayedPresets,
69 now: selectedAt,
70 + presets,
71 });
72
73 expect(selection._tag).toBe("selected");
74 if (selection._tag === "selected") {
75 expect(selection.preset.snoozedUntil).toBe(
74 - new Date(selectedAt.getTime() + 60 * 60 * 1_000).toISOString(),
76 + new Date(selectedAt.getTime() + 6 * 60 * 60 * 1_000).toISOString(),
77 );
78 }
79 });
@@ -83,13 +85,17 @@ describe("resolveThreadListV2SnoozePresets", () => {
85 vi.useFakeTimers({ now: new Date(2026, 4, 8, 10) });
86 const laterMinute = new Date(2026, 4, 8, 19, 15).toISOString();
87
86 - const presets = resolveThreadListV2SnoozePresets({ secondary: "snooze", now: laterMinute });
88 + const presets = resolveThreadListV2SnoozePresets({
89 + secondary: "snooze",
90 + now: laterMinute,
91 + presets: undefined,
92 + });
93
88 - expect(presets.find((preset) => preset.id === "hour")?.snoozedUntil).toBe(
94 + expect(presets.find((preset) => preset.id === "after:60")?.snoozedUntil).toBe(
95 new Date(2026, 4, 8, 20, 15).toISOString(),
96 );
97 // The evening preset is gone by 19:15; a reading from 10:00 would still offer it.
92 - expect(presets.map((preset) => preset.id)).not.toContain("evening");
98 + expect(presets.map((preset) => preset.id)).not.toContain("at:today:18:00");
99 });
100 });
101
apps/mobile/src/features/threads/threadListV2.ts
+18 -14
@@ -2,6 +2,7 @@ import {
2 canSnooze,
3 effectiveSnoozed,
4 hasQueuedTurnStart,
5 + pickSnoozePreset,
6 QUEUED_TURN_START_GRACE_MS,
7 resolveSnoozePresets,
8 snoozeWakeLabel,
@@ -28,6 +29,7 @@ import {
29 sortSettledThreads,
30 } from "@t3tools/client-runtime/state/thread-sort";
31 import type { EnvironmentId, ProjectId } from "@t3tools/contracts";
32 +import type { SnoozePresetSetting } from "@t3tools/contracts/settings";
33
34 import type { ThreadListProvider } from "../../state/thread-list-environments";
35 import type { ThreadMoveAvailability } from "./threadOrder";
@@ -80,32 +82,34 @@ export type ThreadListV2SwipeAction = "archive" | "settle" | "unsettle" | "snooz
82 export function resolveThreadListV2SnoozePresets(input: {
83 readonly secondary: "snooze" | null;
84 readonly now: string;
85 + readonly presets: ReadonlyArray<SnoozePresetSetting> | undefined;
86 }): ReadonlyArray<SnoozePreset> {
84 - return input.secondary === "snooze" ? resolveSnoozePresets(new Date(input.now)) : [];
87 + return input.secondary === "snooze"
88 + ? resolveSnoozePresets(new Date(input.now), presetOptions(input.presets))
89 + : [];
90 +}
91 +
92 +function presetOptions(presets: ReadonlyArray<SnoozePresetSetting> | undefined) {
93 + return presets ? { presets } : {};
94 }
95
96 export function resolveThreadListV2SnoozeMenuSelection(input: {
97 readonly event: string;
98 readonly displayedPresets: ReadonlyArray<SnoozePreset>;
99 readonly now: Date;
100 + readonly presets: ReadonlyArray<SnoozePresetSetting> | undefined;
101 }):
102 | { readonly _tag: "selected"; readonly preset: SnoozePreset }
103 | { readonly _tag: "expired" }
104 | { readonly _tag: "not-snooze" } {
105 if (!input.event.startsWith("snooze:")) return { _tag: "not-snooze" };
96 -
97 - const currentPreset = resolveSnoozePresets(input.now).find(
98 - (candidate) => input.event === `snooze:${candidate.id}`,
99 - );
100 - if (currentPreset) return { _tag: "selected", preset: currentPreset };
101 -
102 - const displayedPreset = input.displayedPresets.find(
103 - (candidate) => input.event === `snooze:${candidate.id}`,
104 - );
105 - if (displayedPreset && Date.parse(displayedPreset.snoozedUntil) > input.now.getTime()) {
106 - return { _tag: "selected", preset: displayedPreset };
107 - }
108 - return { _tag: "expired" };
106 + const preset = pickSnoozePreset({
107 + shown: input.displayedPresets,
108 + id: input.event.slice("snooze:".length),
109 + now: input.now,
110 + ...presetOptions(input.presets),
111 + });
112 + return preset ? { _tag: "selected", preset } : { _tag: "expired" };
113 }
114
115 export function resolveThreadListV2SwipeActions(input: {
apps/mobile/src/state/thread-list-environments.ts
+9 -1
@@ -36,6 +36,7 @@ function selectEnvironment(config: ServerConfig) {
36 ),
37 machineKind: resolveEnvironmentMachineKind(config),
38 capabilities: config.environment.capabilities,
39 + snoozePresets: config.settings.snoozePresets,
40 };
41 }
42
@@ -71,8 +72,10 @@ function collectEnvironments(environments: ReadonlyMap<EnvironmentId, ListEnviro
72 const pinReorderEnvironmentIds = new Set<EnvironmentId>();
73 const activeReorderEnvironmentIds = new Set<EnvironmentId>();
74 const titleRegenerationEnvironmentIds = new Set<EnvironmentId>();
74 - for (const [id, { providers, machineKind, capabilities }] of environments) {
75 + const snoozePresetsByEnvironmentId = new Map<EnvironmentId, ListEnvironment["snoozePresets"]>();
76 + for (const [id, { providers, machineKind, capabilities, snoozePresets }] of environments) {
77 providersByEnvironmentId.set(id, providers);
78 + snoozePresetsByEnvironmentId.set(id, snoozePresets);
79 machineByEnvironmentId.set(id, machineKind);
80 if (capabilities.threadSettlement === true) settlementEnvironmentIds.add(id);
81 if (capabilities.threadSnooze === true) snoozeEnvironmentIds.add(id);
@@ -92,6 +95,7 @@ function collectEnvironments(environments: ReadonlyMap<EnvironmentId, ListEnviro
95 pinReorderEnvironmentIds,
96 activeReorderEnvironmentIds,
97 titleRegenerationEnvironmentIds,
98 + snoozePresetsByEnvironmentId,
99 };
100 }
101
@@ -110,10 +114,14 @@ export function createThreadListEnvironmentsAtom(
114 if (prior && sameProviders(prior.providers, selected.providers)) {
115 selected.providers = prior.providers;
116 }
117 + if (prior && JSON.stringify(prior.snoozePresets) === JSON.stringify(selected.snoozePresets)) {
118 + selected.snoozePresets = prior.snoozePresets;
119 + }
120 const unchanged =
121 prior &&
122 prior.providers === selected.providers &&
123 prior.machineKind === selected.machineKind &&
124 + prior.snoozePresets === selected.snoozePresets &&
125 capabilityKeys.every(
126 (key) => (prior.capabilities[key] === true) === (selected.capabilities[key] === true),
127 );
apps/web/src/components/Sidebar.snooze.ts
+41 -16
@@ -1,32 +1,57 @@
1 +import type { EnvironmentId } from "@t3tools/contracts";
2 import type { TimestampFormat } from "@t3tools/contracts/settings";
3 import {
4 + pickSnoozePreset as pickSharedSnoozePreset,
5 resolveSnoozePresets as resolveSharedSnoozePresets,
6 snoozeWakeLabel,
7 type SnoozePreset,
8 } from "@t3tools/client-runtime/state/thread-settled";
9
8 -import { formatShortTimestamp, parseTimestampDate } from "../timestampFormat";
10 +import { appAtomRegistry } from "../rpc/atomRegistry";
11 +import { serverEnvironment } from "../state/server";
12 +import { formatShortTimestamp } from "../timestampFormat";
13 +import { toastManager } from "./ui/toast";
14
15 export { snoozeWakeLabel, type SnoozePreset };
16
12 -function timeOfDayLabel(date: Date, timestampFormat: TimestampFormat): string {
13 - return formatShortTimestamp(date.toISOString(), timestampFormat);
14 -}
15 -
17 +/** The snooze menu for a thread, from its environment's presets, read when the menu opens. */
18 export function resolveSnoozePresets(
19 now: Date,
20 timestampFormat: TimestampFormat,
21 + environmentId: EnvironmentId,
22 ): ReadonlyArray<SnoozePreset> {
20 - return resolveSharedSnoozePresets(now).map((preset) => {
21 - const wake = parseTimestampDate(preset.snoozedUntil);
22 - if (wake === null) return preset;
23 - const time = timeOfDayLabel(wake, timestampFormat);
24 - return {
25 - ...preset,
26 - whenLabel:
27 - preset.id === "next-week"
28 - ? `${wake.toLocaleDateString(undefined, { weekday: "short" })} ${time}`
29 - : time,
30 - };
23 + return resolveSharedSnoozePresets(now, snoozeOptions(timestampFormat, environmentId));
24 +}
25 +
26 +/** A shown menu choice as picked; see the shared `pickSnoozePreset`. */
27 +export function pickSnoozePreset(
28 + shown: ReadonlyArray<SnoozePreset>,
29 + id: string,
30 + timestampFormat: TimestampFormat,
31 + environmentId: EnvironmentId,
32 +): SnoozePreset | undefined {
33 + const picked = pickSharedSnoozePreset({
34 + shown,
35 + id,
36 + now: new Date(),
37 + ...snoozeOptions(timestampFormat, environmentId),
38 });
39 + if (!picked) {
40 + toastManager.add({
41 + type: "warning",
42 + title: "Could not snooze thread",
43 + description: "That snooze time has passed. Choose another time.",
44 + });
45 + }
46 + return picked;
47 +}
48 +
49 +function snoozeOptions(timestampFormat: TimestampFormat, environmentId: EnvironmentId) {
50 + const presets = appAtomRegistry.get(
51 + serverEnvironment.settingsValueAtom(environmentId),
52 + )?.snoozePresets;
53 + return {
54 + ...(presets ? { presets } : {}),
55 + formatTime: (date: Date) => formatShortTimestamp(date.toISOString(), timestampFormat),
56 + };
57 }
apps/web/src/components/Sidebar.tsx
+31 -6
@@ -205,7 +205,12 @@ import {
205 } from "./Sidebar.drag";
206 import { SidebarPointerSensor } from "./Sidebar.pointer";
207 import { createSidebarListMotion } from "./Sidebar.motion";
208 -import { resolveSnoozePresets, snoozeWakeLabel, type SnoozePreset } from "./Sidebar.snooze";
208 +import {
209 + pickSnoozePreset,
210 + resolveSnoozePresets,
211 + snoozeWakeLabel,
212 + type SnoozePreset,
213 +} from "./Sidebar.snooze";
214 import { ProjectFavicon } from "./ProjectFavicon";
215 import { deriveProviderEntriesByEnvironment } from "../providerInstances";
216 import { useStableCallback } from "../hooks/useStableCallback";
@@ -2135,8 +2140,14 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2140 const unpinMenuItem = buildBulkUnpinContextMenuItem({
2141 pinnedCount: pinnedSelectedThreads.length,
2142 });
2143 + // Presets sync across environments, so the first selected thread's stand for all.
2144 // oxlint-disable-next-line react/purity -- runs in an event handler (oxc#27309)
2139 - const snoozePresets = resolveSnoozePresets(new Date(), timestampFormat);
2145 + const menuOpenedAt = new Date();
2146 + const snoozePresets = resolveSnoozePresets(
2147 + menuOpenedAt,
2148 + timestampFormat,
2149 + selectedThreads[0]!.environmentId,
2150 + );
2151 const clicked = await settlePromise(() =>
2152 api.contextMenu.show(
2153 [
@@ -2163,7 +2174,7 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2174 {
2175 id: "snooze:custom",
2176 label: "Custom…",
2166 - separatorBefore: true,
2177 + separatorBefore: snoozePresets.length > 0,
2178 disabled: !canOperateThreads(selectedThreads),
2179 },
2180 ],
@@ -2211,7 +2222,12 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2222 const preset =
2223 clicked.value === "snooze:custom"
2224 ? await requestCustomSnooze()
2214 - : snoozePresets.find((candidate) => `snooze:${candidate.id}` === clicked.value);
2225 + : pickSnoozePreset(
2226 + snoozePresets,
2227 + clicked.value.slice("snooze:".length),
2228 + timestampFormat,
2229 + selectedThreads[0]!.environmentId,
2230 + );
2231 if (preset) {
2232 const coSnoozingKeys = new Set(threadKeys);
2233 clearSelection();
@@ -2428,7 +2444,11 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2444 const isSettled = settledThreadKeysRef.current.has(threadKey);
2445 const isSnoozed = snoozedThreadKeysRef.current.has(threadKey);
2446 const isPinned = thread.pinnedAt != null;
2431 - const snoozePresets = resolveSnoozePresets(new Date(), timestampFormat);
2447 + const snoozePresets = resolveSnoozePresets(
2448 + new Date(),
2449 + timestampFormat,
2450 + thread.environmentId,
2451 + );
2452 const threadProjectGroup =
2453 projectGroupsRef.current.find((project) =>
2454 project.memberProjectRefs.some(
@@ -2479,7 +2499,12 @@ export default function Sidebar({ routeReveal }: { routeReveal: SidebarRouteReve
2499 const preset =
2500 clicked.value === "snooze:custom"
2501 ? await requestCustomSnooze()
2482 - : snoozePresets.find((candidate) => `snooze:${candidate.id}` === clicked.value);
2502 + : pickSnoozePreset(
2503 + snoozePresets,
2504 + clicked.value.slice("snooze:".length),
2505 + timestampFormat,
2506 + thread.environmentId,
2507 + );
2508 if (preset) attemptSnooze(threadRef, preset);
2509 return;
2510 }
apps/web/src/components/settings/SettingsPanels.tsx
+13 -1
@@ -54,6 +54,7 @@ import { useOptionalSettingsScope, useSettingsScope } from "./SettingsScopeConte
54 import { scopedIdleCompaction } from "./scopedSettings";
55 import { ProjectDefaultsSettings } from "./ProjectDefaultsSettings";
56 import { ThreadTitleInstructionsSettings } from "./ThreadTitleInstructionsSettings";
57 +import { SnoozePresetsRow } from "./SnoozePresetsSettings";
58 import { useDesktopUpdateState } from "../../state/desktopUpdate";
59 import {
60 getCustomModelOptionsByInstance,
@@ -452,6 +453,9 @@ export function useSettingsRestore(onRestored?: () => void) {
453 ...(settings.snoozeLimitedThreads !== DEFAULT_UNIFIED_SETTINGS.snoozeLimitedThreads
454 ? ["Snooze until limits reset"]
455 : []),
456 + ...(!Equal.equals(settings.snoozePresets, DEFAULT_UNIFIED_SETTINGS.snoozePresets)
457 + ? ["Snooze options"]
458 + : []),
459 ...(settings.wordWrap !== DEFAULT_UNIFIED_SETTINGS.wordWrap ? ["Word wrap"] : []),
460 ...(settings.persistComposerContextStrip !==
461 DEFAULT_UNIFIED_SETTINGS.persistComposerContextStrip
@@ -608,6 +612,7 @@ export function useSettingsRestore(onRestored?: () => void) {
612 sidebarAutoSettleOnMerge: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleOnMerge,
613 autoResumeLimitedThreads: DEFAULT_UNIFIED_SETTINGS.autoResumeLimitedThreads,
614 snoozeLimitedThreads: DEFAULT_UNIFIED_SETTINGS.snoozeLimitedThreads,
615 + snoozePresets: DEFAULT_UNIFIED_SETTINGS.snoozePresets,
616 responseStreamingMode: DEFAULT_UNIFIED_SETTINGS.responseStreamingMode,
617 enableProviderUpdateChecks: DEFAULT_UNIFIED_SETTINGS.enableProviderUpdateChecks,
618 continueThreadsAfterServerUpdate: DEFAULT_UNIFIED_SETTINGS.continueThreadsAfterServerUpdate,
@@ -1489,7 +1494,8 @@ export function ThreadsSettingsPanel() {
1494 const settings = useScopedSettings();
1495 const updateSettings = useUpdateScopedSettings();
1496 const navigate = useNavigate();
1492 - const { environment, connectedEnvironments, target } = useSettingsScope();
1497 + const { environment, connectedEnvironments, target, scope } = useSettingsScope();
1498 + const isProjectScope = scope.kind === "project" || scope.kind === "checkout";
1499 const environmentId = environment?.environmentId ?? null;
1500 const hasServerTargets = connectedEnvironments.length > 0;
1501 const mixedResponseStreamingMode = useScopedSettingsMixed(["responseStreamingMode"]);
@@ -1586,6 +1592,12 @@ export function ThreadsSettingsPanel() {
1592
1593 <ProjectDefaultsSettings category="general" />
1594
1595 + {!isProjectScope ? (
1596 + <SettingsSection id="snooze" title="Snooze">
1597 + <SnoozePresetsRow />
1598 + </SettingsSection>
1599 + ) : null}
1600 +
1601 <SettingsSection id="usage-limits" title="Usage limits">
1602 <SettingsRow
1603 serverScoped
apps/web/src/components/settings/SnoozePresetsSettings.logic.test.ts new
+20
@@ -0,0 +1,20 @@
1 +import { describe, expect, it } from "vite-plus/test";
2 +
3 +import { reconcileSnoozeDraft } from "./SnoozePresetsSettings.logic";
4 +
5 +describe("reconcileSnoozeDraft", () => {
6 + it("keeps the draft while our own writes echo back in order", () => {
7 + expect(reconcileSnoozeDraft(["a", "b"], "a")).toEqual({ adopt: false, pending: ["b"] });
8 + expect(reconcileSnoozeDraft(["b"], "b")).toEqual({ adopt: false, pending: [] });
9 + });
10 +
11 + it("adopts a value from elsewhere, even one this editor wrote earlier", () => {
12 + expect(reconcileSnoozeDraft(["b"], "c")).toEqual({ adopt: true });
13 + // "a" was written and acknowledged before; seeing it again means someone restored it.
14 + expect(reconcileSnoozeDraft([], "a")).toEqual({ adopt: true });
15 + });
16 +
17 + it("acknowledges every earlier write when a later one echoes", () => {
18 + expect(reconcileSnoozeDraft(["a", "b", "a"], "b")).toEqual({ adopt: false, pending: ["a"] });
19 + });
20 +});
apps/web/src/components/settings/SnoozePresetsSettings.logic.ts new
+15
@@ -0,0 +1,15 @@
1 +import * as Equal from "effect/Equal";
2 +
3 +/**
4 + * Reads a server value against the editor's writes still in flight. Matching one acknowledges
5 + * it and every earlier write; anything else came from elsewhere and replaces the draft.
6 + */
7 +export function reconcileSnoozeDraft<T>(
8 + pending: ReadonlyArray<T>,
9 + saved: T,
10 +): { readonly adopt: true } | { readonly adopt: false; readonly pending: ReadonlyArray<T> } {
11 + const acknowledged = pending.findIndex((snapshot) => Equal.equals(snapshot, saved));
12 + return acknowledged === -1
13 + ? { adopt: true }
14 + : { adopt: false, pending: pending.slice(acknowledged + 1) };
15 +}
apps/web/src/components/settings/SnoozePresetsSettings.tsx new
+428
@@ -0,0 +1,428 @@
1 +import { useState } from "react";
2 +import {
3 + DEFAULT_SNOOZE_PRESETS,
4 + MAX_SNOOZE_PRESET_MINUTES,
5 + MAX_SNOOZE_PRESETS,
6 + SnoozePresetDay,
7 + type SnoozePresetSetting,
8 +} from "@t3tools/contracts/settings";
9 +import {
10 + resolveSnoozePreset,
11 + resolveSnoozePresets,
12 + snoozePresetId,
13 +} from "@t3tools/client-runtime/state/thread-settled";
14 +import * as Equal from "effect/Equal";
15 +import * as Schema from "effect/Schema";
16 +import { PlusIcon, XIcon } from "lucide-react";
17 +
18 +import { useNowMinute } from "../../hooks/useNowMinute";
19 +import { reconcileSnoozeDraft } from "./SnoozePresetsSettings.logic";
20 +import { formatShortTimestamp } from "../../timestampFormat";
21 +import { Button } from "../ui/button";
22 +import { Input } from "../ui/input";
23 +import {
24 + NumberField,
25 + NumberFieldDecrement,
26 + NumberFieldGroup,
27 + NumberFieldIncrement,
28 + NumberFieldInput,
29 +} from "../ui/number-field";
30 +import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select";
31 +import { SettingResetButton, SettingsRow } from "./settingsLayout";
32 +import { searchableSetting } from "./settingsSearch";
33 +import {
34 + useScopedSettings,
35 + useScopedSettingsMixed,
36 + useUpdateScopedSettings,
37 +} from "./useScopedSettings";
38 +
39 +const UNIT_MINUTES = { minutes: 1, hours: 60, days: 24 * 60 } as const;
40 +type DurationUnit = keyof typeof UNIT_MINUTES;
41 +const UNIT_LABELS: Record<DurationUnit, string> = {
42 + minutes: "minutes",
43 + hours: "hours",
44 + days: "days",
45 +};
46 +const SINGULAR_UNIT_LABELS: Record<DurationUnit, string> = {
47 + minutes: "minute",
48 + hours: "hour",
49 + days: "day",
50 +};
51 +
52 +const WHEN_LABELS: Record<"after" | SnoozePresetDay, string> = {
53 + after: "In",
54 + today: "Today",
55 + tomorrow: "Tomorrow",
56 + monday: "Monday",
57 + tuesday: "Tuesday",
58 + wednesday: "Wednesday",
59 + thursday: "Thursday",
60 + friday: "Friday",
61 + saturday: "Saturday",
62 + sunday: "Sunday",
63 +};
64 +const WHEN_VALUES = ["after", ...SnoozePresetDay.literals] as const;
65 +
66 +// Offered in order when adding, skipping any already in the list.
67 +const ADD_CANDIDATES: ReadonlyArray<SnoozePresetSetting> = [
68 + ...DEFAULT_SNOOZE_PRESETS,
69 + { kind: "after", minutes: 30 },
70 + { kind: "at", day: "saturday", time: "09:00" },
71 + { kind: "after", minutes: 24 * 60 },
72 +];
73 +
74 +function splitMinutes(minutes: number): { amount: number; unit: DurationUnit } {
75 + if (minutes % UNIT_MINUTES.days === 0)
76 + return { amount: minutes / UNIT_MINUTES.days, unit: "days" };
77 + if (minutes % UNIT_MINUTES.hours === 0) {
78 + return { amount: minutes / UNIT_MINUTES.hours, unit: "hours" };
79 + }
80 + return { amount: minutes, unit: "minutes" };
81 +}
82 +
83 +function nextCandidate(presets: ReadonlyArray<SnoozePresetSetting>): SnoozePresetSetting {
84 + const used = new Set(presets.map(snoozePresetId));
85 + return (
86 + ADD_CANDIDATES.find((candidate) => !used.has(snoozePresetId(candidate))) ?? {
87 + kind: "after",
88 + minutes: 60,
89 + }
90 + );
91 +}
92 +
93 +const isSnoozePresetDay = Schema.is(SnoozePresetDay);
94 +
95 +interface KindMemory {
96 + readonly minutes: number;
97 + readonly time: string;
98 +}
99 +
100 +function withWhen(
101 + preset: SnoozePresetSetting,
102 + when: string,
103 + memory: KindMemory,
104 +): SnoozePresetSetting | null {
105 + if (when === "after") {
106 + return preset.kind === "after" ? preset : { kind: "after", minutes: memory.minutes };
107 + }
108 + if (!isSnoozePresetDay(when)) return null;
109 + return { kind: "at", day: when, time: preset.kind === "at" ? preset.time : memory.time };
110 +}
111 +
112 +/** Edits the snooze menu's options. Menus sort them by wake time, so rows keep the order they were added in. */
113 +export function SnoozePresetsRow() {
114 + const settings = useScopedSettings();
115 + const updateSettings = useUpdateScopedSettings();
116 + const saved = settings.snoozePresets;
117 + // Edits build on a local draft, so a second edit before the first save echoes back
118 + // does not restore what the first one changed. Echoes of our own writes keep the draft.
119 + const [presets, setPresets] = useState(saved);
120 + // Row keys survive removals, so a row's in-progress field state stays with that row.
121 + const [keys, setKeys] = useState<ReadonlyArray<number>>(() => saved.map((_, index) => index));
122 + const [nextKey, setNextKey] = useState(saved.length);
123 + // Null forces the next render to adopt the saved value, as after a failed write.
124 + const [savedSource, setSavedSource] = useState<ReadonlyArray<SnoozePresetSetting> | null>(saved);
125 + // Environments disagree, so equal-looking edits and Reset must still write to all of them.
126 + const mixed = useScopedSettingsMixed(["snoozePresets"]);
127 + const [written, setWritten] = useState<ReadonlyArray<ReadonlyArray<SnoozePresetSetting>>>([]);
128 + const freshKeys = (count: number) => {
129 + setNextKey(nextKey + count);
130 + return Array.from({ length: count }, (_, index) => nextKey + index);
131 + };
132 + if (!Equal.equals(savedSource, saved)) {
133 + setSavedSource(saved);
134 + const reconciled = reconcileSnoozeDraft(written, saved);
135 + if (reconciled.adopt) {
136 + setWritten([]);
137 + setPresets(saved);
138 + setKeys(freshKeys(saved.length));
139 + } else {
140 + setWritten(reconciled.pending);
141 + }
142 + }
143 + const save = (
144 + snoozePresets: ReadonlyArray<SnoozePresetSetting>,
145 + nextKeys: ReadonlyArray<number> = keys,
146 + ) => {
147 + if (!mixed && Equal.equals(snoozePresets, presets)) return;
148 + setPresets(snoozePresets);
149 + setKeys(nextKeys);
150 + setWritten((previous) => [...previous, snoozePresets]);
151 + updateSettings(
152 + { snoozePresets },
153 + {
154 + onFailed: () => {
155 + setWritten([]);
156 + setSavedSource(null);
157 + },
158 + },
159 + );
160 + };
161 + const replaceAt = (index: number, next: SnoozePresetSetting) =>
162 + save(presets.map((preset, candidate) => (candidate === index ? next : preset)));
163 +
164 + return (
165 + <SettingsRow
166 + serverScoped
167 + settingKeys={["snoozePresets"]}
168 + {...searchableSetting("snooze-options")}
169 + description="Choices in every snooze menu, listed soonest first. Weekdays mean the next one after today."
170 + resetAction={
171 + !mixed && Equal.equals(presets, DEFAULT_SNOOZE_PRESETS) ? null : (
172 + <SettingResetButton
173 + label="snooze options"
174 + onClick={() => save(DEFAULT_SNOOZE_PRESETS, freshKeys(DEFAULT_SNOOZE_PRESETS.length))}
175 + />
176 + )
177 + }
178 + >
179 + <SnoozePresetList
180 + presets={presets}
181 + keys={keys}
182 + timestampFormat={settings.timestampFormat}
183 + onChange={replaceAt}
184 + onRemove={(index) =>
185 + save(
186 + presets.filter((_, candidate) => candidate !== index),
187 + keys.filter((_, candidate) => candidate !== index),
188 + )
189 + }
190 + onAdd={() => save([...presets, nextCandidate(presets)], [...keys, ...freshKeys(1)])}
191 + />
192 + </SettingsRow>
193 + );
194 +}
195 +
196 +function SnoozePresetList(props: {
197 + presets: ReadonlyArray<SnoozePresetSetting>;
198 + keys: ReadonlyArray<number>;
199 + timestampFormat: Parameters<typeof formatShortTimestamp>[1];
200 + onChange: (index: number, preset: SnoozePresetSetting) => void;
201 + onRemove: (index: number) => void;
202 + onAdd: () => void;
203 +}) {
204 + const nowMinute = useNowMinute();
205 + const now = new Date(`${nowMinute}Z`);
206 + const formatTime = (date: Date) =>
207 + formatShortTimestamp(date.toISOString(), props.timestampFormat);
208 + const seenIds = new Set<string>();
209 + const seenWakes = new Set<string>();
210 + const previews = props.presets.map((preset) => {
211 + const resolved = resolveSnoozePreset(preset, now, formatTime);
212 + if (resolved === null) return { tone: "muted", text: "Passed for today" } as const;
213 + if (seenIds.has(resolved.id)) {
214 + return { tone: "muted", text: "Duplicate of an option above" } as const;
215 + }
216 + if (seenWakes.has(resolved.snoozedUntil)) {
217 + return { tone: "muted", text: "Same time as an option above" } as const;
218 + }
219 + seenIds.add(resolved.id);
220 + seenWakes.add(resolved.snoozedUntil);
221 + return { tone: "menu", label: resolved.label, when: resolved.whenLabel } as const;
222 + });
223 +
224 + const menuPresets = resolveSnoozePresets(now, { presets: props.presets, formatTime });
225 + const repeatedLabels = new Set(
226 + menuPresets
227 + .map((preset) => preset.label)
228 + .filter((label, index, labels) => labels.indexOf(label) !== index),
229 + );
230 + const menuOrder = menuPresets.map((preset) =>
231 + repeatedLabels.has(preset.label) ? `${preset.label} ${preset.whenLabel}` : preset.label,
232 + );
233 +
234 + return (
235 + <div className="flex flex-col gap-1.5 pt-3 pb-2">
236 + {props.presets.map((preset, index) => {
237 + const preview = previews[index]!;
238 + return (
239 + <div
240 + key={props.keys[index]}
241 + role="group"
242 + aria-label={`Snooze option ${index + 1}`}
243 + className="flex flex-wrap items-center gap-2"
244 + >
245 + <SnoozePresetFields preset={preset} onChange={(next) => props.onChange(index, next)} />
246 + <div className="ml-auto flex min-w-0 items-center gap-2 text-xs text-muted-foreground">
247 + {preview.tone === "menu" ? (
248 + <span className="truncate">
249 + <span className="text-foreground">{preview.label}</span>
250 + <span className="ps-2 tabular-nums">{preview.when}</span>
251 + </span>
252 + ) : (
253 + <span className="truncate">{preview.text}</span>
254 + )}
255 + <Button
256 + variant="ghost-muted"
257 + size="icon-sm"
258 + aria-label={`Remove snooze option ${index + 1}`}
259 + onClick={() => props.onRemove(index)}
260 + >
261 + <XIcon />
262 + </Button>
263 + </div>
264 + </div>
265 + );
266 + })}
267 + <p className="text-xs text-muted-foreground">
268 + {menuOrder.length === 0 ? "Menus offer only Custom…" : `Menu now: ${menuOrder.join(" · ")}`}
269 + </p>
270 + <div>
271 + <Button
272 + variant="ghost-muted"
273 + size="compact"
274 + disabled={props.presets.length >= MAX_SNOOZE_PRESETS}
275 + onClick={props.onAdd}
276 + >
277 + <PlusIcon />
278 + Add option
279 + </Button>
280 + {props.presets.length >= MAX_SNOOZE_PRESETS ? (
281 + <span className="ps-2 text-xs text-muted-foreground">
282 + Up to {MAX_SNOOZE_PRESETS} options
283 + </span>
284 + ) : null}
285 + </div>
286 + </div>
287 + );
288 +}
289 +
290 +function SnoozePresetFields(props: {
291 + preset: SnoozePresetSetting;
292 + onChange: (preset: SnoozePresetSetting) => void;
293 +}) {
294 + const { preset, onChange } = props;
295 + const when = preset.kind === "after" ? "after" : preset.day;
296 + // Switching between a duration and a set time keeps the other kind's last value, so a
297 + // misclick on "When" can be undone without retyping it.
298 + const [memory, setMemory] = useState<KindMemory>({ minutes: 60, time: "09:00" });
299 + return (
300 + <div className="flex items-center gap-2">
301 + <Select
302 + value={when}
303 + items={WHEN_LABELS}
304 + onValueChange={(value) => {
305 + const next = value === null ? null : withWhen(preset, value, memory);
306 + if (!next) return;
307 + if (next.kind !== preset.kind) {
308 + setMemory(
309 + preset.kind === "after"
310 + ? { ...memory, minutes: preset.minutes }
311 + : { ...memory, time: preset.time },
312 + );
313 + }
314 + onChange(next);
315 + }}
316 + >
317 + <SelectTrigger size="sm" className="w-32" aria-label="When">
318 + <SelectValue />
319 + </SelectTrigger>
320 + <SelectPopup>
321 + {WHEN_VALUES.map((value) => (
322 + <SelectItem hideIndicator key={value} value={value}>
323 + {WHEN_LABELS[value]}
324 + </SelectItem>
325 + ))}
326 + </SelectPopup>
327 + </Select>
328 + {preset.kind === "after" ? (
329 + <DurationFields
330 + minutes={preset.minutes}
331 + onChange={(minutes) => onChange({ ...preset, minutes })}
332 + />
333 + ) : (
334 + <>
335 + <span className="text-xs text-muted-foreground">at</span>
336 + <Input
337 + nativeInput
338 + size="sm"
339 + type="time"
340 + className="w-32"
341 + aria-label="Time"
342 + value={preset.time}
343 + onChange={(event) => {
344 + if (/^\d{2}:\d{2}$/.test(event.target.value)) {
345 + onChange({ ...preset, time: event.target.value });
346 + }
347 + }}
348 + />
349 + </>
350 + )}
351 + </div>
352 + );
353 +}
354 +
355 +function DurationFields(props: { minutes: number; onChange: (minutes: number) => void }) {
356 + // The chosen unit stays put while stepping, so 59 → 60 minutes does not jump to hours.
357 + const [chosenUnit, setChosenUnit] = useState(() => splitMinutes(props.minutes).unit);
358 + const unit =
359 + props.minutes % UNIT_MINUTES[chosenUnit] === 0 ? chosenUnit : splitMinutes(props.minutes).unit;
360 + const amount = props.minutes / UNIT_MINUTES[unit];
361 + const maxAmount = Math.floor(MAX_SNOOZE_PRESET_MINUTES / UNIT_MINUTES[unit]);
362 + // Typing stays local until the field commits (blur, Enter, or a step), so half-typed
363 + // values never reach the server.
364 + const [draft, setDraft] = useState<number | null>(amount);
365 + const [draftSource, setDraftSource] = useState(`${props.minutes}:${unit}`);
366 + if (draftSource !== `${props.minutes}:${unit}`) {
367 + setDraftSource(`${props.minutes}:${unit}`);
368 + setDraft(amount);
369 + }
370 + return (
371 + <>
372 + <NumberField
373 + size="sm"
374 + className="w-24"
375 + min={1}
376 + max={maxAmount}
377 + step={1}
378 + value={draft}
379 + onValueChange={setDraft}
380 + onValueCommitted={(value) => {
381 + if (value === null) {
382 + setDraft(amount);
383 + return;
384 + }
385 + const next = Math.min(maxAmount, Math.max(1, Math.round(value)));
386 + setDraft(next);
387 + if (next !== amount) props.onChange(next * UNIT_MINUTES[unit]);
388 + }}
389 + >
390 + <NumberFieldGroup>
391 + <NumberFieldDecrement aria-label="Decrease" />
392 + <NumberFieldInput
393 + aria-label="Amount"
394 + // Base UI commits on blur but not on Enter; refocus so keyboard users stay put.
395 + onKeyDown={(event) => {
396 + if (event.key !== "Enter") return;
397 + const input = event.currentTarget;
398 + input.blur();
399 + input.focus();
400 + }}
401 + />
402 + <NumberFieldIncrement aria-label="Increase" />
403 + </NumberFieldGroup>
404 + </NumberField>
405 + <Select
406 + value={unit}
407 + items={amount === 1 ? SINGULAR_UNIT_LABELS : UNIT_LABELS}
408 + onValueChange={(value) => {
409 + if (value === "minutes" || value === "hours" || value === "days") {
410 + setChosenUnit(value);
411 + props.onChange(Math.min(amount * UNIT_MINUTES[value], MAX_SNOOZE_PRESET_MINUTES));
412 + }
413 + }}
414 + >
415 + <SelectTrigger size="sm" className="w-28" aria-label="Unit">
416 + <SelectValue />
417 + </SelectTrigger>
418 + <SelectPopup>
419 + {(Object.keys(UNIT_LABELS) as DurationUnit[]).map((value) => (
420 + <SelectItem hideIndicator key={value} value={value}>
421 + {(amount === 1 ? SINGULAR_UNIT_LABELS : UNIT_LABELS)[value]}
422 + </SelectItem>
423 + ))}
424 + </SelectPopup>
425 + </Select>
426 + </>
427 + );
428 +}
apps/web/src/components/settings/settingsSearch.ts
+8
@@ -393,6 +393,14 @@ export const SETTINGS_SEARCH_ITEMS = [
393 to: "/settings/general",
394 searchTerms: ["sort projects sidebar manual created recent"],
395 },
396 + {
397 + id: "snooze-options",
398 + title: "Snooze options",
399 + to: "/settings/threads",
400 + searchTerms: ["snooze presets times later tonight tomorrow next week remind"],
401 + environmentOnly: true,
402 + scope: "environment-defaults",
403 + },
404 {
405 id: "snooze-limited-threads",
406 title: "Snooze until limits reset",
apps/web/src/components/settings/useScopedSettings.ts
+6 -2
@@ -49,13 +49,14 @@ export function useScopedSettingSource(keys: readonly (keyof ServerSettings)[])
49
50 function useRunScopedPlan() {
51 const persistServer = useAtomCommand(serverEnvironment.updateSettings, { reportFailure: false });
52 - return (plan: ReturnType<typeof planScopedSettingsPatch>) => {
52 + return (plan: ReturnType<typeof planScopedSettingsPatch>, onFailed?: () => void) => {
53 if (plan.unavailableReason) {
54 toastManager.add({
55 type: "warning",
56 title: "Setting not saved",
57 description: plan.unavailableReason,
58 });
59 + onFailed?.();
60 return;
61 }
62 void persistScopedSettingsPatch(
@@ -78,6 +79,7 @@ function useRunScopedPlan() {
79 persistClientSettingsPatch,
80 ).then(({ failedEnvironments, savedEnvironments, savedEnvironmentCount }) => {
81 if (failedEnvironments.length === 0) return;
82 + onFailed?.();
83 toastManager.add({
84 type: "error",
85 title:
@@ -98,7 +100,9 @@ function useRunScopedPlan() {
100 export function useUpdateScopedSettings() {
101 const { scope, environments } = useSettingsScope();
102 const run = useRunScopedPlan();
101 - return (patch: ScopedSettingsPatch) => run(planScopedSettingsPatch(scope, environments, patch));
103 + /** `onFailed` runs when any target rejects or drops the patch, so a draft can fall back. */
104 + return (patch: ScopedSettingsPatch, options?: { readonly onFailed?: () => void }) =>
105 + run(planScopedSettingsPatch(scope, environments, patch), options?.onFailed);
106 }
107
108 export function useClearScopedSettings() {
apps/web/src/components/sidebar/SidebarThreadRow.tsx
+12 -6
@@ -22,6 +22,7 @@ import {
22 import { scopeThreadRef, scopedThreadKey } from "@t3tools/client-runtime/environment";
23 import {
24 AuthOrchestrationOperateScope,
25 + type EnvironmentId,
26 type EnvironmentMachineKind,
27 type ScopedThreadRef,
28 } from "@t3tools/contracts";
@@ -98,7 +99,7 @@ import {
99 useLinkedThreadPullRequest,
100 ThreadSearchPullRequestNumber,
101 } from "../ThreadStatusIndicators";
101 -import { resolveSnoozePresets, type SnoozePreset } from "../Sidebar.snooze";
102 +import { pickSnoozePreset, resolveSnoozePresets, type SnoozePreset } from "../Sidebar.snooze";
103 import { useThreadShell } from "../../state/entities";
104 import { ProjectFavicon, type ProjectFaviconProject } from "../ProjectFavicon";
105 import { ThreadSearchMatchExcerpt } from "../ThreadSearchMatch";
@@ -369,10 +370,13 @@ function SnoozeMenuButton(props: {
370 onOpenChange: (open: boolean) => void;
371 onSnooze: (preset: Pick<SnoozePreset, "snoozedUntil">) => void;
372 timestampFormat: TimestampFormat;
373 + environmentId: EnvironmentId;
374 }) {
373 - const { open, onOpenChange, onSnooze, timestampFormat } = props;
374 - // oxlint-disable-next-line react/purity -- Presets are resolved only while the menu is open, so each opening reads a fresh time.
375 - const presets = open ? resolveSnoozePresets(new Date(), timestampFormat) : [];
375 + const { open, onOpenChange, onSnooze, timestampFormat, environmentId } = props;
376 + const presets = open
377 + ? // oxlint-disable-next-line react/purity -- Presets are resolved only while the menu is open, so each opening reads a fresh time.
378 + resolveSnoozePresets(new Date(), timestampFormat, environmentId)
379 + : [];
380 return (
381 <Menu open={open} onOpenChange={onOpenChange}>
382 <Tooltip>
@@ -401,14 +405,15 @@ function SnoozeMenuButton(props: {
405 key={preset.id}
406 onClick={(event) => {
407 event.stopPropagation();
404 - onSnooze(preset);
408 + const picked = pickSnoozePreset(presets, preset.id, timestampFormat, environmentId);
409 + if (picked) onSnooze(picked);
410 }}
411 >
412 {preset.label}
413 <MenuShortcut>{preset.whenLabel}</MenuShortcut>
414 </MenuItem>
415 ))}
411 - <MenuSeparator />
416 + {presets.length > 0 ? <MenuSeparator /> : null}
417 <MenuItem
418 onClick={async (event) => {
419 event.stopPropagation();
@@ -1438,6 +1443,7 @@ const SidebarThreadRow = memo(function SidebarThreadRow(props: SidebarThreadRowP
1443 onOpenChange={setSnoozeMenuOpen}
1444 onSnooze={handleSnoozePreset}
1445 timestampFormat={props.timestampFormat}
1446 + environmentId={thread.environmentId}
1447 />
1448 ) : null}
1449 {props.settlementSupported ? (
apps/web/src/components/threadActionMenu.logic.ts
+5 -1
@@ -148,7 +148,11 @@ export function buildThreadActionMenuItems(
148 id: `snooze:${preset.id}` as const,
149 label: `${preset.label} (${preset.whenLabel})`,
150 })),
151 - { id: "snooze:custom" as const, label: "Custom…", separatorBefore: true },
151 + {
152 + id: "snooze:custom" as const,
153 + label: "Custom…",
154 + separatorBefore: state.snoozePresets.length > 0,
155 + },
156 ],
157 },
158 ]
apps/web/src/hooks/useThreadActionMenu.ts
+8 -3
@@ -15,7 +15,7 @@ import {
15 } from "@t3tools/contracts";
16 import { useRouter } from "@tanstack/react-router";
17
18 -import { resolveSnoozePresets } from "../components/Sidebar.snooze";
18 +import { pickSnoozePreset, resolveSnoozePresets } from "../components/Sidebar.snooze";
19 import {
20 buildThreadActionMenuItems,
21 threadActionRequiresOperate,
@@ -131,7 +131,7 @@ export function useThreadActionMenu(input: {
131 titleRegeneration: readEnvironmentSupportsTitleRegeneration(threadRef.environmentId),
132 };
133 const isRegeneratingTitle = thread.titleRegeneration != null;
134 - const snoozePresets = resolveSnoozePresets(now, timestampFormat);
134 + const snoozePresets = resolveSnoozePresets(now, timestampFormat, threadRef.environmentId);
135 const items = buildThreadActionMenuItems({
136 canOperate: readEnvironmentScope(threadRef.environmentId, AuthOrchestrationOperateScope),
137 branch: thread.branch ?? null,
@@ -164,7 +164,12 @@ export function useThreadActionMenu(input: {
164 const preset =
165 action === "snooze:custom"
166 ? await requestCustomSnooze()
167 - : snoozePresets.find((candidate) => `snooze:${candidate.id}` === action);
167 + : pickSnoozePreset(
168 + snoozePresets,
169 + action.slice("snooze:".length),
170 + timestampFormat,
171 + threadRef.environmentId,
172 + );
173 if (!preset) return;
174 const result = await snoozeThread(threadRef, preset.snoozedUntil);
175 if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
docs/user/thread-sidebar.md
+6
@@ -263,6 +263,12 @@ access to the environment and is not available on Windows.
263
264 ## Snooze until later
265
266 +To change the choices in the snooze menu, open **Settings → Threads → Snooze options**.
267 +Each option is a duration, such as 3 hours, or a time on a day, such as 9:00 PM
268 +tomorrow. A weekday means the next one after today. Menus list the options soonest
269 +first and hide a today option after its time passes. Saved with **All environments**
270 +selected, the options apply to every connected environment, and the mobile app uses them too.
271 +
272 Choose **Snooze → Custom…** from a thread's menu to pick a date and time in your
273 local time zone, or a duration in minutes, hours, or days. Durations start when
274 you confirm; one day means 24 hours. On web and desktop, you can also snooze
packages/client-runtime/src/state/sharedSettings.ts
+1
@@ -14,6 +14,7 @@ const SHARED_SERVER_SETTING_KEYS = [
14 "sidebarAutoSettleOnMerge",
15 "autoResumeLimitedThreads",
16 "snoozeLimitedThreads",
17 + "snoozePresets",
18 "newWorktreesStartFromOrigin",
19 "sourceControlWritingStyle",
20 "textGenerationModelSelection",
packages/client-runtime/src/state/threadSettled.ts
+125 -54
@@ -1,5 +1,6 @@
1 // @effect-diagnostics globalDate:off -- UI snooze presets use local calendar boundaries and Intl labels.
2 import * as DateTime from "effect/DateTime";
3 +import { DEFAULT_SNOOZE_PRESETS, type SnoozePresetSetting } from "@t3tools/contracts/settings";
4
5 import type { EnvironmentThreadShell, PendingSubagentRequest } from "./models.ts";
6
@@ -171,26 +172,31 @@ export function threadWokeAt(
172 }
173
174 const HOUR_MS = 60 * 60 * 1_000;
174 -const EVENING_HOUR = 18;
175 -const MORNING_HOUR = 9;
175
177 -export type SnoozePresetId = "hour" | "three-hours" | "evening" | "tomorrow" | "next-week";
176 +const WEEKDAY_INDEX = {
177 + sunday: 0,
178 + monday: 1,
179 + tuesday: 2,
180 + wednesday: 3,
181 + thursday: 4,
182 + friday: 5,
183 + saturday: 6,
184 +} as const;
185
186 export interface SnoozePreset {
180 - readonly id: SnoozePresetId;
187 + readonly id: string;
188 readonly label: string;
189 readonly whenLabel: string;
190 readonly snoozedUntil: string;
191 }
192
186 -function snoozeTimeOfDayLabel(date: Date): string {
187 - return date.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });
193 +export interface SnoozePresetOptions {
194 + readonly presets?: ReadonlyArray<SnoozePresetSetting>;
195 + readonly formatTime?: (date: Date) => string;
196 }
197
190 -function snoozeAtHour(base: Date, hour: number): Date {
191 - const next = DateTime.toDate(DateTime.makeUnsafe(base));
192 - next.setHours(hour, 0, 0, 0);
193 - return next;
198 +function snoozeTimeOfDayLabel(date: Date): string {
199 + return date.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });
200 }
201
202 // Calendar-day advance instead of adding DAY_MS: fixed millisecond offsets
@@ -202,54 +208,119 @@ function addSnoozeDays(base: Date, days: number): Date {
208 return next;
209 }
210
205 -export function resolveSnoozePresets(now: Date): ReadonlyArray<SnoozePreset> {
206 - const inAnHour = DateTime.toDate(DateTime.makeUnsafe(now.getTime() + HOUR_MS));
207 - const inThreeHours = DateTime.toDate(DateTime.makeUnsafe(now.getTime() + 3 * HOUR_MS));
208 - const presets: SnoozePreset[] = [
209 - {
210 - id: "hour",
211 - label: "In 1 hour",
212 - whenLabel: snoozeTimeOfDayLabel(inAnHour),
213 - snoozedUntil: inAnHour.toISOString(),
214 - },
215 - {
216 - id: "three-hours",
217 - label: "In 3 hours",
218 - whenLabel: snoozeTimeOfDayLabel(inThreeHours),
219 - snoozedUntil: inThreeHours.toISOString(),
220 - },
221 - ];
222 -
223 - const evening = snoozeAtHour(now, EVENING_HOUR);
224 - if (evening.getTime() - now.getTime() > HOUR_MS) {
225 - presets.push({
226 - id: "evening",
227 - label: "This evening",
228 - whenLabel: snoozeTimeOfDayLabel(evening),
229 - snoozedUntil: evening.toISOString(),
230 - });
211 +function pluralize(count: number, unit: string): string {
212 + return `${count} ${unit}${count === 1 ? "" : "s"}`;
213 +}
214 +
215 +/** "3 hours", "90 minutes", "2 days": the largest unit that divides evenly. */
216 +function formatSnoozeDuration(minutes: number): string {
217 + if (minutes % (24 * 60) === 0) return pluralize(minutes / (24 * 60), "day");
218 + if (minutes % 60 === 0) return pluralize(minutes / 60, "hour");
219 + return pluralize(minutes, "minute");
220 +}
221 +
222 +function capitalize(word: string): string {
223 + return word[0]!.toUpperCase() + word.slice(1);
224 +}
225 +
226 +function snoozePresetDaysAhead(
227 + setting: Extract<SnoozePresetSetting, { kind: "at" }>,
228 + now: Date,
229 +): number {
230 + if (setting.day === "today") return 0;
231 + if (setting.day === "tomorrow") return 1;
232 + return (WEEKDAY_INDEX[setting.day] - now.getDay() + 7) % 7 || 7;
233 +}
234 +
235 +/** Labels follow the actual day gap, so a Monday option on a Sunday reads "Tomorrow". */
236 +function snoozePresetLabel(setting: SnoozePresetSetting, daysAhead: number): string {
237 + if (setting.kind === "after") return `In ${formatSnoozeDuration(setting.minutes)}`;
238 + if (daysAhead === 0) {
239 + const hour = Number(setting.time.slice(0, 2));
240 + return hour < 12 ? "This morning" : hour < 17 ? "This afternoon" : "This evening";
241 }
242 + if (daysAhead === 1) return "Tomorrow";
243 + if (setting.day === "monday") return "Next week";
244 + return daysAhead === 7 ? `Next ${capitalize(setting.day)}` : capitalize(setting.day);
245 +}
246 +
247 +export function snoozePresetId(setting: SnoozePresetSetting): string {
248 + return setting.kind === "after"
249 + ? `after:${setting.minutes}`
250 + : `at:${setting.day}:${setting.time}`;
251 +}
252
233 - const tomorrow = snoozeAtHour(addSnoozeDays(now, 1), MORNING_HOUR);
234 - presets.push({
235 - id: "tomorrow",
236 - label: "Tomorrow",
237 - whenLabel: snoozeTimeOfDayLabel(tomorrow),
238 - snoozedUntil: tomorrow.toISOString(),
239 - });
240 -
241 - const daysUntilMonday = (1 - now.getDay() + 7) % 7 || 7;
242 - const nextWeek = snoozeAtHour(addSnoozeDays(now, daysUntilMonday), MORNING_HOUR);
243 - if (nextWeek.getTime() !== tomorrow.getTime()) {
244 - presets.push({
245 - id: "next-week",
246 - label: "Next week",
247 - whenLabel: `${nextWeek.toLocaleDateString(undefined, { weekday: "short" })} ${snoozeTimeOfDayLabel(nextWeek)}`,
248 - snoozedUntil: nextWeek.toISOString(),
249 - });
253 +export function resolveSnoozePreset(
254 + setting: SnoozePresetSetting,
255 + now: Date,
256 + formatTime: (date: Date) => string = snoozeTimeOfDayLabel,
257 +): SnoozePreset | null {
258 + let wake: Date;
259 + let daysAhead = 0;
260 + if (setting.kind === "after") {
261 + wake = DateTime.toDate(DateTime.makeUnsafe(now.getTime() + setting.minutes * 60_000));
262 + } else {
263 + daysAhead = snoozePresetDaysAhead(setting, now);
264 + wake = addSnoozeDays(now, daysAhead);
265 + wake.setHours(Number(setting.time.slice(0, 2)), Number(setting.time.slice(3)), 0, 0);
266 + // A today option whose time has passed is left out until tomorrow.
267 + if (wake.getTime() <= now.getTime()) return null;
268 }
269 + const label = snoozePresetLabel(setting, daysAhead);
270 + // Durations and "Next week" don't name the wake day, so a wake on another day shows it.
271 + const labelNamesDay = setting.kind === "at" && label !== "Next week";
272 + const time = formatTime(wake);
273 + return {
274 + id: snoozePresetId(setting),
275 + label,
276 + whenLabel:
277 + labelNamesDay || wake.toDateString() === now.toDateString()
278 + ? time
279 + : `${wake.toLocaleDateString(undefined, { weekday: "short" })} ${time}`,
280 + snoozedUntil: wake.toISOString(),
281 + };
282 +}
283
252 - return presets;
284 +/** The snooze menu: soonest first, one row per wake minute. */
285 +export function resolveSnoozePresets(
286 + now: Date,
287 + options: SnoozePresetOptions = {},
288 +): ReadonlyArray<SnoozePreset> {
289 + // By minute, so a duration (which keeps the clock's seconds) and a set time in the same
290 + // minute tie, and the stable sort keeps whichever comes first in settings.
291 + const wakeMinute = (preset: SnoozePreset) => Math.floor(Date.parse(preset.snoozedUntil) / 60_000);
292 + const seen = new Set<number>();
293 + return (
294 + (options.presets ?? DEFAULT_SNOOZE_PRESETS)
295 + .flatMap((setting) => resolveSnoozePreset(setting, now, options.formatTime) ?? [])
296 + // flatMap returned a new array; Hermes has no `toSorted`.
297 + .sort((a, b) => wakeMinute(a) - wakeMinute(b))
298 + .filter((preset) => {
299 + if (seen.has(wakeMinute(preset))) return false;
300 + seen.add(wakeMinute(preset));
301 + return true;
302 + })
303 + );
304 +}
305 +
306 +/**
307 + * A menu choice as picked. A duration re-resolves from its setting (not the deduped menu) so it
308 + * starts at selection. A set time keeps the shown wake, which a day change would otherwise shift.
309 + */
310 +export function pickSnoozePreset(input: {
311 + readonly shown: ReadonlyArray<SnoozePreset>;
312 + readonly id: string;
313 + readonly now: Date;
314 + readonly presets?: ReadonlyArray<SnoozePresetSetting>;
315 + readonly formatTime?: (date: Date) => string;
316 +}): SnoozePreset | undefined {
317 + const original = input.shown.find((preset) => preset.id === input.id);
318 + const ahead =
319 + original && Date.parse(original.snoozedUntil) > input.now.getTime() ? original : undefined;
320 + const setting = (input.presets ?? DEFAULT_SNOOZE_PRESETS).find(
321 + (candidate) => candidate.kind === "after" && snoozePresetId(candidate) === input.id,
322 + );
323 + return (setting && resolveSnoozePreset(setting, input.now, input.formatTime)) ?? ahead;
324 }
325
326 export function snoozeWakeLabel(snoozedUntil: string, options: { readonly now: string }): string {
packages/client-runtime/src/state/threadSnoozed.test.ts
+98 -15
@@ -1,12 +1,14 @@
1 // @effect-diagnostics globalDate:off -- Tests exercise local calendar snooze boundaries.
2 import { ThreadId } from "@t3tools/contracts";
3 import { TurnId } from "@t3tools/contracts";
4 +import type { SnoozePresetSetting } from "@t3tools/contracts/settings";
5 import { describe, expect, it } from "vite-plus/test";
6
7 import {
8 canSnooze,
9 effectiveSnoozed,
10 hasQueuedTurnStart,
11 + pickSnoozePreset,
12 resolveSnoozePresets,
13 threadRaisedHandWhileSnoozed,
14 threadWokeAt,
@@ -273,25 +275,106 @@ describe("threadWokeAt", () => {
275 });
276
277 describe("resolveSnoozePresets", () => {
276 - it("drops the evening choice once evening is near or past", () => {
277 - expect(resolveSnoozePresets(localDate(2026, 4, 8, 17, 30)).map((preset) => preset.id)).toEqual([
278 - "hour",
279 - "three-hours",
280 - "tomorrow",
281 - "next-week",
278 + const formatTime = (date: Date) =>
279 + `${date.getHours()}:${String(date.getMinutes()).padStart(2, "0")}`;
280 + const menu = (now: Date, presets?: ReadonlyArray<SnoozePresetSetting>) =>
281 + resolveSnoozePresets(now, { formatTime, ...(presets ? { presets } : {}) }).map(
282 + (preset) => `${preset.label} ${preset.whenLabel}`,
283 + );
284 +
285 + it("lists custom presets soonest first and names the day when the label does not", () => {
286 + // Wednesday 20:00.
287 + expect(
288 + menu(localDate(2026, 4, 8, 20), [
289 + { kind: "at", day: "monday", time: "18:00" },
290 + { kind: "at", day: "tomorrow", time: "21:00" },
291 + { kind: "after", minutes: 360 },
292 + { kind: "after", minutes: 180 },
293 + ]),
294 + ).toEqual(["In 3 hours 23:00", "In 6 hours Thu 2:00", "Tomorrow 21:00", "Next week Mon 18:00"]);
295 + });
296 +
297 + it("drops a today preset once its time passes and moves a weekday on that day to next week", () => {
298 + // Monday 18:30.
299 + const now = localDate(2026, 4, 13, 18, 30);
300 + const presets = resolveSnoozePresets(now, {
301 + presets: [
302 + { kind: "at", day: "today", time: "18:00" },
303 + { kind: "at", day: "monday", time: "09:00" },
304 + ],
305 + });
306 + expect(presets.map((preset) => preset.id)).toEqual(["at:monday:09:00"]);
307 + expect(new Date(presets[0]!.snoozedUntil)).toEqual(localDate(2026, 4, 20, 9));
308 + });
309 +
310 + it("names the real day gap: a Monday option on Sunday is Tomorrow, a weekday a week out is Next", () => {
311 + const theo: ReadonlyArray<SnoozePresetSetting> = [
312 + { kind: "at", day: "tomorrow", time: "21:00" },
313 + { kind: "at", day: "monday", time: "18:00" },
314 + { kind: "at", day: "friday", time: "17:00" },
315 + ];
316 + // Sunday 14:00.
317 + expect(menu(localDate(2026, 8, 30, 14), theo)).toEqual([
318 + "Tomorrow 18:00",
319 + "Tomorrow 21:00",
320 + "Friday 17:00",
321 + ]);
322 + // Friday 10:00: today's 17:00 is a week away.
323 + expect(menu(localDate(2026, 9, 4, 10), theo)).toEqual([
324 + "Tomorrow 21:00",
325 + "Next week Mon 18:00",
326 + "Next Friday 17:00",
327 ]);
328 });
329
285 - it("drops next week on Sundays, when it lands on the same Monday as tomorrow", () => {
286 - const presets = resolveSnoozePresets(localDate(2026, 8, 30, 7, 1));
287 - expect(presets.map((preset) => preset.id)).toEqual([
288 - "hour",
289 - "three-hours",
290 - "evening",
291 - "tomorrow",
330 + it("shows one row when two presets wake at the same time", () => {
331 + // Sunday, so Tomorrow 9:00 and Next week 9:00 are the same Monday.
332 + expect(menu(localDate(2026, 8, 30, 7, 1))).toEqual([
333 + "In 1 hour 8:01",
334 + "In 3 hours 10:01",
335 + "This evening 18:00",
336 + "Tomorrow 9:00",
337 ]);
293 - const tomorrow = new Date(presets.find((preset) => preset.id === "tomorrow")!.snoozedUntil);
294 - expect(tomorrow.getDay()).toBe(1);
338 + });
339 +
340 + it("treats a duration and a set time in the same minute as one row", () => {
341 + const now = localDate(2026, 4, 8, 15);
342 + now.setSeconds(25);
343 + expect(
344 + menu(now, [
345 + { kind: "after", minutes: 180 },
346 + { kind: "at", day: "today", time: "18:00" },
347 + ]),
348 + ).toEqual(["In 3 hours 18:00"]);
349 + });
350 +});
351 +
352 +describe("pickSnoozePreset", () => {
353 + it("starts a duration when it is picked, even when the menu merged it with a set time", () => {
354 + const presets: ReadonlyArray<SnoozePresetSetting> = [
355 + { kind: "at", day: "today", time: "18:30" },
356 + { kind: "after", minutes: 180 },
357 + ];
358 + // At 15:00 the two differ; at 15:30 "In 3 hours" lands on 18:30 and the menu shows one row.
359 + const shown = resolveSnoozePresets(localDate(2026, 4, 8, 15), { presets });
360 + const picked = pickSnoozePreset({
361 + shown,
362 + id: "after:180",
363 + now: localDate(2026, 4, 8, 15, 30),
364 + presets,
365 + });
366 + expect(picked?.snoozedUntil).toBe(localDate(2026, 4, 8, 18, 30).toISOString());
367 + });
368 +
369 + it("keeps a set time's shown wake when the day changes while the menu is open", () => {
370 + // Sunday 23:59: "Tomorrow" means Monday 9:00, even if the pick lands after midnight.
371 + const shown = resolveSnoozePresets(localDate(2026, 8, 30, 23, 59));
372 + const picked = pickSnoozePreset({
373 + shown,
374 + id: "at:tomorrow:09:00",
375 + now: localDate(2026, 8, 31, 0, 1),
376 + });
377 + expect(picked?.snoozedUntil).toBe(localDate(2026, 8, 31, 9).toISOString());
378 });
379 });
380
packages/contracts/src/settings.ts
+43
@@ -92,6 +92,45 @@ export const SidebarAutoSettleAfterDays = Schema.Number.check(
92 );
93 export type SidebarAutoSettleAfterDays = typeof SidebarAutoSettleAfterDays.Type;
94 const DEFAULT_SIDEBAR_AUTO_SETTLE_AFTER_DAYS: SidebarAutoSettleAfterDays = 3;
95 +
96 +export const MAX_SNOOZE_PRESET_MINUTES = 30 * 24 * 60;
97 +export const MAX_SNOOZE_PRESETS = 8;
98 +export const SnoozePresetDay = Schema.Literals([
99 + "today",
100 + "tomorrow",
101 + "monday",
102 + "tuesday",
103 + "wednesday",
104 + "thursday",
105 + "friday",
106 + "saturday",
107 + "sunday",
108 +]);
109 +export type SnoozePresetDay = typeof SnoozePresetDay.Type;
110 +/** `after` wakes a fixed time from now. `at` wakes at a local time; a weekday is its next occurrence after today. */
111 +export const SnoozePresetSetting = Schema.Union([
112 + Schema.Struct({
113 + kind: Schema.Literal("after"),
114 + minutes: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: MAX_SNOOZE_PRESET_MINUTES })),
115 + }),
116 + Schema.Struct({
117 + kind: Schema.Literal("at"),
118 + day: SnoozePresetDay,
119 + time: Schema.String.check(Schema.isPattern(/^([01]\d|2[0-3]):[0-5]\d$/)),
120 + }),
121 +]);
122 +export type SnoozePresetSetting = typeof SnoozePresetSetting.Type;
123 +export const SnoozePresetSettings = Schema.Array(SnoozePresetSetting).check(
124 + Schema.isMaxLength(MAX_SNOOZE_PRESETS),
125 +);
126 +export const DEFAULT_SNOOZE_PRESETS: ReadonlyArray<SnoozePresetSetting> = [
127 + { kind: "after", minutes: 60 },
128 + { kind: "after", minutes: 180 },
129 + { kind: "at", day: "today", time: "18:00" },
130 + { kind: "at", day: "tomorrow", time: "09:00" },
131 + { kind: "at", day: "monday", time: "09:00" },
132 +];
133 +
134 export const MIN_GLASS_OPACITY = 40;
135 export const MAX_GLASS_OPACITY = 100;
136 export const GlassOpacity = Schema.Int.check(
@@ -1172,6 +1211,9 @@ export const ServerSettings = Schema.Struct({
1211 idleCompaction: Schema.optionalKey(IdleCompactionMode),
1212 snoozeLimitedThreads: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
1213 autoResumeLimitedThreads: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
1214 + snoozePresets: SnoozePresetSettings.pipe(
1215 + Schema.withDecodingDefault(Effect.succeed(DEFAULT_SNOOZE_PRESETS)),
1216 + ),
1217 /** Beta: guest links for this machine's threads. Off refuses new links and pauses existing ones. */
1218 guestSharingEnabled: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
1219 /**
@@ -1523,6 +1565,7 @@ export const ServerSettingsPatch = Schema.Struct({
1565 sidebarAutoSettleOnMerge: Schema.optionalKey(Schema.Boolean),
1566 autoResumeLimitedThreads: Schema.optionalKey(Schema.Boolean),
1567 snoozeLimitedThreads: Schema.optionalKey(Schema.Boolean),
1568 + snoozePresets: Schema.optionalKey(SnoozePresetSettings),
1569 guestSharingEnabled: Schema.optionalKey(Schema.Boolean),
1570 linkedEnvironmentsEnabled: Schema.optionalKey(Schema.Boolean),
1571 backgroundActivity: Schema.optionalKey(