@theia/ai-chat 1.74.0-next.9 → 1.74.1

package/src/common/chat-service-pinned-agent.spec.ts

@@ -74,17 +74,38 @@ describe('ChatService pinned agent behavior', () => {
         prompts: []
     };
 
+    const mockHiddenAgent: ChatAgent = {
+        id: 'hidden-worker',
+        name: 'Hidden Worker',
+        description: 'Test agent that is hidden from chat (showInChat: false)',
+        locations: [ChatAgentLocation.Panel],
+        invoke: async () => { },
+        languageModelRequirements: [],
+        tags: [],
+        variables: [],
+        agentSpecificVariables: [],
+        functions: [],
+        prompts: []
+    };
+
     class MockChatAgentService {
         private agents = new Map<string, ChatAgent>([
             ['pinned-agent', mockPinnedAgent],
             ['mentioned-agent', mockMentionedAgent],
-            ['default-agent', mockDefaultAgent]
+            ['default-agent', mockDefaultAgent],
+            ['hidden-worker', mockHiddenAgent]
         ]);
 
+        /** Mirrors ChatAgentServiceImpl: agents with showInChat === false are only returned with includeHidden. */
+        private hiddenIds = new Set<string>(['hidden-worker']);
+
         readonly onDidChangeAgents = { dispose: () => { } };
         readonly onDefaultAgentChanged = { dispose: () => { } };
 
-        getAgent(id: string): ChatAgent | undefined {
+        getAgent(id: string, includeHidden: boolean = false): ChatAgent | undefined {
+            if (!includeHidden && this.hiddenIds.has(id)) {
+                return undefined;
+            }
             return this.agents.get(id);
         }
 
@@ -222,4 +243,39 @@ describe('ChatService pinned agent behavior', () => {
         // The selected agent (mentioned-agent) becomes the new pinned agent
         expect(session.pinnedAgent).to.equal(mockMentionedAgent);
     });
+
+    it('should resolve a hidden pinned agent instead of falling back to the default agent', () => {
+        // AgentDelegationTool pins the delegated agent on the session it creates; worker agents
+        // are typically hidden (showInChat: false). The pin is an explicit choice, so it must
+        // resolve even for hidden agents — falling back to the default agent would silently run
+        // the wrong agent with the wrong prompt and toolset.
+        const session = createMockSession(mockHiddenAgent);
+        const parsedRequest: ParsedChatRequest = {
+            request: { text: 'test message' },
+            parts: [new ParsedChatRequestTextPart({ start: 0, endExclusive: 'test message'.length }, 'test message')],
+            toolRequests: new Map(),
+            variables: []
+        };
+
+        const agent = chatService.getAgent(parsedRequest, session);
+        expect(agent).to.equal(mockHiddenAgent);
+    });
+
+    it('should resolve a hidden pinned agent when the request mentions that hidden agent', () => {
+        // A delegated request's text is '@<agentId> <prompt>'. The mention of a hidden agent does
+        // not resolve (mentions stay hidden-excluding), but the pin must still catch it.
+        const session = createMockSession(mockHiddenAgent);
+        const parsedRequest: ParsedChatRequest = {
+            request: { text: '@hidden-worker test' },
+            parts: [
+                new ParsedChatRequestAgentPart({ start: 0, endExclusive: '@hidden-worker'.length }, 'hidden-worker', 'hidden-worker'),
+                new ParsedChatRequestTextPart({ start: '@hidden-worker '.length, endExclusive: '@hidden-worker test'.length }, 'test')
+            ],
+            toolRequests: new Map(),
+            variables: []
+        };
+
+        const agent = chatService.getAgent(parsedRequest, session);
+        expect(agent).to.equal(mockHiddenAgent);
+    });
 });

package/src/common/chat-service-session-events.spec.ts

@@ -0,0 +1,161 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import { Container } from '@theia/core/shared/inversify';
+import {
+    ActiveSessionChangedEvent,
+    ChatServiceImpl,
+    DefaultChatAgentId,
+    PinChatAgent,
+    SessionCreatedEvent,
+    SessionDeletedEvent,
+    SessionRenamedEvent
+} from './chat-service';
+import { ChatAgentService } from './chat-agent-service';
+import { ChatRequestParser } from './chat-request-parser';
+import { AIVariableService, ToolInvocationRegistry } from '@theia/ai-core';
+import { ILogger } from '@theia/core';
+import { ChatContentDeserializerRegistry, ChatContentDeserializerRegistryImpl, DefaultChatContentDeserializerContribution } from './chat-content-deserializer';
+import { ChangeSetElementDeserializerRegistry, ChangeSetElementDeserializerRegistryImpl } from './change-set-element-deserializer';
+import { ChatAgent, ChatAgentLocation } from './chat-agents';
+import { ChatRequest } from './chat-model';
+import { ParsedChatRequest, ParsedChatRequestTextPart } from './parsed-chat-request';
+
+describe('ChatService session events', () => {
+    let chatService: ChatServiceImpl;
+    let container: Container;
+
+    const mockDefaultAgent: ChatAgent = {
+        id: 'default-agent',
+        name: 'Default Agent',
+        description: 'Test default agent',
+        locations: [ChatAgentLocation.Panel],
+        invoke: async () => { },
+        languageModelRequirements: [],
+        tags: [],
+        variables: [],
+        agentSpecificVariables: [],
+        functions: [],
+        prompts: []
+    };
+
+    class MockChatAgentService {
+        readonly onDidChangeAgents = { dispose: () => { } };
+        readonly onDefaultAgentChanged = { dispose: () => { } };
+
+        getAgent(id: string): ChatAgent | undefined {
+            return id === 'default-agent' ? mockDefaultAgent : undefined;
+        }
+
+        resolveAgent(): ChatAgent | undefined {
+            return mockDefaultAgent;
+        }
+    }
+
+    class MockChatRequestParser {
+        async parseChatRequest(request: ChatRequest): Promise<ParsedChatRequest> {
+            return {
+                request,
+                parts: [new ParsedChatRequestTextPart({ start: 0, endExclusive: request.text.length }, request.text)],
+                toolRequests: new Map(),
+                variables: []
+            };
+        }
+    }
+
+    class MockAIVariableService {
+        async resolveVariable(): Promise<unknown> {
+            return undefined;
+        }
+    }
+
+    class MockLogger {
+        error(): void { }
+        warn(): void { }
+        info(): void { }
+        debug(): void { }
+    }
+
+    beforeEach(() => {
+        container = new Container();
+
+        container.bind(ChatAgentService).toConstantValue(new MockChatAgentService() as unknown as ChatAgentService);
+        container.bind(ChatRequestParser).toConstantValue(new MockChatRequestParser() as unknown as ChatRequestParser);
+        container.bind(AIVariableService).toConstantValue(new MockAIVariableService() as unknown as AIVariableService);
+        container.bind(ToolInvocationRegistry).toConstantValue({});
+        container.bind(ILogger).toConstantValue(new MockLogger() as unknown as ILogger);
+
+        container.bind(DefaultChatAgentId).toConstantValue({ id: 'default-agent' });
+        container.bind(PinChatAgent).toConstantValue(true);
+
+        const contentRegistry = new ChatContentDeserializerRegistryImpl();
+        new DefaultChatContentDeserializerContribution().registerDeserializers(contentRegistry);
+        container.bind(ChatContentDeserializerRegistry).toConstantValue(contentRegistry);
+        container.bind(ChangeSetElementDeserializerRegistry).toConstantValue(new ChangeSetElementDeserializerRegistryImpl());
+        container.bind(ChatServiceImpl).toSelf().inSingletonScope();
+
+        chatService = container.get(ChatServiceImpl);
+    });
+
+    it('should fire a renamed event when sendRequest sets the session title', async () => {
+        const session = chatService.createSession(ChatAgentLocation.Panel);
+        expect(session.title).to.be.undefined;
+
+        const events: (ActiveSessionChangedEvent | SessionCreatedEvent | SessionDeletedEvent | SessionRenamedEvent)[] = [];
+        chatService.onSessionEvent(e => events.push(e));
+
+        await chatService.sendRequest(session.id, { text: 'Hello world' });
+
+        expect(session.title).to.equal('Hello world');
+        const renamedEvents = events.filter(e => e.type === 'renamed');
+        expect(renamedEvents).to.have.length(1);
+        expect((renamedEvents[0] as SessionRenamedEvent).sessionId).to.equal(session.id);
+    });
+
+    it('should not fire a renamed event on subsequent requests when title is already set', async () => {
+        const session = chatService.createSession(ChatAgentLocation.Panel);
+
+        // First request sets the title
+        await chatService.sendRequest(session.id, { text: 'First message' });
+        expect(session.title).to.equal('First message');
+
+        const events: (ActiveSessionChangedEvent | SessionCreatedEvent | SessionDeletedEvent | SessionRenamedEvent)[] = [];
+        chatService.onSessionEvent(e => events.push(e));
+
+        // Second request should not trigger a renamed event
+        await chatService.sendRequest(session.id, { text: 'Second message' });
+
+        const renamedEvents = events.filter(e => e.type === 'renamed');
+        expect(renamedEvents).to.have.length(0);
+        // Title should remain the first message
+        expect(session.title).to.equal('First message');
+    });
+
+    it('should fire a renamed event via renameSession', async () => {
+        const session = chatService.createSession(ChatAgentLocation.Panel);
+
+        const events: (ActiveSessionChangedEvent | SessionCreatedEvent | SessionDeletedEvent | SessionRenamedEvent)[] = [];
+        chatService.onSessionEvent(e => events.push(e));
+
+        await chatService.renameSession(session.id, 'New Title');
+
+        expect(session.title).to.equal('New Title');
+        const renamedEvents = events.filter(e => e.type === 'renamed');
+        expect(renamedEvents).to.have.length(1);
+        expect((renamedEvents[0] as SessionRenamedEvent).sessionId).to.equal(session.id);
+    });
+});

package/src/common/chat-service.spec.ts

@@ -0,0 +1,211 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Container } from '@theia/core/shared/inversify';
+import { ChatServiceImpl } from './chat-service';
+import { ChatAgentService } from './chat-agent-service';
+import { ChatSessionStore } from './chat-session-store';
+import { ChatContentDeserializerRegistry } from './chat-content-deserializer';
+import { ChangeSetElementDeserializerRegistry } from './change-set-element-deserializer';
+import { ToolInvocationRegistry, AIVariableService } from '@theia/ai-core';
+import { ILogger } from '@theia/core';
+import { ChatRequestParser } from './chat-request-parser';
+
+disableJSDOM();
+
+describe('ChatServiceImpl', () => {
+    let sandbox: sinon.SinonSandbox;
+    let chatService: ChatServiceImpl;
+    let mockSessionStore: sinon.SinonStubbedInstance<ChatSessionStore>;
+    let mockAgentService: sinon.SinonStubbedInstance<ChatAgentService>;
+    let mockDeserRegistry: sinon.SinonStubbedInstance<ChatContentDeserializerRegistry>;
+    let mockChangeSetDeserRegistry: sinon.SinonStubbedInstance<ChangeSetElementDeserializerRegistry>;
+    let mockToolInvocationRegistry: sinon.SinonStubbedInstance<ToolInvocationRegistry>;
+    let mockVariableService: sinon.SinonStubbedInstance<AIVariableService>;
+    let mockRequestParser: sinon.SinonStubbedInstance<ChatRequestParser>;
+    let mockLogger: sinon.SinonStubbedInstance<ILogger>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+
+        mockSessionStore = {
+            storeSessions: sandbox.stub().resolves(),
+            readSession: sandbox.stub().resolves(undefined) as never,
+            deleteSession: sandbox.stub().resolves() as never,
+            clearAllSessions: sandbox.stub().resolves() as never,
+            getSessionIndex: sandbox.stub().resolves({}) as never,
+            hasPersistedSessions: sandbox.stub().resolves(false) as never
+        };
+
+        mockAgentService = {
+            getAgent: sandbox.stub().returns(undefined),
+            getAgents: sandbox.stub().returns([]),
+            resolveAgent: sandbox.stub().returns(undefined)
+        } as sinon.SinonStubbedInstance<ChatAgentService>;
+
+        mockDeserRegistry = {
+            deserialize: sandbox.stub().resolves([])
+        } as sinon.SinonStubbedInstance<ChatContentDeserializerRegistry>;
+
+        mockChangeSetDeserRegistry = {
+            deserialize: sandbox.stub().resolves([])
+        } as sinon.SinonStubbedInstance<ChangeSetElementDeserializerRegistry>;
+
+        mockToolInvocationRegistry = {
+            getFunction: sandbox.stub().returns(undefined)
+        } as sinon.SinonStubbedInstance<ToolInvocationRegistry>;
+
+        mockVariableService = {
+            resolveVariable: sandbox.stub().resolves(undefined)
+        } as sinon.SinonStubbedInstance<AIVariableService>;
+
+        mockRequestParser = {
+            parseChatRequest: sandbox.stub().resolves({ parts: [], toolRequests: [], variables: [] })
+        } as sinon.SinonStubbedInstance<ChatRequestParser>;
+
+        mockLogger = {
+            debug: sandbox.stub(),
+            info: sandbox.stub(),
+            warn: sandbox.stub(),
+            error: sandbox.stub()
+        } as sinon.SinonStubbedInstance<ILogger>;
+
+        const container = new Container();
+        container.bind(ChatServiceImpl).toSelf().inSingletonScope();
+        container.bind(ChatAgentService).toConstantValue(mockAgentService);
+        container.bind(ChatSessionStore).toConstantValue(mockSessionStore);
+        container.bind(ChatContentDeserializerRegistry).toConstantValue(mockDeserRegistry);
+        container.bind(ChangeSetElementDeserializerRegistry).toConstantValue(mockChangeSetDeserRegistry);
+        container.bind(ToolInvocationRegistry).toConstantValue(mockToolInvocationRegistry);
+        container.bind(ChatRequestParser).toConstantValue(mockRequestParser);
+        container.bind(AIVariableService).toConstantValue(mockVariableService);
+        container.bind(ILogger).toConstantValue(mockLogger);
+
+        chatService = container.get(ChatServiceImpl);
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe('deleteSession', () => {
+        it('should delete child sessions when deleting a parent session', async () => {
+            // Create a parent session
+            const parentSession = chatService.createSession();
+
+            // Create a child session by directly setting rootSessionId
+            const childSession = chatService.createSession();
+            childSession.rootSessionId = parentSession.id;
+
+            // Delete the parent session
+            await chatService.deleteSession(parentSession.id);
+
+            // Verify parent session was deleted
+            expect(chatService.getSession(parentSession.id)).to.be.undefined;
+
+            // Verify child session was also deleted (cascade delete)
+            expect(chatService.getSession(childSession.id)).to.be.undefined;
+
+            // Verify deleteSession was called for both sessions
+            expect(mockSessionStore.deleteSession.callCount).to.equal(2);
+            expect(mockSessionStore.deleteSession.calledWith(parentSession.id)).to.be.true;
+            expect(mockSessionStore.deleteSession.calledWith(childSession.id)).to.be.true;
+        });
+
+        it('should handle multiple child sessions', async () => {
+            // Create a parent session
+            const parentSession = chatService.createSession();
+
+            // Create multiple child sessions
+            const child1 = chatService.createSession();
+            child1.rootSessionId = parentSession.id;
+            const child2 = chatService.createSession();
+            child2.rootSessionId = parentSession.id;
+            const child3 = chatService.createSession();
+            child3.rootSessionId = parentSession.id;
+
+            // Delete the parent session
+            await chatService.deleteSession(parentSession.id);
+
+            // Verify all sessions were deleted
+            expect(chatService.getSession(parentSession.id)).to.be.undefined;
+            expect(chatService.getSession(child1.id)).to.be.undefined;
+            expect(chatService.getSession(child2.id)).to.be.undefined;
+            expect(chatService.getSession(child3.id)).to.be.undefined;
+
+            // Verify deleteSession was called for all sessions
+            expect(mockSessionStore.deleteSession.callCount).to.equal(4);
+        });
+
+        it('should not delete sessions without rootSessionId', async () => {
+            // Create a standalone session
+            const standaloneSession = chatService.createSession();
+
+            // Delete it
+            await chatService.deleteSession(standaloneSession.id);
+
+            // Verify only that session was deleted
+            expect(chatService.getSession(standaloneSession.id)).to.be.undefined;
+            expect(mockSessionStore.deleteSession.callCount).to.equal(1);
+        });
+
+        it('should delete persisted-only child sessions that are not loaded in memory', async () => {
+            // Parent is in memory; the child exists only in the persisted index (e.g. after a reload).
+            const parentSession = chatService.createSession();
+            const persistedChildId = 'persisted-child-id';
+            mockSessionStore.getSessionIndex.resolves({
+                [persistedChildId]: {
+                    sessionId: persistedChildId,
+                    title: 'Persisted child',
+                    saveDate: 0,
+                    location: parentSession.model.location,
+                    rootSessionId: parentSession.id
+                }
+            });
+
+            await chatService.deleteSession(parentSession.id);
+
+            // Both the in-memory parent and the persisted-only child are removed from storage.
+            expect(mockSessionStore.deleteSession.calledWith(parentSession.id)).to.be.true;
+            expect(mockSessionStore.deleteSession.calledWith(persistedChildId)).to.be.true;
+        });
+
+        it('should not delete sessions with different rootSessionId', async () => {
+            // Create two independent sessions
+            const session1 = chatService.createSession();
+            const session2 = chatService.createSession();
+
+            // Set session2 as a child of a non-existent session
+            session2.rootSessionId = 'non-existent-session-id';
+
+            // Delete session1
+            await chatService.deleteSession(session1.id);
+
+            // Verify only session1 was deleted
+            expect(chatService.getSession(session1.id)).to.be.undefined;
+            expect(chatService.getSession(session2.id)).to.not.be.undefined;
+            expect(mockSessionStore.deleteSession.callCount).to.equal(1);
+            expect(mockSessionStore.deleteSession.calledWith(session1.id)).to.be.true;
+        });
+    });
+});

package/src/common/chat-service.ts

@@ -73,6 +73,8 @@ export interface ChatSession {
     pinnedAgent?: ChatAgent;
     /** ID of the root session in the delegation chain. For delegated sessions, this points to the topmost session where task contexts are stored. */
     rootSessionId?: string;
+    /** ID of the immediate parent session that delegated this one. Undefined for top-level sessions. */
+    parentSessionId?: string;
 }
 
 export interface ActiveSessionChangedEvent {
@@ -224,6 +226,43 @@ export class ChatServiceImpl implements ChatService {
     }
 
     async deleteSession(sessionId: string): Promise<void> {
+        await this.deleteSessionAndChildren(sessionId, new Set<string>());
+    }
+
+    protected async deleteSessionAndChildren(sessionId: string, visited: Set<string>): Promise<void> {
+        if (visited.has(sessionId)) {
+            return;
+        }
+        visited.add(sessionId);
+
+        // Delete children first. A child is any session whose immediate parent (parentSessionId) or root
+        // (rootSessionId) points to this session. Matching parentSessionId is what lets us cascade through
+        // intermediate levels: deleting B in A -> B -> C reaches C via its parentSessionId even though C's
+        // rootSessionId still points at A. Children may live only in memory, only in persisted storage
+        // (e.g. after a reload, not yet restored), or both, so collect ids from both sources. The visited
+        // set guards against cycles and re-deleting a child reachable from more than one ancestor.
+        const childIds = new Set<string>();
+        for (const s of this._sessions) {
+            if (s.parentSessionId === sessionId || s.rootSessionId === sessionId) {
+                childIds.add(s.id);
+            }
+        }
+        if (this.sessionStore) {
+            try {
+                const index = await this.sessionStore.getSessionIndex();
+                for (const metadata of Object.values(index)) {
+                    if (metadata.parentSessionId === sessionId || metadata.rootSessionId === sessionId) {
+                        childIds.add(metadata.sessionId);
+                    }
+                }
+            } catch (error) {
+                this.logger.error('Failed to read session index for cascade delete', { sessionId, error });
+            }
+        }
+        for (const childId of childIds) {
+            await this.deleteSessionAndChildren(childId, visited);
+        }
+
         const sessionIndex = this._sessions.findIndex(candidate => candidate.id === sessionId);
 
         // If session is in memory, remove it
@@ -351,6 +390,7 @@ export class ChatServiceImpl implements ChatService {
         }
         const requestText = request.request.displayText ?? request.request.text;
         session.title = requestText;
+        this.onSessionEventEmitter.fire({ type: 'renamed', sessionId: session.id });
         if (this.chatSessionNamingService) {
             const otherSessionNames = this._sessions.map(s => s.title).filter((title): title is string => title !== undefined);
             const namingService = this.chatSessionNamingService;
@@ -362,6 +402,7 @@ export class ChatServiceImpl implements ChatService {
                             session.title = name;
                             // Trigger persistence when title changes
                             this.saveSession(session.id);
+                            this.onSessionEventEmitter.fire({ type: 'renamed', sessionId: session.id });
                         }
                         didGenerateName = true;
                     }).catch(error => this.logger.error('Failed to generate chat session name', error));
@@ -411,8 +452,12 @@ export class ChatServiceImpl implements ChatService {
             return mentionedAgent;
         } else if (session.pinnedAgent) {
             // If we have a valid pinned agent, use it (pinned agent may become stale
-            // if it was disabled; so we always need to recheck)
-            const pinnedAgent = this.chatAgentService.getAgent(session.pinnedAgent.id);
+            // if it was disabled; so we always need to recheck). A pin is an explicit choice —
+            // e.g. AgentDelegationTool pins the delegated agent on the session it creates, and
+            // worker agents are often hidden (showInChat: false) — so hidden agents are honored
+            // here, while plain @-mentions above stay hidden-excluding. Without this, a request
+            // in a session pinned to a hidden agent silently falls back to the default agent.
+            const pinnedAgent = this.chatAgentService.getAgent(session.pinnedAgent.id, true);
             if (pinnedAgent) {
                 return pinnedAgent;
             }
@@ -458,9 +503,15 @@ export class ChatServiceImpl implements ChatService {
         // Store session with title, pinned agent info, last interaction timestamp, and error state
         const lastRequest = session.model.getRequests().at(-1);
         const hasError = lastRequest?.response.isComplete === true && lastRequest?.response.isError === true;
-        return this.sessionStore.storeSessions(
-            { model: session.model, title: session.title, pinnedAgentId: session.pinnedAgent?.id, lastInteraction: session.lastInteraction?.getTime(), hasError }
-        ).catch(error => {
+        return this.sessionStore.storeSessions({
+            model: session.model,
+            title: session.title,
+            pinnedAgentId: session.pinnedAgent?.id,
+            lastInteraction: session.lastInteraction?.getTime(),
+            hasError,
+            rootSessionId: session.rootSessionId,
+            parentSessionId: session.parentSessionId
+        }).catch(error => {
             this.logger.error('Failed to store chat sessions', error);
         });
     }
@@ -505,9 +556,10 @@ export class ChatServiceImpl implements ChatService {
         const model = new MutableChatModel(serialized.model);
         await this.restoreSessionData(model, serialized.model);
 
-        // Determine pinned agent
+        // Determine pinned agent (hidden agents included — a restored pin, like a live one,
+        // is an explicit choice; see getPinnedAgent)
         const pinnedAgent = serialized.pinnedAgentId
-            ? this.chatAgentService.getAgent(serialized.pinnedAgentId)
+            ? this.chatAgentService.getAgent(serialized.pinnedAgentId, true)
             : undefined;
 
         // Register as session
@@ -517,8 +569,12 @@ export class ChatServiceImpl implements ChatService {
             lastInteraction: new Date(serialized.saveDate),
             model,
             isActive: false,
-            pinnedAgent
+            pinnedAgent,
+            rootSessionId: serialized.rootSessionId,
+            parentSessionId: serialized.parentSessionId
         };
+        session.model.rootSessionId = serialized.rootSessionId;
+        session.model.parentSessionId = serialized.parentSessionId;
         this._sessions.push(session);
         this.setupAutoSaveForSession(session);
         this.onSessionEventEmitter.fire({ type: 'created', sessionId: session.id });