diff --git a/apps/server/src/environment/ServerEnvironment.test.ts b/apps/server/src/environment/ServerEnvironment.test.ts index 3a9bfafb82eaf..282f36c2e74de 100644 --- a/apps/server/src/environment/ServerEnvironment.test.ts +++ b/apps/server/src/environment/ServerEnvironment.test.ts @@ -119,6 +119,7 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("ServerEnvironmen projectWorktreeCleanup: true, worktreesDirectory: true, threadAutoSettlementScope: true, + threadAutoSettleSnoozedOnMerge: true, }); } }), diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts index 0f3a88f5c0d94..362e4e7d39c8f 100644 --- a/apps/server/src/environment/ServerEnvironment.ts +++ b/apps/server/src/environment/ServerEnvironment.ts @@ -244,6 +244,7 @@ export const make = Effect.gen(function* () { worktreesDirectory: true, ...(hostPlatform === "darwin" ? { fastWorktreeCheckout: true } : {}), threadAutoSettlementScope: true, + threadAutoSettleSnoozedOnMerge: true, threadRestartContinuation: true, projectSettingsOverrides: true, projectProviderInstanceOverrides: true, diff --git a/apps/server/src/orchestration-v2/ThreadSettlementService.test.ts b/apps/server/src/orchestration-v2/ThreadSettlementService.test.ts index a17dde47c20b3..d1897de8c540d 100644 --- a/apps/server/src/orchestration-v2/ThreadSettlementService.test.ts +++ b/apps/server/src/orchestration-v2/ThreadSettlementService.test.ts @@ -181,6 +181,7 @@ describe("isAutoSettlementCandidate", () => { snoozedAt: at(-60 * 60 * 1_000), }); expect(ThreadSettlementService.isAutoSettlementCandidate(snoozed, NOW_MS)).toBe(false); + expect(ThreadSettlementService.isAutoSettlementCandidate(snoozed, NOW_MS, true)).toBe(true); expect( ThreadSettlementService.isAutoSettlementCandidate( shell({ ...snoozed, status: "failed", latestRunCompletedAt: at(-30 * 60 * 1_000) }), @@ -915,6 +916,51 @@ describe("ThreadSettlementServiceV2 worker", () => { }), ); + it.effect("settles a snoozed thread with a merged link only when snoozed-on-merge is on", () => + Effect.gen(function* () { + yield* TestClock.setTime(Date.parse(NOW)); + const thread = makeThread("snoozed-merged-link", { + snoozedAt: DateTime.makeUnsafe("2026-08-27T00:00:00.000Z"), + snoozedUntil: DateTime.makeUnsafe("2026-08-29T00:00:00.000Z"), + pullRequests: [ + { + ...persistedLink(null, DateTime.makeUnsafe("2026-08-20T00:00:00.000Z")), + snapshot: { + state: "merged", + title: "Pull request", + headBranch: "feature", + baseBranch: "main", + isDraft: false, + updatedAt: NOW, + syncedAt: NOW, + mergedAt: NOW, + }, + }, + ], + }); + for (const [enabled, expected] of [ + [false, []], + [true, [thread.id]], + ] as const) { + const fixture = yield* makeHarness({ + snapshot: makeSnapshot([thread]), + settings: { + ...DEFAULT_SERVER_SETTINGS, + sidebarAutoSettleAfterDays: null, + sidebarAutoSettleSnoozedOnMerge: enabled, + }, + }); + yield* Effect.gen(function* () { + const service = yield* ThreadSettlementService.ThreadSettlementServiceV2; + yield* startHarness(service, fixture.activation, fixture.snapshotReads); + expect((yield* Ref.get(fixture.commands)).map((command) => command.threadId)).toEqual( + expected, + ); + }).pipe(Effect.provide(fixture.layer)); + } + }), + ); + it.effect("settles an idle thread with an open persisted link on the inactivity sweep", () => Effect.gen(function* () { yield* TestClock.setTime(Date.parse(NOW)); @@ -2308,5 +2354,18 @@ describe("isSnoozed", () => { autoSettleOnMerge: true, }), ).toBeNull(); + const resolveWith = (mergedAt: DateTime.Utc, autoSettleOnMerge: boolean) => + ThreadSettlementService.resolveAutoSettlementAt({ + thread, + pullRequest: { state: "merged", mergedAt: DateTime.formatIso(mergedAt) }, + nowMs: NOW_MS, + autoSettleAfterDays: null, + autoSettleOnMerge, + autoSettleSnoozedOnMerge: true, + }); + expect(resolveWith(at(-1), true)).toEqual(at(-DAY_MS)); + // A merge that landed before the snooze was already seen by the user who snoozed. + expect(resolveWith(at(-3 * DAY_MS), true)).toBeNull(); + expect(resolveWith(at(-1), false)).toBeNull(); }); }); diff --git a/apps/server/src/orchestration-v2/ThreadSettlementService.ts b/apps/server/src/orchestration-v2/ThreadSettlementService.ts index 5c49dcddbf404..46b265f20bf0c 100644 --- a/apps/server/src/orchestration-v2/ThreadSettlementService.ts +++ b/apps/server/src/orchestration-v2/ThreadSettlementService.ts @@ -138,10 +138,11 @@ export function threadHasQueuedTurnStart( function pullRequestSettles( thread: Pick< ProjectionStore.ProjectionSettlementCandidate, - "createdAt" | "latestUserAuthoredMessageAt" + "createdAt" | "latestUserAuthoredMessageAt" | "snoozedAt" >, pullRequest: SettlementPullRequest, autoSettleOnMerge: boolean, + snoozed: boolean, ): boolean { if (pullRequest.state !== "closed" && (pullRequest.state !== "merged" || !autoSettleOnMerge)) { return false; @@ -155,12 +156,17 @@ function pullRequestSettles( if (userAnchorMs === null) return false; const pullRequestAtMs = Date.parse(terminalAt); if (Number.isNaN(pullRequestAtMs)) return false; - return pullRequestAtMs >= userAnchorMs; + if (pullRequestAtMs < userAnchorMs) return false; + if (!snoozed) return true; + // A snoozed thread settles only on a merge that lands after the snooze. + const snoozedAtMs = toMillis(thread.snoozedAt); + return pullRequest.state === "merged" && (snoozedAtMs === null || pullRequestAtMs >= snoozedAtMs); } export function isAutoSettlementCandidate( thread: Omit, nowMs: number, + settleSnoozedOnMerge = false, ): boolean { if (thread.archivedAt !== null || thread.settledOverride !== null) return false; if (thread.pinnedAt != null || thread.autoSettleDisabledAt != null) return false; @@ -174,7 +180,7 @@ export function isAutoSettlementCandidate( if (pendingTasks.some(isPullRequestWatchTask)) return false; if (threadHasQueuedTurnStart(thread, nowMs)) return false; // Interrupted runs must keep the same snooze protection the sidebar shows. - return !isSnoozed(thread, nowMs); + return settleSnoozedOnMerge || !isSnoozed(thread, nowMs); } /** Match client effectiveSnoozed so agents and sidebar agree. */ @@ -217,6 +223,7 @@ export function resolveAutoSettlementAt(input: { readonly autoSettleAfterDays: number | null; readonly autoSettleOnMerge: boolean; readonly autoSettleKeepPullRequests?: boolean; + readonly autoSettleSnoozedOnMerge?: boolean; }): DateTime.Utc | null { const { thread } = input; let pullRequest = input.pullRequest; @@ -240,11 +247,17 @@ export function resolveAutoSettlementAt(input: { closedAt: latest.snapshot.closedAt ?? null, }; } - if (!isAutoSettlementCandidate(thread, input.nowMs)) return null; + const settleSnoozedOnMerge = input.autoSettleOnMerge && input.autoSettleSnoozedOnMerge === true; + if (!isAutoSettlementCandidate(thread, input.nowMs, settleSnoozedOnMerge)) return null; + const snoozed = isSnoozed(thread, input.nowMs); const activityAtMs = threadActivityAtMs(thread); - if (pullRequest !== null && pullRequestSettles(thread, pullRequest, input.autoSettleOnMerge)) { + if ( + pullRequest !== null && + pullRequestSettles(thread, pullRequest, input.autoSettleOnMerge, snoozed) + ) { return DateTime.makeUnsafe(activityAtMs); } + if (snoozed) return null; const hasPullRequest = hasOpenLink || pullRequest !== null || @@ -289,12 +302,14 @@ export function autoSettlementSettingsKey( settings.sidebarAutoSettleOnMerge, settings.sidebarAutoSettleAfterDays, settings.sidebarAutoSettleKeepPullRequests, + settings.sidebarAutoSettleSnoozedOnMerge, Object.entries(settings.projectSettingsOverrides) .filter( ([, entry]) => entry.sidebarAutoSettleOnMerge !== undefined || entry.sidebarAutoSettleAfterDays !== undefined || - entry.sidebarAutoSettleKeepPullRequests !== undefined, + entry.sidebarAutoSettleKeepPullRequests !== undefined || + entry.sidebarAutoSettleSnoozedOnMerge !== undefined, ) .sort(([left], [right]) => left.localeCompare(right)) .map(([projectId, entry]) => [ @@ -304,6 +319,7 @@ export function autoSettlementSettingsKey( ? "inherit" : entry.sidebarAutoSettleAfterDays, entry.sidebarAutoSettleKeepPullRequests ?? "inherit", + entry.sidebarAutoSettleSnoozedOnMerge ?? "inherit", ]), ]); } @@ -360,11 +376,17 @@ export const make = Effect.gen(function* () { if (nowMs - readAtMs >= QUIET_SYNC_INTERVAL_MS) quietOpenReadAt.delete(key); } // Merge events resweep all candidates because unlinked threads settle through branch lookup. - const candidates = threads.filter( - (thread) => - (automaticSettlementEnabled || thread.lineage.relationshipToParent === "subagent") && - isAutoSettlementCandidate(thread, nowMs), - ); + const candidates = threads.filter((thread) => { + const subagent = thread.lineage.relationshipToParent === "subagent"; + if (!automaticSettlementEnabled && !subagent) return false; + const { settings: projectSettings } = resolveProjectSettings(settings, thread.projectId); + // Subagents settle with their parent without a merge decision, so they keep snooze protection. + const settleSnoozedOnMerge = + !subagent && + projectSettings.sidebarAutoSettleOnMerge && + projectSettings.sidebarAutoSettleSnoozedOnMerge; + return isAutoSettlementCandidate(thread, nowMs, settleSnoozedOnMerge); + }); // Runs per candidate thread, thousands per sweep on busy servers; the sweep owns the span. const settleThread = Effect.fnUntraced( @@ -394,6 +416,7 @@ export const make = Effect.gen(function* () { autoSettleAfterDays: currentSettings.sidebarAutoSettleAfterDays, autoSettleOnMerge: currentSettings.sidebarAutoSettleOnMerge, autoSettleKeepPullRequests: currentSettings.sidebarAutoSettleKeepPullRequests, + autoSettleSnoozedOnMerge: currentSettings.sidebarAutoSettleSnoozedOnMerge, }); if (settledAt === null) return thread; const uuid = yield* random.uuidV4(); @@ -432,6 +455,7 @@ export const make = Effect.gen(function* () { autoSettleAfterDays: projectSettings.sidebarAutoSettleAfterDays, autoSettleOnMerge: projectSettings.sidebarAutoSettleOnMerge, autoSettleKeepPullRequests: projectSettings.sidebarAutoSettleKeepPullRequests, + autoSettleSnoozedOnMerge: projectSettings.sidebarAutoSettleSnoozedOnMerge, }); return settledAt === null ? Effect.succeed(thread) : settleThread(thread, null); }, @@ -511,6 +535,7 @@ export const make = Effect.gen(function* () { autoSettleAfterDays: settings.sidebarAutoSettleAfterDays, autoSettleOnMerge: settings.sidebarAutoSettleOnMerge, autoSettleKeepPullRequests: settings.sidebarAutoSettleKeepPullRequests, + autoSettleSnoozedOnMerge: settings.sidebarAutoSettleSnoozedOnMerge, }) !== null ); }); diff --git a/apps/web/src/components/settings/SettingsPanels.tsx b/apps/web/src/components/settings/SettingsPanels.tsx index 633e18a567b2f..8709308e796df 100644 --- a/apps/web/src/components/settings/SettingsPanels.tsx +++ b/apps/web/src/components/settings/SettingsPanels.tsx @@ -506,6 +506,10 @@ export function useSettingsRestore(onRestored?: () => void) { ...(settings.sidebarAutoSettleOnMerge !== DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleOnMerge ? ["Auto-settle merged threads"] : []), + ...(settings.sidebarAutoSettleSnoozedOnMerge !== + DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleSnoozedOnMerge + ? ["Auto-settle snoozed threads on merge"] + : []), ...(settings.autoResumeLimitedThreads !== DEFAULT_UNIFIED_SETTINGS.autoResumeLimitedThreads ? ["Resume after usage limits"] : []), @@ -680,6 +684,7 @@ export function useSettingsRestore(onRestored?: () => void) { sidebarAutoSettleAfterDays: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleAfterDays, sidebarAutoSettleKeepPullRequests: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleKeepPullRequests, sidebarAutoSettleOnMerge: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleOnMerge, + sidebarAutoSettleSnoozedOnMerge: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleSnoozedOnMerge, autoResumeLimitedThreads: DEFAULT_UNIFIED_SETTINGS.autoResumeLimitedThreads, snoozeLimitedThreads: DEFAULT_UNIFIED_SETTINGS.snoozeLimitedThreads, snoozePresets: DEFAULT_UNIFIED_SETTINGS.snoozePresets, @@ -1722,7 +1727,7 @@ export function ThreadsSettingsPanel() { const settings = useScopedSettings(); const updateSettings = useUpdateScopedSettings(); const navigate = useNavigate(); - const { environment, connectedEnvironments, target, scope } = useSettingsScope(); + const { environment, connectedEnvironments, target, targets, scope } = useSettingsScope(); const isProjectScope = scope.kind === "project" || scope.kind === "checkout"; const environmentId = environment?.environmentId ?? null; const hasServerTargets = connectedEnvironments.length > 0; @@ -1735,6 +1740,12 @@ export function ThreadsSettingsPanel() { const supportsAutoSettlementScope = connectedEnvironments.every( (target) => target.serverConfig?.environment.capabilities.threadAutoSettlementScope === true, ); + const supportsAutoSettleSnoozedOnMerge = connectedEnvironments.every( + (entry) => entry.serverConfig?.environment.capabilities.threadAutoSettleSnoozedOnMerge === true, + ); + const anyTargetHasAutoSettleOnMerge = targets.some( + (entry) => entry.settings.sidebarAutoSettleOnMerge === true, + ); const textGenerationTargets = useTextGenerationTargets({ environmentId, @@ -1912,6 +1923,24 @@ export function ThreadsSettingsPanel() { /> } /> + {anyTargetHasAutoSettleOnMerge && supportsAutoSettleSnoozedOnMerge ? ( + + updateSettings({ sidebarAutoSettleSnoozedOnMerge: Boolean(checked) }) + } + aria-label="Auto-settle snoozed threads on merge" + /> + } + /> + ) : null} + environment.connection.phase === "connected" && + environment.serverConfig?.environment.capabilities.threadAutoSettleSnoozedOnMerge === true, + ) === true; const hasTextGeneratorsEnvironment = environments.some( (environment) => @@ -71,6 +77,7 @@ export function useAvailableSettingsSearchItems() { managedTunnelActive, hasPeerLinkHost, hasFastWorktreeCheckoutEnvironment, + hasThreadAutoSettleSnoozedOnMergeEnvironment, hasTextGeneratorsEnvironment, hasPrimaryEnvironment: primaryEnvironmentId !== null, }); diff --git a/docs/user/thread-sidebar.md b/docs/user/thread-sidebar.md index 905f3a5bfbe9c..98615636e157f 100644 --- a/docs/user/thread-sidebar.md +++ b/docs/user/thread-sidebar.md @@ -195,6 +195,8 @@ settlement unless you turn on **Keep threads with a PR** in **Settings → Threa but an old closed or merged pull request does not settle work you resumed after it closed. Only your own messages count as resuming. A turn that finished background work or a pull request watch starts on its own does not. +Snoozed threads stay snoozed until they wake. To let a merge settle them anyway, turn on +**Auto-settle snoozed threads on merge** in **Settings → Threads**. To keep one thread out of the settled shelf no matter how long it sits idle, open its menu, choose **Auto-settle behavior**, and pick **Never**. The current option is checked. Pick diff --git a/packages/contracts/src/environment.ts b/packages/contracts/src/environment.ts index fd091152599d3..49b0902a7f046 100644 --- a/packages/contracts/src/environment.ts +++ b/packages/contracts/src/environment.ts @@ -115,6 +115,8 @@ export const ExecutionEnvironmentCapabilities = Schema.Struct({ /** Sent by macOS servers, which honor the fastWorktreeCheckout setting. */ fastWorktreeCheckout: Schema.optionalKey(Schema.Boolean), threadAutoSettlementScope: Schema.optionalKey(Schema.Boolean), + /** Hide the switch when absent; older servers keep snoozed threads through a merge. */ + threadAutoSettleSnoozedOnMerge: Schema.optionalKey(Schema.Boolean), threadRestartContinuation: Schema.optionalKey(Schema.Boolean), projectSettingsOverrides: Schema.optionalKey(Schema.Boolean), /** Hide the switch when absent; older servers silently drop per-project provider patches. */ diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.ts index 0013e288983e0..3dbd8bd0defe0 100644 --- a/packages/contracts/src/settings.ts +++ b/packages/contracts/src/settings.ts @@ -1194,6 +1194,7 @@ export const PROJECT_SCOPED_SERVER_SETTING_KEYS = [ "sidebarAutoSettleOnMerge", "sidebarAutoSettleAfterDays", "sidebarAutoSettleKeepPullRequests", + "sidebarAutoSettleSnoozedOnMerge", "continueThreadsAfterServerUpdate", "responseStreamingMode", "speechProjectCustomWords", @@ -1232,6 +1233,7 @@ export const ProjectSettingsOverrides = Schema.Struct({ sidebarAutoSettleOnMerge: Schema.optionalKey(Schema.Boolean), sidebarAutoSettleAfterDays: Schema.optionalKey(Schema.NullOr(SidebarAutoSettleAfterDays)), sidebarAutoSettleKeepPullRequests: Schema.optionalKey(Schema.Boolean), + sidebarAutoSettleSnoozedOnMerge: Schema.optionalKey(Schema.Boolean), continueThreadsAfterServerUpdate: Schema.optionalKey(Schema.Boolean), responseStreamingMode: Schema.optionalKey(ResponseStreamingMode), speechProjectCustomWords: Schema.optionalKey(SpeechCustomWords), @@ -1482,6 +1484,9 @@ export const ServerSettings = Schema.Struct({ Schema.withDecodingDefault(Effect.succeed(false)), ), sidebarAutoSettleOnMerge: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))), + sidebarAutoSettleSnoozedOnMerge: Schema.Boolean.pipe( + Schema.withDecodingDefault(Effect.succeed(false)), + ), backgroundActivity: BackgroundActivitySettings, automaticGitFetchInterval: Schema.DurationFromMillis.pipe( @@ -1900,6 +1905,7 @@ export const ServerSettingsPatch = Schema.Struct({ idleCompaction: Schema.optionalKey(IdleCompactionMode), sidebarAutoSettleKeepPullRequests: Schema.optionalKey(Schema.Boolean), sidebarAutoSettleOnMerge: Schema.optionalKey(Schema.Boolean), + sidebarAutoSettleSnoozedOnMerge: Schema.optionalKey(Schema.Boolean), autoResumeLimitedThreads: Schema.optionalKey(Schema.Boolean), snoozeLimitedThreads: Schema.optionalKey(Schema.Boolean), snoozePresets: Schema.optionalKey(SnoozePresetSettings),