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(