Mark newly discovered completed threads unread

[danieliser]

What Changed

• Observe authoritative thread snapshots after each environment has completed its initial bootstrap.
• Remember the thread keys already seen in each environment.
• Mark a thread unread when it first appears after bootstrap with an already-completed latest turn.
• Keep observation history environment-scoped so remote and local snapshots cannot affect one another.

Why

The existing completion indicator is timestamp-based and intentionally treats threads without a visit marker as read. That leaves a narrow gap for a thread created elsewhere that first appears in the current client only after it has already completed.

This draft explores treating that newly discovered completion as unread without lighting up historical threads from the initial snapshot.

Scope

• This does not change sidebar presentation or manual Mark unread behavior.
• Initial bootstrap history remains read.
• This only handles threads first discovered in the completed state; ordinary completion handling remains unchanged.
• The change is independent and can be evaluated as an optional follow-up.

Attribution

The original implementation is authored by Wout Stiens; that authorship is preserved in the commit history.

Verification

• 3 focused tests passed:
  • initial snapshot history is seeded without becoming unread
  • a newly discovered completed thread becomes unread
  • unfinished and non-authoritative-environment threads remain unchanged
• Scoped formatting and lint checks passed.

Note

Mark newly discovered completed threads as unread on first appearance

• Adds a useMarkFirstSeenCompletedThreadsUnread hook that tracks which threads have been seen per snapshot environment and calls markThreadUnread the first time a completed thread appears after the initial bootstrap.
• A pure resolveFirstSeenCompletedThreads utility handles the stateless computation, comparing current thread keys against a previously-seen set to find newly completed threads.
• The hook is mounted in EventRouter in __root.tsx so it runs for the lifetime of the app.
• Behavioral Change: threads completed while the user is away will be marked unread when they next load the app, but only for snapshot environments.

📊 Macroscope summarized fc354d8. 2 files reviewed, 0 issues evaluated, 0 issues filtered, 0 comments posted

🗂️ Filtered Issues

No issues evaluated.

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Repository UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 65717f03-5a08-4a79-8e71-cc414a0eedb0

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

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

[macroscopeapp]

🟡 Medium hooks/useMarkFirstSeenCompletedThreadsUnread.ts:64

resolveFirstSeenCompletedThreads marks a completed thread as seen and pushes it to newlyUnreadThreads even when latestTurn.completedAt is null. Since markThreadUnread ignores null-timestamp threads, the thread is recorded as seen but never actually marked unread. When the real completedAt arrives in a later snapshot, the thread key is already in the previous-seen set, so it is never retried — the thread stays read forever. Consider deferring the push to newlyUnreadThreads until completedAt is non-null, while still tracking the key as seen.

    if (
      previousThreadKeys !== undefined &&
      !previousThreadKeys.has(threadKey) &&
      thread.latestTurn?.state === "completed" &&
+     thread.latestTurn.completedAt != null
    ) {

🤖 Copy this AI Prompt to have your agent fix this:

In file @apps/web/src/hooks/useMarkFirstSeenCompletedThreadsUnread.ts around lines 64-68:

`resolveFirstSeenCompletedThreads` marks a completed thread as seen and pushes it to `newlyUnreadThreads` even when `latestTurn.completedAt` is `null`. Since `markThreadUnread` ignores null-timestamp threads, the thread is recorded as seen but never actually marked unread. When the real `completedAt` arrives in a later snapshot, the thread key is already in the previous-seen set, so it is never retried — the thread stays read forever. Consider deferring the push to `newlyUnreadThreads` until `completedAt` is non-null, while still tracking the key as seen.