[fixfon]

Problem

After a snooze expires and the Woke badge is dismissed, choosing Mark unread brings the old Woke badge back instead of showing Done (#24052).

Dismissing Woke records a visit at the wake time. Mark unread rewinds lastVisitedAt to just before the latest completion but keeps the expired snoozedUntil/snoozedAt. Clients read snoozedUntil as the wake time, so after the rewind the already-dismissed wake looks unseen again and outranks Done.

Repro (from the issue): finish a run, snooze for 1 minute, let it expire, dismiss Woke, then Mark unread. Expected Done, got Woke.

Change

In the thread.mark-unread case in apps/server/src/orchestration-v2/Orchestrator.ts, if the snooze has already expired (snoozedUntil <= now), clear snoozedUntil and snoozedAt and store the expiry in lastSnoozeWakeAt. Auto-settlement already reads lastSnoozeWakeAt as the wake time after a timer wake, so its timer base does not change.

• A snooze that has not expired yet is left untouched.
• updatedAt is not changed, same as before.
• Side effect: once Mark unread retires an expired snooze, that Woke badge is gone for good. The thread shows Done (unread) until the next snooze/wake cycle. This is the behavior the issue asks for.

Server only, 2 files, +128/-2 (16 lines of source, the rest is tests). No client changes.

Scope and approval

Fixes #24052. The issue has no maintainer triage comment yet. I think this qualifies as a small, focused fix for an obvious bug: Mark unread is meant to mark the latest completion unread, and bringing back a notification the user already dismissed is a side effect, not intended behavior. The fix is the one the reporter described and verified on their own build.

Possible overlap with open PRs, both different bugs:

• fix(server): mark unread works while a queued message is held #23593 changes the line just above in the same mark-unread path (latestRunCompletedAt now comes from latestUnheldRun). It does not touch the snooze fields. Whichever lands second will need a trivial rebase in Orchestrator.ts.
• fix(threads): allow snoozing pending input requests #20058 also clears snoozedUntil/snoozedAt, but when a snoozed user-input request is answered, not on mark unread. It also edits Orchestrator.control-reads.test.ts, so a rebase conflict in that test file is possible.

Verification

Unit tests only. I did not run the UI or do a manual check in the app.

Two new tests in apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts:

• mark unread retires an expired snooze so a dismissed wake stays dismissed: complete a run, snooze 1 minute, advance 2 minutes, visit at the wake time, then mark unread. Asserts lastVisitedAt is rewound, snoozedUntil/snoozedAt are null, and lastSnoozeWakeAt equals the old expiry.
• mark unread leaves a future snooze untouched: same flow with a 60-minute snooze. Only lastVisitedAt changes.

Results:

• vp test run apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts: the expired-snooze test fails on base 12c91aef7a and with the source change reverted; with the change, 13/13 pass.
• vp test run apps/server/src/orchestration-v2/ThreadSettlementService.test.ts packages/client-runtime/src/state/threadSnoozed.test.ts: 42/42 pass (22 + 20).
• Lint, format check and server typecheck are clean.

Environment: macOS arm64, Node 25.9.0 (the repo's engines field asks for 26.12.1, so tests did not run on the pinned Node), pnpm 12.14.0.

Claude Sonnet 5.5 (xhigh) via T3 Code.

[macroscopeapp]

Approvability

Verdict: Approved at b81ade6

Macroscope's review found this PR approvable — This is a small, focused server bug fix that retires only expired snoozes during Mark Unread, while preserving future snoozes. Regression tests cover both cases, and the change introduces no schema, configuration, or new capability.

^{You can add or adjust custom eligibility rules. Learn more.}

[coderabbitai]

No actionable comments were generated in the recent review.

Recent review info

Run configuration

• Source mode: Auto
• Repository: pingdotgg/t3code
• Branch: main
• File: .coderabbit.config.ts
• Commit: 1316d48
• Layers: Repository TS config
• Review profile: CHILL
• Plan: Advanced
• Run ID: 3915f93d-a163-4941-a707-afde9160997b

Commits

Reviewing files that changed from the base of the PR and between b81ade6 and f25ccc9.

Files selected for processing: 4

• apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts
• apps/server/src/orchestration-v2/Orchestrator.ts
• packages/client-runtime/src/state/threadVisits.test.ts
• packages/client-runtime/src/state/threadVisits.ts

Included review availability: This review used your included allowance. Your plan provides up to 10 included reviews per hour; 0 remain after this review.

Walkthrough

When thread.mark-unread runs, it clears snooze fields if the snooze deadline has passed and records that deadline as lastSnoozeWakeAt. It preserves future snoozes. Client visit tracking suppresses duplicate visits based on timestamp order.

Changes: Mark Unread and Snooze State

Layer / File(s)	Summary
Mark-unread behavior and regression coverage apps/server/src/orchestration-v2/Orchestrator.ts, apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts	thread.mark-unread clears snoozedUntil and snoozedAt when the deadline has passed, and records the deadline in lastSnoozeWakeAt. Tests cover expired and future snoozes and the lastVisitedAt rewind.
Visit deduplication and regression coverage packages/client-runtime/src/state/threadVisits.ts, packages/client-runtime/src/state/threadVisits.test.ts	Visit tracking suppresses dispatch when the last dispatched timestamp is greater than or equal to the effective update time. A test covers wake-time visits, timestamp changes, and a later visit.

Priority: Low

Estimated code review effort: 2 (Simple) | ~10 minutes

Change: Bug fix · Severity of issue fixed: Low

Suggested labels: bugfix, size:M

Suggested reviewers: juliusmarminge, yash-singh1

Merge Risk: Minimal · up to f25cc

The change appears ready to merge after normal checks; no concrete remaining issue is identified.

Pre-merge checks: 3 · 1

Failed checks: 1 warning

Check name	Status	Explanation	Resolution
Linked Issues check		Issue #24052 requires the expired-snooze thread.mark-unread behavior. Orchestrator.ts clears snoozedUntil and snoozedAt, stores the old expiry in lastSnoozeWakeAt, and preserves future snooz…	Add an automated regression test for replaying thread.mark-unread after the thread is snoozed again. Verify that command replay does not retire or alter the new snooze, while the expired-snooze case still records the prior wake in `lastSn…

Passed checks: 3 passed

Check name	Status	Explanation
Title check		The title is concise, specific, and accurately describes the primary fix: Mark unread no longer restores a dismissed wake.
Description check		The description includes all required sections. It clearly explains the problem, implementation, scope rationale, affected behavior, focused verification, test results, environment, and unperformed ch…
Out of Scope Changes check		The client-runtime changes are directly related to #24052. They prevent the active-thread visit tracker from immediately undoing the server-side unread rewind after the expired wake is retired, and th…

Full details: Description check

Explanation

The description includes all required sections. It clearly explains the problem, implementation, scope rationale, affected behavior, focused verification, test results, environment, and unperformed checks.

Full details: Out of Scope Changes check

Explanation

The client-runtime changes are directly related to #24052. They prevent the active-thread visit tracker from immediately undoing the server-side unread rewind after the expired wake is retired, and the added test verifies that behavior. The remaining changes implement or test the server state transition. No unrelated change is established by the complete PR diff.

Full details: Linked Issues check

Explanation

Issue #24052 requires the expired-snooze thread.mark-unread behavior. Orchestrator.ts clears snoozedUntil and snoozedAt, stores the old expiry in lastSnoozeWakeAt, and preserves future snoozes. The server tests cover the expired and future cases, and threadVisits.ts keeps the unread state sticky after wake retirement. However, the linked issue also requires regression coverage that replays the command after a new snooze. The whole PR diff contains no such test.

Resolution

Add an automated regression test for replaying thread.mark-unread after the thread is snoozed again. Verify that command replay does not retire or alter the new snooze, while the expired-snooze case still records the prior wake in lastSnoozeWakeAt.

Finishing Touches

🧪 Generate unit tests (beta)

• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

_{Comment @coderabbitai help to get the list of available commands.}

[maria-rcks]

Note

Written by gpt-6.1-sol on behalf of Maria

thanks @fixfon. the expired-snooze cleanup and saved wake timestamp correctly preserve settlement timing. i retained your commit and both regression tests, merged current main, and shortened the source comment.

i also fixed one nearby mobile regression: removing the wake timestamp could make the active visit tracker send an older visit and immediately undo mark unread. the tracker now ignores older watermarks; a regression in its existing test file verifies unread persists until fresh activity.

verification at f25ccc9dac1060afd8877c6e4c2668030656eeb2:

• reproduced the original regression against current main's implementation: expired-snooze test fails; future-snooze test passes.
• reproduced the tracker regression before fixing it.
• blacksmith: 63 focused orchestrator/settlement/client-snooze tests pass. vp run check:changed passes format, lint, knip, graphql, eight affected/dependent package typechecks, and 24 adjacent tests.
• real chrome client and codex provider: completed a turn, snoozed for one minute, waited for expiry, explicitly dismissed Woke, then chose Mark unread. main restores Woke; the fix shows Done. matching thread and persisted data across server restarts. stored snooze fields clear, while lastSnoozeWakeAt retains the original expiry.
• all 27 ci checks pass; latest CodeRabbit review has no actionable findings. two independent final-head reviews approve.

unverified: native mobile and electron were not run. the mobile visit behavior is covered through the shared tracker test. no labels changed and no pr merged.

main after mark unread:

fix after mark unread:

short sidebar interaction on the fix:

review note: CodeRabbit's nonblocking linked-issue warning asks for a command-replay test after re-snoozing. the issue describes that coverage in its local workaround; it does not require changing replay semantics. Orchestrator.ts checks the persisted command receipt at lines 11927–11970 and returns it before dispatching any mutation, so replay cannot clear a newer snooze. no replay code changed. the general receipt-replay regression also passes in Orchestrator.control-reads.test.ts; the extra snooze-specific replay scenario remains untested.

media note: git.cafe currently renders these external media references as links. the uploaded images were inspected and the uploaded video was played through and seeked in chrome.

[maria-rcks]

Note

Written by gpt-6.1-sol on behalf of Maria

Verified in a real dev environment

verified as-is at f25ccc9dac1060afd8877c6e4c2668030656eeb2 on this task's linux boat vm. no code changes or pushes were needed.

• reproduced on fresh github/main (2349c81afc): finish a real codex gpt-6.1-sol turn, snooze for one minute, navigate away, wait for expiry, dismiss woke, then choose mark unread. woke incorrectly returns.
• stopped main, checked out the exact pr head, installed dependencies, and ran the real dev server against an isolated copy of the same app-created data. repo playwright and /usr/bin/google-chrome drove the web UI. the same mark-unread action shows done. snoozedUntil and snoozedAt clear; lastSnoozeWakeAt retains the original expiry. the matching badge crops below use the same thread and completed run.
• a future one-hour snooze survives mark unread unchanged. wake now still returns the thread. snoozing again produces a fresh woke badge.
• mark unread stays done while the thread is open. a subsequent real gpt-6.1-sol turn completes and advances the active visit normally, clearing unread. two fresh provider turns completed on the pr head.
• blacksmith: all 72 focused orchestrator, settlement, snooze, and visit-tracker tests pass. vp run check:changed 1316d48b0c68151afd8b47eb0c11a114cf0b4daa passes format, lint, knip, graphql, eight affected/dependent package typechecks, and 24 adjacent tests. the worker initially lacked the merge base; fetching the pr history fixed that setup issue. ci currently reports 29 successful checks, none pending or failing.

main after mark unread:

pr after mark unread:

pr interaction, including mark unread while open (animated copy for github):

short runtime transcript and persisted state

captures were inspected, and the uploaded recording was played through and seeked in chrome.

Not verified

native ios/android and electron clients were not launched. macos/windows, relay/tunnel, multi-device flows, other providers, and the specific replay-after-re-snooze scenario were not exercised. this linux pass verifies the web client and real codex provider path; shared mobile visit logic is covered by the existing tracker tests. automatic settlement timing was covered by existing tests, not a long manual wait.