Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

feat(sidebar-v2): thread snoozing (#4311)

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