@theia/ai-ide 1.74.0-next.8 → 1.74.0

package/src/browser/chat-session-item.tsx

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import {
-    ChatAgentService, ChatRequestModel, ChatService, ChatSession, ChatSessionMetadata
+    ChatAgentService, ChatService, ChatSession, ChatSessionMetadata, ChatSessionStatus
 } from '@theia/ai-chat';
 import { DisposableCollection, Event } from '@theia/core';
 import { buttonKeyboardProps, codicon, HoverService, isActivationKey } from '@theia/core/lib/browser';
@@ -45,6 +45,21 @@ export interface ChatSessionItemProps {
     actions?: ChatSessionItemAction[];
     /** Invoked when an action is triggered, with the action and this item's session. */
     onAction?: (action: ChatSessionItemAction, session: ChatSessionMetadata) => void;
+    /**
+     * Whether this session has child sessions. The children themselves are rendered separately by
+     * the parent list; this only drives the expand/collapse toggle.
+     */
+    hasChildSessions?: boolean;
+    /** Whether this item is a child of a parent session. */
+    isChildSession?: boolean;
+    /** Depth level for indentation. */
+    depth?: number;
+    /** Whether the parent session is expanded. */
+    isExpanded?: boolean;
+    /** Whether any descendant session needs user action; shows a warning badge on this row. */
+    descendantNeedsAttention?: boolean;
+    /** Called when the user toggles the expand/collapse state. */
+    onToggleExpand?: () => void;
 }
 
 /** Subscribes the component to the unread flag for one session. */
@@ -92,15 +107,19 @@ export interface ChatSessionItemComponentProps extends ChatSessionItemProps {
 }
 
 export function ChatSessionItem(props: ChatSessionItemComponentProps): React.ReactElement {
-    const { session, isRestored, chatService, chatAgentService, hoverService, markdownRenderer, unreadState, onClick, actions, onAction, formatTimeAgo } = props;
+    const {
+        session, isRestored, chatService, chatAgentService, hoverService, markdownRenderer, unreadState,
+        onClick, actions, onAction, formatTimeAgo, hasChildSessions, isChildSession, depth, isExpanded,
+        descendantNeedsAttention, onToggleExpand
+    } = props;
+    const currentDepth = depth ?? 0;
 
     // eslint-disable-next-line no-null/no-null
     const itemRef = React.useRef<HTMLDivElement | null>(null);
     const hoverActiveRef = React.useRef(false);
 
     const timeAgo = useTimeAgo(session.saveDate, formatTimeAgo);
-    const [isWorking, setIsWorking] = React.useState(false);
-    const [isWaitingForInput, setIsWaitingForInput] = React.useState(false);
+    const [status, setStatus] = React.useState<ChatSessionStatus>();
     const [hasError, setHasError] = React.useState(session.hasError === true);
     const hasUnread = useUnreadMessages(session.sessionId, unreadState);
 
@@ -119,11 +138,8 @@ export function ChatSessionItem(props: ChatSessionItemComponentProps): React.Rea
 
         const attach = (s: ChatSession) => {
             const recompute = () => {
-                const requests = s.model.getRequests();
-                setIsWorking(requests.some(ChatRequestModel.isInProgress));
-                setIsWaitingForInput(requests.some(r => r.response.isWaitingForInput));
-                const lastReq = requests.at(-1);
-                setHasError(lastReq?.response.isComplete === true && lastReq?.response.isError === true);
+                setStatus(s.model.status);
+                setHasError(s.model.status === 'failed');
             };
             recompute();
             s.model.onDidChange(recompute, undefined, trash);
@@ -159,13 +175,13 @@ export function ChatSessionItem(props: ChatSessionItemComponentProps): React.Rea
         // once the session is actually opened.
         const loadedSession = chatService.getSession(session.sessionId);
         const tooltip = loadedSession
-            ? buildSessionTooltip(loadedSession, session, chatAgentService, markdownRenderer, hasUnread, isWorking, hasError, isWaitingForInput)
-            : buildRestoredSessionTooltip(session, chatAgentService);
+            ? buildSessionTooltip(loadedSession, session, chatAgentService, markdownRenderer, hasUnread, descendantNeedsAttention)
+            : buildRestoredSessionTooltip(session, chatAgentService, descendantNeedsAttention);
         // The tooltip may hold a markdown render result; dispose it once the hover is torn down
         // (or right away if we no longer intend to show it).
         if (!hoverActiveRef.current) { tooltip.dispose(); return; }
         hoverService.requestHover({ content: tooltip.element, target, position: 'left', onHide: () => tooltip.dispose() });
-    }, [session, chatService, chatAgentService, hoverService, markdownRenderer, hasUnread, isWorking, hasError, isWaitingForInput]);
+    }, [session, chatService, chatAgentService, hoverService, markdownRenderer, hasUnread, descendantNeedsAttention]);
 
     React.useEffect(() => () => { hoverActiveRef.current = false; }, []);
 
@@ -188,14 +204,24 @@ export function ChatSessionItem(props: ChatSessionItemComponentProps): React.Rea
         }
     }, [onClick]);
 
-    // A session waiting for input is still "in progress" (ChatRequestModel.isInProgress is true),
+    // A session waiting for input or approval is still working (its request is in progress),
     // so the waiting state takes precedence over the generic working spinner: it signals that the
     // user, not the agent, needs to act.
+    const isWorking = status !== undefined && ChatSessionStatus.isInProgress(status);
+    const ownWaitingForInput = status !== undefined && ChatSessionStatus.requiresUserAction(status);
+    // A row whose (possibly nested) delegated child needs action shows the same bell + dot as a row
+    // that needs action itself, so the signal is consistent and stands out even when collapsed.
+    const isWaitingForInput = ownWaitingForInput || descendantNeedsAttention === true;
     const showWorking = isWorking && !isWaitingForInput;
-    const showUnread = hasUnread && !isWorking && !hasError;
-    const waitingForInputLabel = nls.localize('theia/ai/ide/waitingForInput', 'Waiting for your input');
+    const showUnread = hasUnread && !isWorking && !hasError && !isWaitingForInput;
+    const attentionLabel = ownWaitingForInput
+        ? (status === 'awaitingApproval'
+            ? nls.localize('theia/ai/ide/requiresApproval', 'Requires your approval')
+            : nls.localize('theia/ai/ide/waitingForInput', 'Waiting for your input'))
+        : nls.localize('theia/ai/ide/childInteractionNeeded', 'A delegated session needs your attention');
     const itemClasses = [
         'theia-chat-session-item',
+        isChildSession && 'theia-chat-session-item-child',
         isWaitingForInput && 'theia-chat-session-item-attention',
         showWorking && 'theia-chat-session-item-working',
         hasError && !isWorking && 'theia-chat-session-item-error',
@@ -213,26 +239,55 @@ export function ChatSessionItem(props: ChatSessionItemComponentProps): React.Rea
             className={itemClasses}
             role="button"
             tabIndex={0}
+            style={{ '--tree-indent': `${currentDepth * 12}px` } as React.CSSProperties}
             onClick={onClick}
             onKeyDown={handleKeyDown}
             onMouseEnter={handleMouseEnter}
             onMouseLeave={handleMouseLeave}
             onMouseOver={handleMouseOver}>
             <div className="theia-chat-session-item-icon-col">
-                {isRestored ? (
-                    <span className={`${codicon('archive')} theia-chat-session-item-archive-icon`}
-                        title={nls.localize('theia/ai/ide/restoredSession', 'Restored session')} />
+                {hasChildSessions ? (
+                    <span className="theia-chat-session-item-expand-icon"
+                        onClick={e => {
+                            e.stopPropagation();
+                            onToggleExpand?.();
+                        }}
+                        onKeyDown={e => {
+                            if (isActivationKey(e)) {
+                                e.preventDefault();
+                                e.stopPropagation();
+                                onToggleExpand?.();
+                            }
+                        }}
+                        onMouseDown={e => e.preventDefault()}
+                        role="button"
+                        tabIndex={0}
+                        aria-expanded={isExpanded}
+                        aria-label={isExpanded
+                            ? nls.localize('theia/ai/ide/collapseSession', 'Collapse {0}', title)
+                            : nls.localize('theia/ai/ide/expandSession', 'Expand {0}', title)}>
+                        <span className={`codicon ${isExpanded ? 'codicon-chevron-down' : 'codicon-chevron-right'}`} />
+                    </span>
                 ) : (
-                    <span className={`theia-chat-session-item-agent-icon ${iconClass}`} />
-                )}
-                {showUnread && (
-                    <span className="theia-chat-session-item-unread-dot"
-                        aria-label={nls.localize('theia/ai/ide/tooltip/unread', 'Unread')} />
-                )}
-                {isWaitingForInput && (
-                    <span className="theia-chat-session-item-attention-dot"
-                        aria-label={waitingForInputLabel} />
+                    <span className="theia-chat-session-item-expand-icon theia-chat-session-item-expand-placeholder" aria-hidden="true" />
                 )}
+                <span className="theia-chat-session-item-status-icon">
+                    {isRestored && !isWaitingForInput ? (
+                        <span className={`${codicon('archive')} theia-chat-session-item-archive-icon`}
+                            title={nls.localize('theia/ai/ide/restoredSession', 'Restored session')} />
+                    ) : (
+                        <span className={`theia-chat-session-item-agent-icon ${iconClass}`}
+                            title={isWaitingForInput ? attentionLabel : undefined} />
+                    )}
+                    {showUnread && (
+                        <span className="theia-chat-session-item-unread-dot"
+                            aria-label={nls.localize('theia/ai/ide/tooltip/unread', 'Unread')} />
+                    )}
+                    {isWaitingForInput && (
+                        <span className="theia-chat-session-item-attention-dot"
+                            aria-label={attentionLabel} />
+                    )}
+                </span>
             </div>
             <div className="theia-chat-session-item-content">
                 <div className="theia-chat-session-item-title-line">

package/src/browser/chat-session-list-components.tsx

@@ -0,0 +1,136 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ChatSessionMetadata } from '@theia/ai-chat';
+import { buttonKeyboardProps, isActivationKey } from '@theia/core/lib/browser';
+import { nls } from '@theia/core/lib/common/nls';
+import * as React from '@theia/core/shared/react';
+
+/** When both Active and Restored sections are non-empty, keep at least this many Restored slots. */
+const RESTORED_MIN_RESERVATION = 5;
+
+export interface SectionedSessions {
+    active: ChatSessionMetadata[];
+    restored: ChatSessionMetadata[];
+}
+
+/** A session row with its optional child sessions. */
+export interface SessionRow {
+    session: ChatSessionMetadata;
+    isRestored: boolean;
+    childSessions: SessionRow[];
+}
+
+/**
+ * The id of a session's immediate parent for tree building. Falls back to the root session id for
+ * sessions persisted before immediate-parent tracking existed, so their hierarchy still renders
+ * (flat under the root, as before).
+ */
+export function parentIdOf(session: ChatSessionMetadata): string | undefined {
+    return session.parentSessionId ?? session.rootSessionId;
+}
+
+export interface VisibleSessionSlots {
+    activeCount: number;
+    restoredCount: number;
+}
+
+/**
+ * Allocates the capped number of visible items between the Active and Restored sections of the
+ * overview. When both sections are non-empty, up to {@link RESTORED_MIN_RESERVATION} slots are
+ * reserved for Restored so active sessions cannot crowd it out entirely. A cap of 0 hides the
+ * inline list (every session stays reachable via the "Browse all chats..." link).
+ */
+export function computeVisibleSessionSlots(activeTotal: number, restoredTotal: number, maxSessions: number): VisibleSessionSlots {
+    const cap = Math.max(0, maxSessions);
+    if (cap === 0) {
+        return { activeCount: 0, restoredCount: 0 };
+    }
+    if (restoredTotal === 0) {
+        return { activeCount: Math.min(activeTotal, cap), restoredCount: 0 };
+    }
+    if (activeTotal === 0) {
+        return { activeCount: 0, restoredCount: Math.min(restoredTotal, cap) };
+    }
+    const reserved = Math.min(restoredTotal, Math.min(RESTORED_MIN_RESERVATION, Math.max(1, cap - 1)));
+    const activeCount = Math.min(activeTotal, cap - reserved);
+    const restoredCount = Math.min(restoredTotal, cap - activeCount);
+    return { activeCount, restoredCount };
+}
+
+export interface SessionsListProps {
+    rows: SessionRow[];
+    /** Total cap on items shown; overflow surfaces via the Browse all link. Defaults to no cap. */
+    maxSessions?: number;
+    renderRow: (row: SessionRow) => React.ReactNode;
+    onBrowseAll?: () => void;
+}
+
+export function SessionsList({ rows, maxSessions = Number.MAX_SAFE_INTEGER, renderRow, onBrowseAll }: SessionsListProps): React.ReactElement {
+    // Children are rendered inline by their parent row, so only top-level rows appear in the
+    // sections. A child whose parent session is not in the list falls back to top-level (orphan).
+    const topLevelRows = rows.filter(row => {
+        const parentId = parentIdOf(row.session);
+        if (!parentId) {
+            return true;
+        }
+        return !rows.some(r => r.session.sessionId === parentId);
+    });
+
+    const activeRows = topLevelRows.filter(row => !row.isRestored);
+    const restoredRows = topLevelRows.filter(row => row.isRestored);
+
+    const { activeCount, restoredCount } = computeVisibleSessionSlots(activeRows.length, restoredRows.length, maxSessions);
+    const activeVisible = activeRows.slice(0, activeCount);
+    const restoredVisible = restoredRows.slice(0, restoredCount);
+    const hiddenCount = topLevelRows.length - activeVisible.length - restoredVisible.length;
+
+    return (
+        <div className="theia-WelcomeMessage-SessionsList">
+            {activeVisible.length > 0 && (
+                <div className="theia-WelcomeMessage-SessionsGroup">
+                    <div className="theia-WelcomeMessage-SessionsHeader">
+                        {nls.localizeByDefault('Active')}
+                    </div>
+                    {activeVisible.map(row => renderRow(row))}
+                </div>
+            )}
+            {restoredVisible.length > 0 && (
+                <div className="theia-WelcomeMessage-SessionsGroup">
+                    <div className="theia-WelcomeMessage-SessionsHeader">
+                        {nls.localize('theia/ai/ide/sectionRestored', 'Restored')}
+                    </div>
+                    {restoredVisible.map(row => renderRow(row))}
+                </div>
+            )}
+            {hiddenCount > 0 && onBrowseAll && (
+                <div className="theia-WelcomeMessage-SessionsFooter">
+                    <a className="theia-WelcomeMessage-FooterLink"
+                        {...buttonKeyboardProps(nls.localize('theia/ai/ide/browseAllChats', 'Browse all chats...'))}
+                        onClick={onBrowseAll}
+                        onKeyDown={e => {
+                            if (isActivationKey(e)) {
+                                e.preventDefault();
+                                onBrowseAll();
+                            }
+                        }}>
+                        {nls.localize('theia/ai/ide/browseAllChats', 'Browse all chats...')}
+                    </a>
+                </div>
+            )}
+        </div>
+    );
+}

package/src/browser/{chat-sessions-welcome-message-provider.spec.ts → chat-session-list-service.spec.ts}

@@ -20,10 +20,11 @@ import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/front
 FrontendApplicationConfigProvider.set({});
 import { expect } from 'chai';
 import { Emitter } from '@theia/core';
-import { ChatAgentLocation, ChatService, ChatSession, ChatSessionMetadata } from '@theia/ai-chat';
+import { ChatAgentLocation, ChatService, ChatSession, ChatSessionMetadata, ChatSessionStatus } from '@theia/ai-chat';
 import { ChatViewWidget } from '@theia/ai-chat-ui/lib/browser/chat-view-widget';
 import { ApplicationShell, Widget } from '@theia/core/lib/browser';
-import { ChatSessionsWelcomeMessageProvider, SectionedSessions, computeVisibleSessionSlots } from './chat-sessions-welcome-message-provider';
+import { ChatSessionListService } from './chat-session-list-service';
+import { SectionedSessions, SessionRow, computeVisibleSessionSlots } from './chat-session-list-components';
 disableJSDOM();
 
 /**
@@ -32,7 +33,7 @@ disableJSDOM();
  * unread bookkeeping; spinning up the full container would pull in unrelated
  * services and obscure the assertion.
  */
-class TestableProvider extends ChatSessionsWelcomeMessageProvider {
+class TestableService extends ChatSessionListService {
     constructor(chatService: ChatService, shell: ApplicationShell) {
         super();
         (this as unknown as { chatService: ChatService }).chatService = chatService;
@@ -59,6 +60,7 @@ function createFakeSession(id: string): {
         id,
         isActive: false,
         model: {
+            status: 'idle' as ChatSessionStatus,
             getRequests: () => requests,
             onDidChange: onDidChangeEmitter.event,
         }
@@ -70,7 +72,7 @@ function createFakeSession(id: string): {
     };
 }
 
-describe('ChatSessionsWelcomeMessageProvider', () => {
+describe('ChatSessionListService', () => {
 
     describe('unread state', () => {
         let activeSessionId: string | undefined;
@@ -112,33 +114,33 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
         });
 
         it('marks the session unread when a new request arrives and the chat view is not focused', () => {
-            const provider = new TestableProvider(chatService, shell);
+            const service = new TestableService(chatService, shell);
             const { session, fire, pushRequest } = createFakeSession('s1');
             activeSessionId = 's1';
             activeWidget = otherWidget;
 
-            provider.watch(session);
+            service.watch(session);
             pushRequest(true);
             fire();
 
-            expect(provider.isUnread('s1')).to.equal(true);
+            expect(service.isUnread('s1')).to.equal(true);
         });
 
         it('does not mark unread when the session is active AND the chat view is focused', () => {
-            const provider = new TestableProvider(chatService, shell);
+            const service = new TestableService(chatService, shell);
             const { session, fire, pushRequest } = createFakeSession('s1');
             activeSessionId = 's1';
             activeWidget = chatViewWidget;
 
-            provider.watch(session);
+            service.watch(session);
             pushRequest(true);
             fire();
 
-            expect(provider.isUnread('s1')).to.equal(false);
+            expect(service.isUnread('s1')).to.equal(false);
         });
 
         it('does not mark unread when focus is inside a child widget of the chat view', () => {
-            const provider = new TestableProvider(chatService, shell);
+            const service = new TestableService(chatService, shell);
             const { session, fire, pushRequest } = createFakeSession('s1');
             activeSessionId = 's1';
             // Simulate focus inside a descendant (e.g. AIChatInputWidget): the shell's
@@ -147,42 +149,42 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
             activeWidget = childWidget;
             widgetForActiveElement = childWidget;
 
-            provider.watch(session);
+            service.watch(session);
             pushRequest(true);
             fire();
 
-            expect(provider.isUnread('s1')).to.equal(false);
+            expect(service.isUnread('s1')).to.equal(false);
         });
 
         it('marks unread when the session is not the active one, even if the chat view is focused', () => {
-            const provider = new TestableProvider(chatService, shell);
+            const service = new TestableService(chatService, shell);
             const { session, fire, pushRequest } = createFakeSession('s1');
             activeSessionId = 'other';
             activeWidget = chatViewWidget;
 
-            provider.watch(session);
+            service.watch(session);
             pushRequest(true);
             fire();
 
-            expect(provider.isUnread('s1')).to.equal(true);
+            expect(service.isUnread('s1')).to.equal(true);
         });
 
         it('fires onUnreadChanged once when a session transitions to unread', () => {
-            const provider = new TestableProvider(chatService, shell);
+            const service = new TestableService(chatService, shell);
             const { session, fire, pushRequest } = createFakeSession('s1');
             activeSessionId = undefined;
             activeWidget = otherWidget;
 
             let fired = 0;
-            provider.onUnreadChanged(() => { fired++; });
+            service.onUnreadChanged(() => { fired++; });
 
-            provider.watch(session);
+            service.watch(session);
             pushRequest(true);
             fire();
             pushRequest(true);
             fire();
 
-            expect(provider.isUnread('s1')).to.equal(true);
+            expect(service.isUnread('s1')).to.equal(true);
             expect(fired).to.equal(1);
         });
     });
@@ -239,11 +241,11 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
 
     describe('getSections', () => {
 
-        class SectionsTestProvider extends ChatSessionsWelcomeMessageProvider {
+        class SectionsTestService extends ChatSessionListService {
             constructor(sessions: ChatSession[], persistedSessions: ChatSessionMetadata[]) {
                 super();
                 (this as unknown as { chatService: ChatService }).chatService = { getSessions: () => sessions } as unknown as ChatService;
-                this._persistedSessions = persistedSessions;
+                (this as unknown as { _persistedSessions: ChatSessionMetadata[] })._persistedSessions = persistedSessions;
             }
             sections(): SectionedSessions {
                 return this.getSections();
@@ -254,9 +256,8 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
             lastInteraction?: Date;
             pinnedAgentId?: string;
             location?: ChatAgentLocation;
-            lastRequest?: { isComplete: boolean; isError: boolean };
+            status?: ChatSessionStatus;
         }): ChatSession {
-            const requests = opts?.lastRequest ? [{ response: opts.lastRequest }] : [];
             return {
                 id,
                 title,
@@ -265,7 +266,8 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
                 pinnedAgent: opts?.pinnedAgentId ? { id: opts.pinnedAgentId } : undefined,
                 model: {
                     location: opts?.location ?? ChatAgentLocation.Panel,
-                    getRequests: () => requests
+                    status: opts?.status ?? 'idle',
+                    getRequests: () => []
                 }
             } as unknown as ChatSession;
         }
@@ -275,7 +277,7 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
         }
 
         function getSections(sessions: ChatSession[], persistedSessions: ChatSessionMetadata[]): SectionedSessions {
-            return new SectionsTestProvider(sessions, persistedSessions).sections();
+            return new SectionsTestService(sessions, persistedSessions).sections();
         }
 
         it('excludes active sessions without a title', () => {
@@ -304,11 +306,11 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
             expect(sections.restored.map(s => s.sessionId)).to.deep.equal(['b']);
         });
 
-        it('flags an active session whose last request completed with an error', () => {
+        it('flags an active session whose status is failed', () => {
             const sections = getSections([
-                makeSession('ok', 'Ok', { lastRequest: { isComplete: true, isError: false } }),
-                makeSession('err', 'Err', { lastRequest: { isComplete: true, isError: true } }),
-                makeSession('running', 'Running', { lastRequest: { isComplete: false, isError: false } })
+                makeSession('ok', 'Ok', { status: 'idle' }),
+                makeSession('err', 'Err', { status: 'failed' }),
+                makeSession('running', 'Running', { status: 'running' })
             ], []);
             const byId = new Map(sections.active.map(s => [s.sessionId, s.hasError]));
             expect(byId.get('ok')).to.equal(false);
@@ -324,4 +326,108 @@ describe('ChatSessionsWelcomeMessageProvider', () => {
             expect(sections.active[0].location).to.equal(ChatAgentLocation.Panel);
         });
     });
+
+    describe('session hierarchy', () => {
+
+        class HierarchyTestService extends ChatSessionListService {
+            constructor(chatService: ChatService, persistedSessions: ChatSessionMetadata[] = []) {
+                super();
+                (this as unknown as { chatService: ChatService }).chatService = chatService;
+                (this as unknown as { _persistedSessions: ChatSessionMetadata[] })._persistedSessions = persistedSessions;
+            }
+            rows(sections: SectionedSessions): SessionRow[] {
+                return this.buildRows(sections);
+            }
+            subtreeRequiresAction(row: SessionRow): boolean {
+                return this.descendantRequiresAction(row);
+            }
+            expand(session: ChatSession): void {
+                this.expandAncestors(session);
+            }
+            get expanded(): Set<string> {
+                return this.expandedRoots;
+            }
+        }
+
+        function meta(sessionId: string, opts?: { rootSessionId?: string; parentSessionId?: string }): ChatSessionMetadata {
+            return {
+                sessionId,
+                title: sessionId,
+                saveDate: 0,
+                location: ChatAgentLocation.Panel,
+                rootSessionId: opts?.rootSessionId,
+                parentSessionId: opts?.parentSessionId
+            };
+        }
+
+        function loadedSession(id: string, status: ChatSessionStatus, opts?: { rootSessionId?: string; parentSessionId?: string }): ChatSession {
+            return {
+                id,
+                rootSessionId: opts?.rootSessionId,
+                parentSessionId: opts?.parentSessionId,
+                model: { status }
+            } as unknown as ChatSession;
+        }
+
+        function findRow(rows: SessionRow[], sessionId: string): SessionRow {
+            const row = rows.find(r => r.session.sessionId === sessionId);
+            expect(row, `row ${sessionId}`).to.not.be.undefined;
+            return row!;
+        }
+
+        it('nests a restored A -> B hierarchy with an active C under the root', () => {
+            const service = new HierarchyTestService({ getSession: () => undefined } as unknown as ChatService);
+            const sections: SectionedSessions = {
+                active: [meta('C', { rootSessionId: 'A', parentSessionId: 'B' })],
+                restored: [meta('A'), meta('B', { rootSessionId: 'A', parentSessionId: 'A' })]
+            };
+
+            const rows = service.rows(sections);
+            const rowA = findRow(rows, 'A');
+            expect(rowA.isRestored).to.equal(true);
+            expect(rowA.childSessions.map(c => c.session.sessionId)).to.deep.equal(['B']);
+            const rowB = rowA.childSessions[0];
+            expect(rowB.isRestored).to.equal(true);
+            expect(rowB.childSessions.map(c => c.session.sessionId)).to.deep.equal(['C']);
+            expect(rowB.childSessions[0].isRestored).to.equal(false);
+        });
+
+        it('propagates a deep descendant needing action up the tree', () => {
+            // Only the leaf C awaits input; both B and the root A must report a descendant needing action.
+            const chatService = {
+                getSession: (id: string) => id === 'C' ? loadedSession('C', 'awaitingInput') : loadedSession(id, 'idle')
+            } as unknown as ChatService;
+            const service = new HierarchyTestService(chatService);
+            const sections: SectionedSessions = {
+                active: [meta('C', { rootSessionId: 'A', parentSessionId: 'B' })],
+                restored: [meta('A'), meta('B', { rootSessionId: 'A', parentSessionId: 'A' })]
+            };
+
+            const rows = service.rows(sections);
+            const rowA = findRow(rows, 'A');
+            const rowB = rowA.childSessions[0];
+            const rowC = rowB.childSessions[0];
+            expect(service.subtreeRequiresAction(rowA)).to.equal(true);
+            expect(service.subtreeRequiresAction(rowB)).to.equal(true);
+            expect(service.subtreeRequiresAction(rowC)).to.equal(false);
+        });
+
+        it('expands every ancestor of a session that needs action, falling back to persisted-only ancestors', () => {
+            // C is loaded and awaiting input; its ancestors B and A exist only in the persisted index
+            // (e.g. C was opened directly from "Browse all chats"). The walk must reach the root A, not
+            // stop at the first ancestor `getSession` cannot resolve.
+            const c = loadedSession('C', 'awaitingInput', { rootSessionId: 'A', parentSessionId: 'B' });
+            const chatService = {
+                getSession: (id: string) => id === 'C' ? c : undefined
+            } as unknown as ChatService;
+            const service = new HierarchyTestService(chatService, [
+                meta('A'),
+                meta('B', { rootSessionId: 'A', parentSessionId: 'A' })
+            ]);
+
+            service.expand(c);
+
+            expect([...service.expanded].sort()).to.deep.equal(['A', 'B']);
+        });
+    });
 });