From 38222d07c8f7396ae973e378fb3f607628b04a02 Mon Sep 17 00:00:00 2001
From: Bohdan Triapitsyn <artmore@protonmail.com>
Date: Thu, 23 Jul 2026 16:46:20 +0300
Subject: [PATCH] fix: include active root sessions in Recent sidebar

Recent now shows active root sessions immediately, even if they are older than 48 hours
Archived sessions and subtasks still stay out of Recent
Added coverage and documentation for the new recency rules
---
 .../src/components/session/SessionSidebar.tsx | 19 +++++----
 .../session/sidebar/DOCUMENTATION.md          |  1 +
 .../session/sidebar/activitySections.test.ts  | 39 +++++++++++++++++++
 .../session/sidebar/activitySections.ts       | 13 +++----
 4 files changed, 57 insertions(+), 15 deletions(-)
 create mode 100644 packages/ui/src/components/session/sidebar/activitySections.test.ts

diff --git a/packages/ui/src/components/session/SessionSidebar.tsx b/packages/ui/src/components/session/SessionSidebar.tsx
index 52ee121c..2a3d9f27 100644
--- a/packages/ui/src/components/session/SessionSidebar.tsx
+++ b/packages/ui/src/components/session/SessionSidebar.tsx
@@ -78,6 +78,7 @@ import {
   orderSessionsByLifecycleScopes,
   useSessionOrderingStore,
 } from '@/sync/session-ordering';
+import { useGlobalSessionStatusStore } from '@/sync/global-session-status';
 import {
   refreshGlobalSessions,
   refreshGlobalSessionsForDirectories,
@@ -270,6 +271,10 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
     (state) => isVisible ? state.rankById : EMPTY_SESSION_ORDER_RANKS,
     [isVisible],
   ));
+  const activeSessionIds = useGlobalSessionStatusStore(useShallow(
+    (state) => isVisible ? [...state.statusById.keys()].sort() : EMPTY_STRING_ARRAY,
+  ));
+  const activeSessionIdSet = React.useMemo(() => new Set(activeSessionIds), [activeSessionIds]);
   const togglePinnedSession = useSessionPinnedStore((state) => state.toggle);
   const [collapsedGroups, setCollapsedGroups] = React.useState<Set<string>>(() => {
     try {
@@ -1263,16 +1268,16 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
     return meta;
   }, [projectSections, homeDirectory]);
 
-  const activeNowSessions = React.useMemo(() => {
+  const recentSessions = React.useMemo(() => {
     if (!showRecentSection || isVSCode) {
       return [];
     }
 
-    return deriveRecentSessions(sessions)
+    return deriveRecentSessions(sessions, activeSessionIdSet)
       .sort((a, b) => compareSessionsByLifecycleOrder(a, b, pinnedSessionIds, sessionOrderRanks));
-  }, [isVSCode, pinnedSessionIds, sessionOrderRanks, sessions, showRecentSection]);
+  }, [activeSessionIdSet, isVSCode, pinnedSessionIds, sessionOrderRanks, sessions, showRecentSection]);
 
-  // Prefetch is wired below, after recentSessionIds is computed.
+  // Prefetch is wired below, after recentSessions is computed.
 
   const activitySections = React.useMemo(() => {
     // VS Code renders the full grouped project view (one group per open
@@ -1282,8 +1287,6 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
       return [];
     }
 
-    const recentSessions = activeNowSessions;
-
     const toItem = (session: Session) => {
       const existing = sessionSidebarMetaById.get(session.id);
       const sessionDirectory = normalizePath((session as Session & { directory?: string | null }).directory ?? null);
@@ -1316,7 +1319,7 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
     return [
       { key: 'active-now' as const, title: t('sessions.sidebar.activity.recentTitle'), items },
     ];
-  }, [activeNowSessions, filterSessionNodesForSearch, hasSessionSearchQuery, isVSCode, normalizedSessionSearchQuery, sessionSidebarMetaById, showRecentSection, t]);
+  }, [filterSessionNodesForSearch, hasSessionSearchQuery, isVSCode, normalizedSessionSearchQuery, recentSessions, sessionSidebarMetaById, showRecentSection, t]);
 
   const hasActivitySectionItems = React.useMemo(
     () => activitySections.some((section) => section.items.length > 0),
@@ -1728,7 +1731,7 @@ const SessionSidebarComponent: React.FC<SessionSidebarProps> = ({
       <SessionPrefetchEffect
         enabled={isVisible}
         sortedSessions={orderedSessions}
-        recentSessions={activeNowSessions}
+        recentSessions={recentSessions}
         prefetchSession={sync.prefetchSession}
       />
       <SidebarHeader
diff --git a/packages/ui/src/components/session/sidebar/DOCUMENTATION.md b/packages/ui/src/components/session/sidebar/DOCUMENTATION.md
index 0047bc9b..a5165543 100644
--- a/packages/ui/src/components/session/sidebar/DOCUMENTATION.md
+++ b/packages/ui/src/components/session/sidebar/DOCUMENTATION.md
@@ -73,6 +73,7 @@
 - Folder membership may contain both a parent session and its descendants. Rendering treats only the highest assigned ancestors as folder roots because their normal session trees already include assigned descendants; persisted membership remains unchanged for cleanup and move semantics.
 - Sidebar selection holds the clicked row's viewport position across navigation-driven sidebar updates. Wheel or touch input cancels the hold immediately, so programmatic compensation never fights intentional scrolling.
 - Global session subscriptions are structural: create/delete, title, share, archive, directory, parent, and slug changes invalidate the tree. Recency-only `time.updated` changes do not trigger a rebuild. The separate lifecycle rank invalidates ordering only on `settled ↔ active` transitions, with root sessions ranked among roots and child sessions only among siblings of the same parent.
+- Recent membership includes active root sessions immediately even when their last committed `time.updated` falls outside the 48-hour window. Children and archived sessions remain excluded, and inactive roots remain timestamp-based. The active-ID subscription is disabled while the sidebar is hidden and ignores retry/status detail changes, avoiding streaming-frequency rerenders.
 - Structural updates rebuild grouped nodes only for projects whose local sessions, worktrees, repository state, or branch changed; unchanged project sections preserve references so memoized group/session descendants skip the update wave.
 - Empty successful lists, unresolved loads, and failed loads are separate UI states. Failed groups expose Retry and retain prior data.
 - Pins and folder assignments are not pruned from the first startup snapshot or from optimistic mutations. Confirmed local deletion and routed external deletion clean immediately; a later authoritative omission after an established baseline covers missed external delete events.
diff --git a/packages/ui/src/components/session/sidebar/activitySections.test.ts b/packages/ui/src/components/session/sidebar/activitySections.test.ts
new file mode 100644
index 00000000..f0132f15
--- /dev/null
+++ b/packages/ui/src/components/session/sidebar/activitySections.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'bun:test';
+import type { Session } from '@opencode-ai/sdk/v2';
+import { deriveRecentSessions } from './activitySections';
+
+const NOW = 200_000_000;
+const RECENT = NOW - (48 * 60 * 60 * 1000);
+const OLD = NOW - (72 * 60 * 60 * 1000);
+
+const session = (id: string, options: { parentID?: string; archived?: number; updated?: number } = {}): Session => ({
+  id,
+  parentID: options.parentID,
+  time: { created: OLD, updated: options.updated ?? OLD, archived: options.archived },
+} as Session);
+
+describe('deriveRecentSessions', () => {
+  test('includes an old root session while it is active', () => {
+    const oldActive = session('old-active');
+
+    expect(deriveRecentSessions([oldActive], new Set([oldActive.id]), NOW)).toEqual([oldActive]);
+  });
+
+  test('does not promote active children or archived sessions into Recent', () => {
+    const child = session('child', { parentID: 'parent' });
+    const archived = session('archived', { archived: NOW - 1 });
+
+    expect(deriveRecentSessions(
+      [child, archived],
+      new Set([child.id, archived.id]),
+      NOW,
+    )).toEqual([]);
+  });
+
+  test('keeps inactive membership timestamp-based', () => {
+    const oldSession = session('old');
+    const recentSession = session('recent', { updated: RECENT });
+
+    expect(deriveRecentSessions([oldSession, recentSession], new Set(), NOW)).toEqual([recentSession]);
+  });
+});
diff --git a/packages/ui/src/components/session/sidebar/activitySections.ts b/packages/ui/src/components/session/sidebar/activitySections.ts
index f655b0d6..87050296 100644
--- a/packages/ui/src/components/session/sidebar/activitySections.ts
+++ b/packages/ui/src/components/session/sidebar/activitySections.ts
@@ -22,20 +22,19 @@ const getSessionUpdatedAt = (session: Session): number => {
   return 0;
 };
 
-// Recent sessions are simply every non-archived, top-level session updated
-// within the last RECENT_SESSION_MAX_AGE_MS. No persisted history or live-busy
-// tracking: membership is timestamp-derived, while the caller applies shared
-// lifecycle ordering.
+// Recent contains non-archived root sessions that are active now or were
+// updated within the retention window. The caller applies shared lifecycle
+// ordering after this membership filter.
 export const deriveRecentSessions = (
   sessions: Session[],
+  activeSessionIds: ReadonlySet<string>,
   now = Date.now(),
 ): Session[] => {
   const minUpdatedAt = now - RECENT_SESSION_MAX_AGE_MS;
-  const recent = sessions.filter((session) => {
+  return sessions.filter((session) => {
     if (isArchivedSession(session) || isSubtaskSession(session)) {
       return false;
     }
-    return getSessionUpdatedAt(session) >= minUpdatedAt;
+    return activeSessionIds.has(session.id) || getSessionUpdatedAt(session) >= minUpdatedAt;
   });
-  return recent;
 };