@nextclaw/ui 0.15.21 → 0.15.23

package/src/features/chat/managers/__tests__/chat-composer-intent.manager.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, vi } from "vitest";
+import { ChatComposerIntentManager } from "@/features/chat/managers/chat-composer-intent.manager";
+
+describe("ChatComposerIntentManager", () => {
+  it("delivers a file reference only to the targeted composer", () => {
+    const manager = new ChatComposerIntentManager();
+    const draftListener = vi.fn();
+    const sessionListener = vi.fn();
+    manager.subscribe(null, draftListener);
+    manager.subscribe("session-1", sessionListener);
+
+    manager.requestFileReference({
+      targetSessionKey: null,
+      tokenKey: "docs/guide.md",
+      label: "guide.md",
+    });
+
+    expect(draftListener).toHaveBeenCalledWith(
+      expect.objectContaining({
+        targetSessionKey: null,
+        tokenKey: "docs/guide.md",
+        label: "guide.md",
+      }),
+    );
+    expect(sessionListener).not.toHaveBeenCalled();
+  });
+
+  it("keeps an intent pending until its matching composer mounts", () => {
+    const manager = new ChatComposerIntentManager();
+    manager.requestFileReference({
+      targetSessionKey: " session-1 ",
+      tokenKey: " src/index.ts ",
+      label: " index.ts ",
+    });
+
+    expect(manager.consumePending(null)).toBeNull();
+    expect(manager.consumePending("session-1")).toMatchObject({
+      targetSessionKey: "session-1",
+      tokenKey: "src/index.ts",
+      label: "index.ts",
+    });
+    expect(manager.consumePending("session-1")).toBeNull();
+  });
+
+  it("ignores incomplete file references", () => {
+    const manager = new ChatComposerIntentManager();
+    const listener = vi.fn();
+    manager.subscribe(null, listener);
+
+    manager.requestFileReference({
+      targetSessionKey: null,
+      tokenKey: " ",
+      label: "README.md",
+    });
+
+    expect(listener).not.toHaveBeenCalled();
+    expect(manager.consumePending(null)).toBeNull();
+  });
+
+  it("publishes a source-aware excerpt with a stable content identity", () => {
+    const manager = new ChatComposerIntentManager();
+    const listener = vi.fn();
+    manager.subscribe("session-1", listener);
+
+    manager.requestExcerptReference({
+      targetSessionKey: "session-1",
+      path: "docs/guide.md",
+      label: "guide.md",
+      excerpt: "selected text",
+      startLine: 12,
+      endLine: 13,
+    });
+
+    expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+      kind: "workspace_excerpt",
+      path: "docs/guide.md",
+      label: "guide.md",
+      excerpt: "selected text",
+      startLine: 12,
+      endLine: 13,
+      tokenKey: expect.stringMatching(/^docs\/guide\.md#excerpt-/),
+    }));
+  });
+
+  it("delivers an excerpt to the unmaterialized new-chat composer", () => {
+    const manager = new ChatComposerIntentManager();
+    const draftListener = vi.fn();
+    manager.subscribe(null, draftListener);
+
+    manager.requestExcerptReference({
+      targetSessionKey: null,
+      path: "package.json",
+      label: "package.json",
+      excerpt: '"name": "nextclaw"',
+      startLine: 2,
+      endLine: 2,
+    });
+
+    expect(draftListener).toHaveBeenCalledWith(expect.objectContaining({
+      targetSessionKey: null,
+      kind: "workspace_excerpt",
+      path: "package.json",
+      excerpt: '"name": "nextclaw"',
+    }));
+  });
+});

package/src/features/chat/managers/__tests__/chat-session-list.manager.test.ts

@@ -55,6 +55,7 @@ function resetChatSessionListManagerState() {
   useChatThreadStore.setState({
     snapshot: {
       ...useChatThreadStore.getState().snapshot,
+      draftProjectRoot: null,
       workspacePanelParentKey: "session-1",
       activeWorkspacePanelKind: "child-session",
       activeChildSessionKey: "child-session-1",
@@ -70,6 +71,18 @@ function resetChatSessionListManagerState() {
 describe("ChatSessionListManager draft and selection flow", () => {
   beforeEach(resetChatSessionListManagerState);
 
+  it("clears the route-derived session selection outside session routes", () => {
+    const manager = new ChatSessionListManager(
+      {} as ConstructorParameters<typeof ChatSessionListManager>[0],
+    );
+
+    manager.syncRouteSessionSelection(null);
+
+    expect(
+      useChatSessionListStore.getState().snapshot.selectedSessionKey,
+    ).toBeNull();
+  });
+
   it("applies the requested session type when creating a session", () => {
     const uiManager = {
       goToChatRoot: vi.fn(),
@@ -93,7 +106,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
     });
     expect(
       useChatSessionListStore.getState().snapshot.selectedSessionKey,
-    ).toBeNull();
+    ).toBe("session-1");
     expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
     expect(
       useChatThreadStore.getState().snapshot.hasSubmittedDraftMessage,
@@ -109,7 +122,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
     } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0];
 
     const manager = new ChatSessionListManager(uiManager);
-    manager.startAgentDraftChat("researcher", "codex");
+    manager.startAgentDraftChat("researcher", "codex", "Create an agent");
 
     expect(uiManager.navigateTo).toHaveBeenCalledWith("/chat/draft", {
       replace: true,
@@ -117,7 +130,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
         chatDraft: {
           sessionType: "codex",
           projectRoot: null,
-          prompt: null,
+          prompt: "Create an agent",
         },
       },
     });
@@ -126,7 +139,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
     );
     expect(
       useChatSessionListStore.getState().snapshot.selectedSessionKey,
-    ).toBeNull();
+    ).toBe("session-1");
     expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
     expect(
       useChatThreadStore.getState().snapshot.hasSubmittedDraftMessage,
@@ -157,6 +170,41 @@ describe("ChatSessionListManager draft and selection flow", () => {
         },
       },
     });
+    expect(useChatThreadStore.getState().snapshot.draftProjectRoot).toBe(
+      "/tmp/project-alpha",
+    );
+  });
+
+  it("drops file tabs from an abandoned draft while preserving real session tabs", () => {
+    useChatThreadStore.getState().setSnapshot({
+      workspaceFileTabs: [
+        {
+          key: "draft::preview::old.md",
+          parentSessionKey: null,
+          path: "old.md",
+          viewMode: "preview",
+        },
+        {
+          key: "session-1::preview::kept.md",
+          parentSessionKey: "session-1",
+          path: "kept.md",
+          viewMode: "preview",
+        },
+      ],
+    });
+    const manager = new ChatSessionListManager({
+      navigateTo: vi.fn(),
+      isAtChatRoot: vi.fn(() => true),
+    } as unknown as ConstructorParameters<typeof ChatSessionListManager>[0]);
+
+    manager.createSession({ projectRoot: "/tmp/new-project" });
+
+    expect(useChatThreadStore.getState().snapshot.workspaceFileTabs).toEqual([
+      expect.objectContaining({
+        key: "session-1::preview::kept.md",
+        parentSessionKey: "session-1",
+      }),
+    ]);
   });
 
   it("carries an initial prompt through the draft route state", () => {
@@ -198,7 +246,7 @@ describe("ChatSessionListManager draft and selection flow", () => {
 
     expect(
       useChatSessionListStore.getState().snapshot.selectedSessionKey,
-    ).toBeNull();
+    ).toBe("session-1");
     expect(uiManager.navigateTo).toHaveBeenCalledWith(
       "/chat/draft",
       expect.any(Object),

package/src/features/chat/managers/__tests__/chat-thread-workspace.manager.test.ts

@@ -3,9 +3,11 @@ import { ChatThreadManager } from '@/features/chat/managers/chat-thread.manager'
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 
-function createUiManager(): ConstructorParameters<typeof ChatThreadManager>[0] {
+function createUiManager(overrides: Record<string, unknown> = {}): ConstructorParameters<typeof ChatThreadManager>[0] {
   return {
     goToSession: vi.fn(),
+    isAtChatRoot: vi.fn(() => true),
+    ...overrides,
   } as unknown as ConstructorParameters<typeof ChatThreadManager>[0];
 }
 
@@ -24,6 +26,8 @@ describe('ChatThreadManager workspace pages', () => {
         activeWorkspacePanelKind: null,
         activeChildSessionKey: null,
         activeWorkspaceFileKey: null,
+        draftProjectRoot: null,
+        workspaceFileTabs: [],
         closedWorkspaceTabEntries: [],
         workspaceNavigationHistory: [],
         workspaceNavigationHistoryIndex: 0,
@@ -75,6 +79,94 @@ describe('ChatThreadManager workspace pages', () => {
     });
   });
 
+  it('opens project files for a draft without exposing session-only pages', () => {
+    const manager = new ChatThreadManager(
+      createUiManager(),
+      {} as ConstructorParameters<typeof ChatThreadManager>[1],
+    );
+
+    manager.toggleWorkspacePanel(null);
+
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      workspacePanelParentKey: null,
+      activeWorkspacePanelKind: 'project-files',
+      workspaceNavigationHistory: [{ kind: 'project-files' }],
+    });
+  });
+
+  it('materializes the draft selection, workspace, and route as one owner action', () => {
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        draftProjectRoot: '/tmp/project-alpha',
+        workspacePanelParentKey: null,
+        activeWorkspacePanelKind: 'file',
+        activeWorkspaceFileKey: 'draft::preview::README.md',
+        workspaceFileTabs: [
+          {
+            key: 'draft::preview::README.md',
+            parentSessionKey: null,
+            path: 'README.md',
+            viewMode: 'preview',
+          },
+        ],
+        workspaceNavigationHistory: [
+          { kind: 'project-files' },
+          { kind: 'file', key: 'draft::preview::README.md' },
+        ],
+        workspaceNavigationHistoryIndex: 1,
+      },
+    });
+    const uiManager = createUiManager();
+    const syncRouteSessionSelection = vi.fn((sessionKey: string) => {
+      useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: sessionKey });
+      useChatThreadStore.getState().setSnapshot({ draftProjectRoot: null });
+    });
+    const manager = new ChatThreadManager(uiManager, {
+      syncRouteSessionSelection,
+    } as unknown as ConstructorParameters<typeof ChatThreadManager>[1]);
+
+    manager.materializeRootDraftSession('materialized-session');
+
+    expect(syncRouteSessionSelection).toHaveBeenCalledWith('materialized-session');
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      draftProjectRoot: null,
+      workspacePanelParentKey: 'materialized-session',
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey:
+        'materialized-session::preview::README.md',
+      workspaceFileTabs: [
+        expect.objectContaining({
+          key: 'materialized-session::preview::README.md',
+          parentSessionKey: 'materialized-session',
+        }),
+      ],
+      workspaceNavigationHistory: [
+        { kind: 'project-files' },
+        {
+          kind: 'file',
+          key: 'materialized-session::preview::README.md',
+        },
+      ],
+    });
+    expect(uiManager.goToSession).toHaveBeenCalledWith('materialized-session', {
+      replace: true,
+    });
+  });
+
+  it('ignores draft materialization after leaving the root route', () => {
+    const uiManager = createUiManager({ isAtChatRoot: vi.fn(() => false) });
+    const syncRouteSessionSelection = vi.fn();
+    const manager = new ChatThreadManager(uiManager, {
+      syncRouteSessionSelection,
+    } as unknown as ConstructorParameters<typeof ChatThreadManager>[1]);
+
+    manager.materializeRootDraftSession('materialized-session');
+
+    expect(syncRouteSessionSelection).not.toHaveBeenCalled();
+    expect(uiManager.goToSession).not.toHaveBeenCalled();
+  });
+
   it('does not close fixed workspace pages', () => {
     const manager = new ChatThreadManager(
       createUiManager(),

package/src/features/chat/managers/__tests__/chat-thread.manager.test.ts

@@ -836,7 +836,7 @@ describe('ChatThreadManager visible workspace selection', () => {
 });
 
 describe('ChatThreadManager deletion', () => {
-  it('clears the selected thread state after deleting the current session', async () => {
+  it('clears thread state while leaving route-derived selection to navigation', async () => {
     const removeQueries = vi.spyOn(appQueryClient, 'removeQueries').mockImplementation(async () => undefined);
     const uiManager = {
       goToSession: vi.fn(),
@@ -844,13 +844,7 @@ describe('ChatThreadManager deletion', () => {
       goToProviders: vi.fn(),
       confirm: vi.fn(async () => true),
     } as unknown as ConstructorParameters<typeof ChatThreadManager>[0];
-    const sessionListManager = {
-      setSelectedSessionKey: vi.fn((value: string | null) => {
-        useChatSessionListStore.getState().setSnapshot({
-          selectedSessionKey: value,
-        });
-      }),
-    } as unknown as ConstructorParameters<typeof ChatThreadManager>[1];
+    const sessionListManager = {} as ConstructorParameters<typeof ChatThreadManager>[1];
     const manager = new ChatThreadManager(
       uiManager,
       sessionListManager,
@@ -858,8 +852,7 @@ describe('ChatThreadManager deletion', () => {
 
     await manager.deleteSession();
 
-    expect(sessionListManager.setSelectedSessionKey).toHaveBeenCalledWith(null);
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('parent-session-1');
     expect(useChatThreadStore.getState().snapshot).toMatchObject({
       sessionKey: null,
       canDeleteSession: false,

package/src/features/chat/managers/__tests__/provider-model-catalog-notice.manager.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+  LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD,
+  ProviderModelCatalogNoticeManager,
+} from '@/features/chat/managers/provider-model-catalog-notice.manager';
+
+function buildOptions(providerId: string, count: number) {
+  return Array.from({ length: count }, (_, index) => ({
+    providerId,
+    value: `${providerId}/model-${index + 1}`,
+  }));
+}
+
+describe('ProviderModelCatalogNoticeManager', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+  });
+
+  it('treats a first large catalog as a browseable baseline and only surfaces later additions', () => {
+    const manager = new ProviderModelCatalogNoticeManager();
+    const initial = buildOptions('openrouter', LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD + 1);
+
+    expect(manager.filterUnseen(initial)).toEqual([]);
+    expect(manager.initializeLargeCatalogs(initial)).toBe(true);
+    expect(manager.filterUnseen([...initial, {
+      providerId: 'openrouter',
+      value: 'openrouter/new-after-baseline',
+    }])).toEqual([{
+      providerId: 'openrouter',
+      value: 'openrouter/new-after-baseline',
+    }]);
+  });
+
+  it('keeps small-catalog additions visible until the user marks the batch as seen', () => {
+    const manager = new ProviderModelCatalogNoticeManager();
+    const initial = buildOptions('opencode', 2);
+
+    expect(manager.filterUnseen(initial)).toEqual(initial);
+    expect(manager.acknowledge(initial)).toBe(true);
+    expect(manager.filterUnseen(initial)).toEqual([]);
+    expect(manager.filterUnseen([...initial, {
+      providerId: 'opencode',
+      value: 'opencode/new-after-seen',
+    }])).toEqual([{
+      providerId: 'opencode',
+      value: 'opencode/new-after-seen',
+    }]);
+  });
+
+  it('recovers from invalid persisted data without suppressing a small catalog', () => {
+    window.localStorage.setItem('nextclaw.chat.provider-model-catalog-notices', '{broken-json');
+    const manager = new ProviderModelCatalogNoticeManager();
+    const options = buildOptions('opencode', 1);
+
+    expect(manager.filterUnseen(options)).toEqual(options);
+  });
+});

package/src/features/chat/managers/chat-composer-intent.manager.ts

@@ -0,0 +1,145 @@
+import {
+  CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+  CHAT_WORKSPACE_FILE_TOKEN_KIND,
+} from "@nextclaw/shared";
+
+type ChatComposerReferenceIntentBase = {
+  id: number;
+  targetSessionKey: string | null;
+  tokenKey: string;
+  label: string;
+};
+
+export type ChatComposerFileReferenceIntent = ChatComposerReferenceIntentBase & {
+  kind: typeof CHAT_WORKSPACE_FILE_TOKEN_KIND;
+};
+
+export type ChatComposerExcerptReferenceIntent = ChatComposerReferenceIntentBase & {
+  kind: typeof CHAT_WORKSPACE_EXCERPT_TOKEN_KIND;
+  path: string;
+  excerpt: string;
+  startLine: number | null;
+  endLine: number | null;
+};
+
+export type ChatComposerReferenceIntent =
+  | ChatComposerFileReferenceIntent
+  | ChatComposerExcerptReferenceIntent;
+
+type ChatComposerReferenceRequest =
+  | Omit<ChatComposerFileReferenceIntent, "id">
+  | Omit<ChatComposerExcerptReferenceIntent, "id">;
+
+type ChatComposerIntentListener = (intent: ChatComposerReferenceIntent) => void;
+
+type ChatComposerIntentSubscription = {
+  targetSessionKey: string | null;
+  listener: ChatComposerIntentListener;
+};
+
+export class ChatComposerIntentManager {
+  private nextId = 0;
+  private pendingIntent: ChatComposerReferenceIntent | null = null;
+  private readonly subscriptions = new Set<ChatComposerIntentSubscription>();
+
+  private publish = (intent: ChatComposerReferenceRequest) => {
+    const id = this.nextId + 1;
+    const targetSessionKey = intent.targetSessionKey?.trim() || null;
+    const nextIntent: ChatComposerReferenceIntent = intent.kind === CHAT_WORKSPACE_FILE_TOKEN_KIND
+      ? { ...intent, id, targetSessionKey }
+      : { ...intent, id, targetSessionKey };
+    this.nextId = nextIntent.id;
+    this.pendingIntent = nextIntent;
+    this.subscriptions.forEach((subscription) => {
+      if (subscription.targetSessionKey === nextIntent.targetSessionKey) {
+        subscription.listener(nextIntent);
+      }
+    });
+  };
+
+  requestFileReference = (params: {
+    targetSessionKey: string | null;
+    tokenKey: string;
+    label: string;
+  }) => {
+    const tokenKey = params.tokenKey.trim();
+    const label = params.label.trim();
+    if (!tokenKey || !label) {
+      return;
+    }
+    this.publish({
+      kind: CHAT_WORKSPACE_FILE_TOKEN_KIND,
+      targetSessionKey: params.targetSessionKey?.trim() || null,
+      tokenKey,
+      label,
+    });
+  };
+
+  requestExcerptReference = (params: {
+    targetSessionKey: string | null;
+    path: string;
+    label: string;
+    excerpt: string;
+    startLine: number | null;
+    endLine: number | null;
+  }) => {
+    const {
+      endLine,
+      excerpt: rawExcerpt,
+      label: rawLabel,
+      path: rawPath,
+      startLine,
+      targetSessionKey,
+    } = params;
+    const path = rawPath.trim();
+    const label = rawLabel.trim();
+    const excerpt = rawExcerpt.trim();
+    if (!path || !label || !excerpt) {
+      return;
+    }
+    const identity = `${path}:${startLine ?? "x"}:${endLine ?? "x"}:${excerpt}`;
+    let hash = 2166136261;
+    for (let index = 0; index < identity.length; index += 1) {
+      hash ^= identity.charCodeAt(index);
+      hash = Math.imul(hash, 16777619);
+    }
+    this.publish({
+      kind: CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+      targetSessionKey,
+      tokenKey: `${path}#excerpt-${(hash >>> 0).toString(36)}`,
+      path,
+      label,
+      excerpt,
+      startLine,
+      endLine,
+    });
+  };
+
+  consumePending = (
+    targetSessionKey: string | null,
+  ): ChatComposerReferenceIntent | null => {
+    if (this.pendingIntent?.targetSessionKey !== targetSessionKey) {
+      return null;
+    }
+    const intent = this.pendingIntent;
+    this.pendingIntent = null;
+    return intent;
+  };
+
+  markConsumed = (intentId: number) => {
+    if (this.pendingIntent?.id === intentId) {
+      this.pendingIntent = null;
+    }
+  };
+
+  subscribe = (
+    targetSessionKey: string | null,
+    listener: ChatComposerIntentListener,
+  ) => {
+    const subscription = { targetSessionKey, listener };
+    this.subscriptions.add(subscription);
+    return () => {
+      this.subscriptions.delete(subscription);
+    };
+  };
+}

package/src/features/chat/managers/chat-session-list.manager.ts

@@ -36,10 +36,14 @@ function toggleListValue(values: string[], value: string): string[] {
 export class ChatSessionListManager {
   constructor(private uiManager: ChatUiManager) {}
 
-  private syncDraftThreadState = () => {
+  private syncDraftThreadState = (draftProjectRoot: string | null) => {
+    const workspaceFileTabs = useChatThreadStore
+      .getState()
+      .snapshot.workspaceFileTabs.filter((tab) => tab.parentSessionKey !== null);
     useChatThreadStore.getState().setSnapshot({
       sessionKey: null,
       sessionDisplayName: undefined,
+      draftProjectRoot,
       canDeleteSession: false,
       parentSessionKey: null,
       parentSessionLabel: null,
@@ -47,7 +51,9 @@ export class ChatSessionListManager {
       activeWorkspacePanelKind: null,
       childSessionTabs: [],
       activeChildSessionKey: null,
+      activeSideChatDraft: null,
       activeWorkspaceFileKey: null,
+      workspaceFileTabs,
       closedWorkspaceTabEntries: [],
       workspaceNavigationHistory: [],
       workspaceNavigationHistoryIndex: 0,
@@ -100,9 +106,8 @@ export class ChatSessionListManager {
     this.setSelectedAgentId(normalizedAgentId);
   };
 
-  setSelectedSessionKey = (next: SetStateAction<string | null>) => {
+  private setSelectedSessionKey = (value: string | null) => {
     const prev = useChatSessionListStore.getState().snapshot.selectedSessionKey;
-    const value = this.resolveUpdateValue(prev, next);
     if (value === prev) {
       return;
     }
@@ -111,23 +116,10 @@ export class ChatSessionListManager {
       .setSnapshot({ selectedSessionKey: value });
   };
 
-  syncRouteSessionSelection = (params: {
-    isChatView: boolean;
-    routeSessionKey: string | null;
-  }) => {
-    const { isChatView, routeSessionKey } = params;
-    if (!isChatView) {
-      return;
-    }
-    const { selectedSessionKey } = useChatSessionListStore.getState().snapshot;
+  syncRouteSessionSelection = (routeSessionKey: string | null) => {
+    this.setSelectedSessionKey(routeSessionKey);
     if (routeSessionKey) {
-      if (selectedSessionKey !== routeSessionKey) {
-        this.setSelectedSessionKey(routeSessionKey);
-      }
-      return;
-    }
-    if (selectedSessionKey !== null) {
-      this.setSelectedSessionKey(null);
+      useChatThreadStore.getState().setSnapshot({ draftProjectRoot: null });
     }
   };
 
@@ -207,10 +199,7 @@ export class ChatSessionListManager {
     );
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
     const normalizedPrompt = prompt?.trim() || null;
-    useChatSessionListStore.getState().setSnapshot({
-      selectedSessionKey: null,
-    });
-    this.syncDraftThreadState();
+    this.syncDraftThreadState(normalizedProjectRoot);
     this.uiManager.navigateTo(CHAT_DRAFT_SESSION_PATH, {
       replace: this.uiManager.isAtChatRoot(),
       state: {
@@ -223,9 +212,9 @@ export class ChatSessionListManager {
     });
   };
 
-  startAgentDraftChat = (agentId: string, sessionType: string): void => {
+  startAgentDraftChat = (agentId: string, sessionType: string, prompt?: string): void => {
     const normalizedAgentId = agentId.trim() || "main";
-    this.createSession({ sessionType });
+    this.createSession({ prompt, sessionType });
     this.setSelectedAgentId(normalizedAgentId);
   };