From e36c361c2d961e5183e22dce0a52cf4d6dacbc5f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=8B=E7=AB=9F?= <dingbingzhi.dbz@alibaba-inc.com>
Date: Mon, 3 Aug 2026 19:38:24 +0800
Subject: [PATCH 01/16] feat(web-shell): show channel sessions in sidebar

---
 ...08-03-web-shell-channel-session-sidebar.md | 40 ++++++++++++
 .../components/sidebar/WebShellSidebar.tsx    | 60 +++++++++++++-----
 ...WebShellSidebar.workspace-removal.test.tsx | 62 +++++++++++++++++++
 .../components/sidebar/WorkspaceSection.tsx   | 21 ++-----
 .../web-shell/client/e2e/utils/mockDaemon.ts  | 12 +++-
 .../client/e2e/web-shell.channels.spec.ts     | 48 ++++++++++++++
 packages/web-shell/client/i18n.tsx            |  6 ++
 7 files changed, 214 insertions(+), 35 deletions(-)
 create mode 100644 docs/design/2026-08-03-web-shell-channel-session-sidebar.md

diff --git a/docs/design/2026-08-03-web-shell-channel-session-sidebar.md b/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
new file mode 100644
index 00000000000..0bbf0e498a0
--- /dev/null
+++ b/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
@@ -0,0 +1,40 @@
+# Web Shell channel sessions in the sidebar
+
+## Motivation
+
+Daemon-managed channels create ordinary workspace sessions with
+`sourceType: "channel"`, but the Web Shell sidebar intentionally requests only
+the `default` session catalog. A session started from DingTalk, Feishu, or
+another channel therefore cannot be opened from the sidebar even though it is
+stored in the selected workspace.
+
+## Design
+
+Add a two-option source switch above the sidebar's project session list:
+
+- **Tasks** lists `sourceType: "default"` and remains the initial selection.
+- **Channels** lists `sourceType: "channel"`.
+
+The switch is shown only when the daemon advertises
+`session_source_metadata`. Older daemons keep the current unfiltered request
+and do not show a control they cannot support.
+
+The selected source is applied consistently to active, pinned, archived, and
+secondary-workspace session requests. Existing session rows, workspace
+sections, grouping, search, polling, and open-session actions are reused.
+
+## Boundaries
+
+- Channel configuration and runtime management are unchanged.
+- Session source metadata and daemon list APIs are unchanged.
+- Session Overview and Split View keep their existing default-session scope.
+- The switch is in-memory UI state and resets to Tasks on page reload.
+
+## Verification
+
+- Assert the source switch is gated by `session_source_metadata`.
+- Assert Tasks is initially selected and requests `sourceType: "default"`.
+- Assert selecting Channels requests `sourceType: "channel"` for primary and
+  workspace-qualified lists.
+- Run the sidebar and workspace-section unit tests, Web Shell build, and
+  TypeScript typecheck.
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index dadcda720f3..1169619ebb0 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -35,6 +35,8 @@ import {
   ChevronRightIcon,
   Columns2Icon,
   LayoutGridIcon,
+  ListTodoIcon,
+  MessageCircleIcon,
   EllipsisVerticalIcon,
   ArchiveIcon,
   ArchiveRestoreIcon,
@@ -60,6 +62,7 @@ import { WebShellThemeId, type WebShellTheme } from '../../themeContext';
 import { useI18n } from '../../i18n';
 import { Input } from '../ui/input';
 import { Button } from '../ui/button';
+import { Tabs, TabsList, TabsTrigger } from '../ui/tabs';
 import { Field, FieldGroup, FieldLabel } from '../ui/field';
 import {
   Select,
@@ -90,7 +93,6 @@ import {
 import {
   SESSION_LIST_PAGE_SIZE,
   SESSION_ORGANIZATION_FEATURE,
-  WEB_SHELL_SESSION_SOURCE_TYPE,
 } from '../../constants/sessions';
 import styles from './WebShellSidebar.module.css';
 
@@ -114,6 +116,8 @@ const GROUP_MENU_MARGIN = 8;
 const CUSTOM_GROUP_COLOR_OPTION = '__custom__';
 const DEFAULT_CUSTOM_GROUP_COLOR: DaemonSessionGroupHexColor = '#416ef5';
 
+type SidebarSessionSource = 'default' | 'channel';
+
 function getSessionIdentity(
   sessionId: string,
   workspaceCwd: string | undefined,
@@ -565,6 +569,11 @@ export function WebShellSidebar({
   const sourceMetadataEnabled = Boolean(
     connection.capabilities?.features?.includes('session_source_metadata'),
   );
+  const [sessionSource, setSessionSource] =
+    useState<SidebarSessionSource>('default');
+  const selectedSessionSource = sourceMetadataEnabled
+    ? sessionSource
+    : undefined;
   const sessionArchiveEnabled = Boolean(
     connection.capabilities?.features?.includes('session_archive'),
   );
@@ -606,9 +615,7 @@ export function WebShellSidebar({
     enabled: includePrimaryWorkspaceSessions,
     pageSize: SESSION_LIST_PAGE_SIZE,
     archiveState: 'active',
-    ...(sourceMetadataEnabled
-      ? { sourceType: WEB_SHELL_SESSION_SOURCE_TYPE }
-      : {}),
+    ...(selectedSessionSource ? { sourceType: selectedSessionSource } : {}),
     ...(organizationEnabled
       ? { view: 'organized' as const, group: 'all' }
       : {}),
@@ -629,9 +636,7 @@ export function WebShellSidebar({
       enabled: organizationEnabled && includePrimaryWorkspaceSessions,
       pageSize: SESSION_LIST_PAGE_SIZE,
       archiveState: 'active',
-      ...(sourceMetadataEnabled
-        ? { sourceType: WEB_SHELL_SESSION_SOURCE_TYPE }
-        : {}),
+      ...(selectedSessionSource ? { sourceType: selectedSessionSource } : {}),
       view: 'organized',
       group: 'pinned',
     });
@@ -655,9 +660,7 @@ export function WebShellSidebar({
       includePrimaryWorkspaceSessions,
     pageSize: SESSION_LIST_PAGE_SIZE,
     archiveState: 'archived',
-    ...(sourceMetadataEnabled
-      ? { sourceType: WEB_SHELL_SESSION_SOURCE_TYPE }
-      : {}),
+    ...(selectedSessionSource ? { sourceType: selectedSessionSource } : {}),
     ...(organizationEnabled
       ? { view: 'organized' as const, group: 'all' }
       : {}),
@@ -1065,8 +1068,8 @@ export function WebShellSidebar({
           .listWorkspaceSessions({
             pageSize: SESSION_LIST_PAGE_SIZE,
             archiveState: 'active',
-            ...(sourceMetadataEnabled
-              ? { sourceType: WEB_SHELL_SESSION_SOURCE_TYPE }
+            ...(selectedSessionSource
+              ? { sourceType: selectedSessionSource }
               : {}),
             view: 'organized',
             group: 'pinned',
@@ -1090,7 +1093,7 @@ export function WebShellSidebar({
   }, [
     displayedWorkspaces,
     organizationEnabled,
-    sourceMetadataEnabled,
+    selectedSessionSource,
     workspace.client,
     workspaceSessionsReloadToken,
   ]);
@@ -1142,8 +1145,8 @@ export function WebShellSidebar({
           .listWorkspaceSessions({
             pageSize: SESSION_LIST_PAGE_SIZE,
             archiveState: 'archived',
-            ...(sourceMetadataEnabled
-              ? { sourceType: WEB_SHELL_SESSION_SOURCE_TYPE }
+            ...(selectedSessionSource
+              ? { sourceType: selectedSessionSource }
               : {}),
             ...(organizationEnabled
               ? { view: 'organized' as const, group: 'all' }
@@ -1185,7 +1188,7 @@ export function WebShellSidebar({
     organizationEnabled,
     secondaryArchivedReloadToken,
     sessionArchiveEnabled,
-    sourceMetadataEnabled,
+    selectedSessionSource,
     workspace.client,
     workspaceQualifiedRestCoreEnabled,
     workspaceSessionsReloadToken,
@@ -4073,6 +4076,29 @@ export function WebShellSidebar({
         </div>
         <div className={styles.body}>
           <div className={styles.sessionList}>
+            {!collapsed && sourceMetadataEnabled && (
+              <Tabs
+                className="px-2 pb-2"
+                value={sessionSource}
+                onValueChange={(value) =>
+                  setSessionSource(value as SidebarSessionSource)
+                }
+              >
+                <TabsList
+                  className="w-full"
+                  aria-label={t('sidebar.sessionSource')}
+                >
+                  <TabsTrigger value="default">
+                    <ListTodoIcon />
+                    {t('sidebar.sessionSource.tasks')}
+                  </TabsTrigger>
+                  <TabsTrigger value="channel">
+                    <MessageCircleIcon />
+                    {t('sidebar.sessionSource.channels')}
+                  </TabsTrigger>
+                </TabsList>
+              </Tabs>
+            )}
             {!collapsed && pinnedSessions.length > 0 && (
               <>
                 <div className={styles.projectsHeader}>
@@ -4182,7 +4208,7 @@ export function WebShellSidebar({
                             noSessionsLabel={t('sidebar.noSessions')}
                             loadErrorLabel={t('sidebar.loadFailed')}
                             organizationEnabled={organizationEnabled}
-                            sourceMetadataEnabled={sourceMetadataEnabled}
+                            sourceType={selectedSessionSource}
                             ungroupedLabel={t('sidebar.groupUngrouped')}
                             onRenameGroup={
                               canOrganizeWorkspace(ws.cwd)
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 429c77e3306..7fdfbb13100 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -2890,6 +2890,68 @@ describe('WebShellSidebar primary workspace header', () => {
   });
 });
 
+describe('WebShellSidebar session source switch', () => {
+  it('switches primary and workspace-qualified lists from tasks to channels', async () => {
+    renderSidebar();
+
+    const sourceTabs = Array.from(
+      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
+    );
+    const tasksTab = sourceTabs.find(
+      (button) => button.textContent?.trim() === 'Tasks',
+    );
+    const channelsTab = sourceTabs.find(
+      (button) => button.textContent?.trim() === 'Channels',
+    );
+    expect(tasksTab?.getAttribute('data-state')).toBe('active');
+    expect(channelsTab).toBeDefined();
+    expect(
+      useSessions.mock.calls.some(
+        ([options]) => options?.sourceType === 'default',
+      ),
+    ).toBe(true);
+
+    await act(async () => {
+      channelsTab!.dispatchEvent(
+        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
+      );
+      channelsTab!.click();
+      await Promise.resolve();
+    });
+
+    expect(channelsTab?.getAttribute('data-state')).toBe('active');
+    expect(
+      useSessions.mock.calls.some(
+        ([options]) => options?.sourceType === 'channel',
+      ),
+    ).toBe(true);
+
+    await expandWorkspace('other');
+    expect(
+      listWorkspaceSessions.mock.calls.some(
+        ([options]) => options?.sourceType === 'channel',
+      ),
+    ).toBe(true);
+  });
+
+  it('hides the switch and keeps legacy session requests unfiltered', () => {
+    connection.capabilities = {
+      ...capabilities,
+      features: capabilities.features.filter(
+        (feature) => feature !== 'session_source_metadata',
+      ),
+    };
+    renderSidebar();
+
+    expect(container.querySelector('[aria-label="Session source"]')).toBeNull();
+    expect(
+      useSessions.mock.calls.every(
+        ([options]) => options?.sourceType === undefined,
+      ),
+    ).toBe(true);
+  });
+});
+
 describe('WebShellSidebar archived session export', () => {
   const exportResult = {
     content: '<p>exported</p>',
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index cf78062db78..172a4064345 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -17,10 +17,7 @@ import { FolderClosedIcon, FolderOpenIcon } from 'lucide-react';
 import { GitBranchIndicator } from '../GitBranchIndicator';
 import { BranchPickerPopover } from '../BranchPickerPopover';
 import { useI18n } from '../../i18n';
-import {
-  SESSION_LIST_PAGE_SIZE,
-  WEB_SHELL_SESSION_SOURCE_TYPE,
-} from '../../constants/sessions';
+import { SESSION_LIST_PAGE_SIZE } from '../../constants/sessions';
 import {
   readWorkspaceCollapsedGroupIds,
   writeWorkspaceCollapsedGroupIds,
@@ -71,7 +68,7 @@ interface WorkspaceSectionProps {
   noSessionsLabel: string;
   loadErrorLabel: string;
   organizationEnabled: boolean;
-  sourceMetadataEnabled?: boolean;
+  sourceType?: string;
   ungroupedLabel: string;
   formatTime: (iso: string) => string;
   searchQuery?: string;
@@ -113,7 +110,7 @@ export function WorkspaceSection({
   noSessionsLabel,
   loadErrorLabel,
   organizationEnabled,
-  sourceMetadataEnabled = false,
+  sourceType,
   ungroupedLabel,
   formatTime,
   searchQuery = '',
@@ -172,9 +169,7 @@ export function WorkspaceSection({
         .listWorkspaceSessions({
           pageSize: SESSION_LIST_PAGE_SIZE,
           archiveState: 'active',
-          ...(sourceMetadataEnabled
-            ? { sourceType: WEB_SHELL_SESSION_SOURCE_TYPE }
-            : {}),
+          ...(sourceType ? { sourceType } : {}),
           ...(organizationEnabled
             ? { view: 'organized' as const, group: 'all' }
             : {}),
@@ -187,13 +182,7 @@ export function WorkspaceSection({
       console.warn('[WorkspaceSection] session poll failed:', err);
       setLoadError(true);
     }
-  }, [
-    client,
-    disabled,
-    organizationEnabled,
-    sourceMetadataEnabled,
-    workspace.cwd,
-  ]);
+  }, [client, disabled, organizationEnabled, sourceType, workspace.cwd]);
 
   useEffect(() => {
     if (!renderSessions || disabled || !organizationEnabled) {
diff --git a/packages/web-shell/client/e2e/utils/mockDaemon.ts b/packages/web-shell/client/e2e/utils/mockDaemon.ts
index 7f63408ad4c..12b4a713215 100644
--- a/packages/web-shell/client/e2e/utils/mockDaemon.ts
+++ b/packages/web-shell/client/e2e/utils/mockDaemon.ts
@@ -823,10 +823,18 @@ async function handleDaemonRoute(
     // `group=all` (and missing group) returns the full active list. The UI
     // excludes pinned rows from organized sections via `excludePinned`.
     const group = searchParams.get('group');
+    const sourceType = searchParams.get('sourceType');
+    const sourceSessions = sourceType
+      ? scenario.sessions.filter(
+          (session) =>
+            session.sourceType === sourceType ||
+            (sourceType === 'default' && session.sourceType === undefined),
+        )
+      : scenario.sessions;
     const sessions =
       group === 'pinned'
-        ? scenario.sessions.filter((session) => Boolean(session.isPinned))
-        : scenario.sessions;
+        ? sourceSessions.filter((session) => Boolean(session.isPinned))
+        : sourceSessions;
     await json(route, { sessions });
     return;
   }
diff --git a/packages/web-shell/client/e2e/web-shell.channels.spec.ts b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
index 07df572ee23..147d058e357 100644
--- a/packages/web-shell/client/e2e/web-shell.channels.spec.ts
+++ b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
@@ -11,6 +11,54 @@ import {
   replayCompleteEvent,
 } from './utils/mockDaemon';
 
+test('shows channel sessions in the sidebar channel catalog', async ({
+  page,
+}, testInfo) => {
+  const scenario = createWebShellDaemonScenario({
+    capabilities: {
+      features: [
+        'session_events',
+        'permission_vote',
+        'session_permission_vote',
+        'session_scope_override',
+        'session_source_metadata',
+      ],
+    },
+    sessions: [
+      {
+        sessionId: 'task-session',
+        displayName: 'Web Shell task',
+        sourceType: 'default',
+      },
+      {
+        sessionId: 'dingtalk-session',
+        displayName: 'DingTalk conversation',
+        sourceType: 'channel',
+        sourceId: 'release-bot',
+      },
+    ],
+  });
+  const daemon = await installMockDaemon(page, scenario, {
+    baseURL: String(testInfo.project.use.baseURL),
+  });
+
+  await page.goto(`/session/${encodeURIComponent(scenario.sessionId)}`);
+  await expect(page.locator('[data-web-shell-root]')).toBeVisible();
+  const connection = await daemon.sse.waitForConnection(scenario.sessionId);
+  await daemon.sendEvent(
+    replayCompleteEvent({ sessionId: connection.sessionId }),
+  );
+  await expect(page.getByText('Loading...')).toHaveCount(0);
+
+  await expect(page.getByText('Web Shell task', { exact: true })).toBeVisible();
+  await expect(page.getByText('DingTalk conversation')).toHaveCount(0);
+  await page.getByRole('tab', { name: 'Channels' }).click();
+  await expect(
+    page.getByText('DingTalk conversation', { exact: true }),
+  ).toBeVisible();
+  await expect(page.getByText('Web Shell task')).toHaveCount(0);
+});
+
 test('creates and deletes a typed Channel configuration', async ({
   page,
 }, testInfo) => {
diff --git a/packages/web-shell/client/i18n.tsx b/packages/web-shell/client/i18n.tsx
index 825dfaf179c..8629ee019ef 100644
--- a/packages/web-shell/client/i18n.tsx
+++ b/packages/web-shell/client/i18n.tsx
@@ -1072,6 +1072,9 @@ const EN: Messages = {
   'sidebar.newWorktreeTask': 'New worktree task',
   'sidebar.plugins': 'Plugins',
   'sidebar.channels': 'Channels',
+  'sidebar.sessionSource': 'Session source',
+  'sidebar.sessionSource.tasks': 'Tasks',
+  'sidebar.sessionSource.channels': 'Channels',
   'sidebar.project': 'Project',
   'sidebar.pinnedSessions': 'Pinned',
   'sidebar.workspaceSelectLabel': 'Workspace',
@@ -3694,6 +3697,9 @@ const ZH: Messages = {
   'sidebar.newWorktreeTask': '新建 Worktree 任务',
   'sidebar.plugins': '插件',
   'sidebar.channels': '频道',
+  'sidebar.sessionSource': '会话来源',
+  'sidebar.sessionSource.tasks': '任务',
+  'sidebar.sessionSource.channels': '频道',
   'sidebar.project': '项目',
   'sidebar.pinnedSessions': '置顶',
   'sidebar.workspaceSelectLabel': '工作区',

From b71723b5ab7ce76b3746b906c23597f42b8921c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=8B=E7=AB=9F?= <dingbingzhi.dbz@alibaba-inc.com>
Date: Mon, 3 Aug 2026 22:48:19 +0800
Subject: [PATCH 02/16] feat(web-shell): configure channel session scope

---
 ...6-08-03-web-shell-channel-session-scope.md | 40 +++++++++++++
 .../commands/channel/channel-registry.test.ts | 21 +++++++
 .../src/commands/channel/channel-registry.ts  | 38 +++++++++++--
 .../src/serve/channel-settings-store.test.ts  | 22 +++++++
 .../cli/src/serve/channel-settings-store.ts   |  2 +-
 .../channels/ChannelEditorDialog.test.tsx     | 22 +++++++
 .../channels/ChannelEditorDialog.tsx          | 57 ++++++++++++++++---
 .../channels/channel-editor-state.test.ts     | 23 ++++++++
 .../channels/channel-editor-state.ts          |  4 +-
 .../client/e2e/web-shell.channels.spec.ts     | 17 ++++++
 packages/web-shell/client/i18n.tsx            | 17 ++++++
 11 files changed, 247 insertions(+), 16 deletions(-)
 create mode 100644 docs/design/2026-08-03-web-shell-channel-session-scope.md

diff --git a/docs/design/2026-08-03-web-shell-channel-session-scope.md b/docs/design/2026-08-03-web-shell-channel-session-scope.md
new file mode 100644
index 00000000000..e3f5b7642dd
--- /dev/null
+++ b/docs/design/2026-08-03-web-shell-channel-session-scope.md
@@ -0,0 +1,40 @@
+# Web Shell channel session scope
+
+## Motivation
+
+Channel runtimes already route incoming messages according to `sessionScope`,
+but the Web Shell channel editor only renders platform-specific management
+fields. Users can therefore configure credentials and access policy, but cannot
+choose which conversations share an agent session.
+
+## Design
+
+Add the existing shared `sessionScope` setting to every manageable channel type
+in the daemon channel catalog. Preserve a plugin-provided field when one exists;
+otherwise advertise an enum with the runtime-supported values and the plugin's
+default scope.
+
+Render the field in a dedicated session section of the channel editor. New and
+legacy configurations show their effective default, and saving writes the
+selected value through the existing channel upsert request.
+
+The available scopes are:
+
+- `user`: one session per sender and chat.
+- `thread`: one session per routing thread, falling back to the chat.
+- `chat_thread`: one session per chat and nested thread.
+- `single`: one session shared by the entire channel instance.
+
+## Compatibility
+
+The runtime router and persisted configuration format are unchanged. Existing
+configurations without `sessionScope` retain their current plugin default until
+they are edited and saved. Unmanageable channel types do not advertise the
+field.
+
+## Verification
+
+- Assert catalog defaults for DingTalk and GitHub.
+- Assert the management store accepts every runtime-supported scope.
+- Assert new and legacy editor drafts use the effective default.
+- Verify the Web Shell can select and persist a non-default scope end to end.
diff --git a/packages/cli/src/commands/channel/channel-registry.test.ts b/packages/cli/src/commands/channel/channel-registry.test.ts
index 5b68d249a8e..7ddfc2e91ed 100644
--- a/packages/cli/src/commands/channel/channel-registry.test.ts
+++ b/packages/cli/src/commands/channel/channel-registry.test.ts
@@ -26,6 +26,16 @@ describe('channel registry', () => {
         required: true,
       }),
     );
+    expect(
+      catalog.find((entry) => entry.type === 'dingtalk')?.fields,
+    ).toContainEqual(
+      expect.objectContaining({
+        key: 'sessionScope',
+        kind: 'enum',
+        required: true,
+        default: 'user',
+      }),
+    );
     for (const type of ['github', 'gitlab'] as const) {
       const fields = catalog.find((entry) => entry.type === type)?.fields;
       expect(fields).toContainEqual(
@@ -56,6 +66,17 @@ describe('channel registry', () => {
         }),
       );
     }
+    expect(
+      catalog.find((entry) => entry.type === 'github')?.fields,
+    ).toContainEqual(
+      expect.objectContaining({
+        key: 'sessionScope',
+        default: 'chat_thread',
+      }),
+    );
+    expect(
+      catalog.find((entry) => entry.type === 'telegram')?.fields,
+    ).not.toContainEqual(expect.objectContaining({ key: 'sessionScope' }));
     expect(JSON.stringify(catalog)).not.toContain('createChannel');
   });
 });
diff --git a/packages/cli/src/commands/channel/channel-registry.ts b/packages/cli/src/commands/channel/channel-registry.ts
index 090b5540334..e26c36ddd44 100644
--- a/packages/cli/src/commands/channel/channel-registry.ts
+++ b/packages/cli/src/commands/channel/channel-registry.ts
@@ -1,6 +1,7 @@
 import type {
   ChannelConfigFieldDescriptor,
   ChannelPlugin,
+  SessionScope,
 } from '@qwen-code/channel-base';
 
 export interface ChannelTypeDescriptor {
@@ -13,6 +14,16 @@ export interface ChannelTypeDescriptor {
 const registry = new Map<string, ChannelPlugin>();
 let builtinsPromise: Promise<void> | null = null;
 
+const SESSION_SCOPE_OPTIONS: ReadonlyArray<{
+  value: SessionScope;
+  label: string;
+}> = [
+  { value: 'user', label: 'Per user and chat' },
+  { value: 'thread', label: 'Per thread' },
+  { value: 'chat_thread', label: 'Per chat and thread' },
+  { value: 'single', label: 'One shared session' },
+];
+
 function ensureBuiltins(): Promise<void> {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
@@ -69,12 +80,29 @@ export async function supportedChannelCatalog(): Promise<
   ChannelTypeDescriptor[]
 > {
   await ensureBuiltins();
-  return [...registry.values()].map(
-    ({ channelType, displayName, management }) => ({
+  return [...registry.values()].map((plugin) => {
+    const { channelType, displayName, management } = plugin;
+    const fields = management?.fields ?? [];
+    return {
       type: channelType,
       displayName,
       manageable: management !== undefined,
-      fields: management?.fields ?? [],
-    }),
-  );
+      fields:
+        management && !fields.some((field) => field.key === 'sessionScope')
+          ? [
+              ...fields,
+              {
+                key: 'sessionScope',
+                label: 'Session scope',
+                kind: 'enum',
+                required: true,
+                default: plugin.defaultSessionScope ?? 'user',
+                description:
+                  'Controls which incoming conversations share one agent session.',
+                options: SESSION_SCOPE_OPTIONS,
+              },
+            ]
+          : fields,
+    };
+  });
 }
diff --git a/packages/cli/src/serve/channel-settings-store.test.ts b/packages/cli/src/serve/channel-settings-store.test.ts
index 07ada91ee78..e647045fbfd 100644
--- a/packages/cli/src/serve/channel-settings-store.test.ts
+++ b/packages/cli/src/serve/channel-settings-store.test.ts
@@ -169,6 +169,28 @@ describe('WorkspaceChannelSettingsStore', () => {
     ).toBe('$BOT_TOKEN');
   });
 
+  it('accepts chat-and-thread session scope', async () => {
+    const store = new WorkspaceChannelSettingsStore(workspace);
+
+    await store.upsert('bot', {
+      expectedRevision: store.snapshot().revision,
+      config: {
+        type: 'management-validation-test',
+        clientId: 'client-id',
+        sessionScope: 'chat_thread',
+      },
+    });
+
+    expect(
+      (
+        readWorkspaceSettings()['channels'] as Record<
+          string,
+          Record<string, unknown>
+        >
+      )['bot']?.['sessionScope'],
+    ).toBe('chat_thread');
+  });
+
   it('replaces and clears secrets only through explicit operations', async () => {
     writeWorkspaceSettings(`{
   "$version": 4,
diff --git a/packages/cli/src/serve/channel-settings-store.ts b/packages/cli/src/serve/channel-settings-store.ts
index d4458fc302b..70a6168fd60 100644
--- a/packages/cli/src/serve/channel-settings-store.ts
+++ b/packages/cli/src/serve/channel-settings-store.ts
@@ -143,7 +143,7 @@ function assertSharedField(key: string, value: unknown): boolean {
     senderPolicy: new Set(['allowlist', 'pairing', 'open']),
     dmPolicy: new Set(['open', 'disabled']),
     groupPolicy: new Set(['disabled', 'allowlist', 'open']),
-    sessionScope: new Set(['user', 'thread', 'single']),
+    sessionScope: new Set(['user', 'thread', 'chat_thread', 'single']),
     dispatchMode: new Set(['steer', 'followup', 'collect']),
     blockStreaming: new Set(['on', 'off']),
   };
diff --git a/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx b/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx
index 07054c667c2..7069ef000e2 100644
--- a/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx
+++ b/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx
@@ -33,6 +33,19 @@ const DINGTALK: DaemonChannelTypeDescriptor = {
       kind: 'secret',
       required: true,
     },
+    {
+      key: 'sessionScope',
+      label: 'Session scope',
+      kind: 'enum',
+      required: true,
+      default: 'user',
+      options: [
+        { value: 'user', label: 'Per user and chat' },
+        { value: 'thread', label: 'Per thread' },
+        { value: 'chat_thread', label: 'Per chat and thread' },
+        { value: 'single', label: 'One shared session' },
+      ],
+    },
   ],
 };
 
@@ -152,6 +165,14 @@ describe('ChannelEditorDialog', () => {
     expect(clear).toBeDefined();
   });
 
+  it('shows the effective session scope in its own section', async () => {
+    await renderDialog({ instance: INSTANCE });
+
+    expect(document.body.textContent).toContain('Session');
+    expect(document.body.textContent).toContain('Session scope');
+    expect(document.body.textContent).toContain('Per user and chat');
+  });
+
   it('submits a new instance with typed fields and the current revision', async () => {
     const onSave = vi.fn().mockResolvedValue(undefined);
     await renderDialog({ onSave });
@@ -181,6 +202,7 @@ describe('ChannelEditorDialog', () => {
       config: {
         type: 'dingtalk',
         clientId: 'ding-client-id',
+        sessionScope: 'user',
         senderPolicy: 'pairing',
       },
       secrets: {
diff --git a/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx b/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx
index 75326c5dfdf..804b87abf52 100644
--- a/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx
+++ b/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx
@@ -91,6 +91,10 @@ const FIELD_LABEL_KEYS: Record<string, Record<string, string>> = {
   },
 };
 
+const COMMON_FIELD_LABEL_KEYS: Record<string, string> = {
+  sessionScope: 'channels.editor.field.sessionScope',
+};
+
 export interface ChannelEditorDialogProps {
   open: boolean;
   descriptor: DaemonChannelTypeDescriptor;
@@ -204,13 +208,17 @@ export function ChannelEditorDialog({
     setSubmitError(undefined);
   }, [descriptor, instance, open]);
 
+  const fieldLabelKey = (field: DaemonChannelConfigFieldDescriptor) =>
+    FIELD_LABEL_KEYS[descriptor.type]?.[field.key] ??
+    COMMON_FIELD_LABEL_KEYS[field.key];
+
   const fieldLabel = (field: DaemonChannelConfigFieldDescriptor) => {
-    const key = FIELD_LABEL_KEYS[descriptor.type]?.[field.key];
+    const key = fieldLabelKey(field);
     return key ? t(key) : field.label;
   };
 
   const fieldDescription = (field: DaemonChannelConfigFieldDescriptor) => {
-    const labelKey = FIELD_LABEL_KEYS[descriptor.type]?.[field.key];
+    const labelKey = fieldLabelKey(field);
     if (labelKey) {
       const descKey = `${labelKey}.description`;
       const translated = t(descKey);
@@ -219,6 +227,19 @@ export function ChannelEditorDialog({
     return field.description;
   };
 
+  const fieldOptionLabel = (
+    field: DaemonChannelConfigFieldDescriptor,
+    option: { value: string; label: string },
+  ) => {
+    const labelKey = fieldLabelKey(field);
+    if (labelKey) {
+      const optionKey = `${labelKey}.option.${option.value}`;
+      const translated = t(optionKey);
+      if (translated !== optionKey) return translated;
+    }
+    return option.label;
+  };
+
   const validationMessage = (
     field: DaemonChannelConfigFieldDescriptor | undefined,
     code: ChannelEditorValidationCode,
@@ -432,7 +453,7 @@ export function ChannelEditorDialog({
             <SelectContent>
               {field.options?.map((option) => (
                 <SelectItem key={option.value} value={option.value}>
-                  {option.label}
+                  {fieldOptionLabel(field, option)}
                 </SelectItem>
               ))}
             </SelectContent>
@@ -519,6 +540,13 @@ export function ChannelEditorDialog({
     );
   };
 
+  const sessionScopeField = descriptor.fields.find(
+    (field) => field.key === 'sessionScope',
+  );
+  const platformFields = descriptor.fields.filter(
+    (field) => field.key !== 'sessionScope',
+  );
+
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
       <DialogContent className="max-w-[calc(100%-2rem)] p-5 sm:max-w-xl">
@@ -596,12 +624,23 @@ export function ChannelEditorDialog({
               </FieldShell>
             </section>
 
-            <section className={styles.section}>
-              <h3 className={styles.sectionHeading}>
-                {t('channels.editor.section.credentials')}
-              </h3>
-              {descriptor.fields.map(renderField)}
-            </section>
+            {platformFields.length > 0 ? (
+              <section className={styles.section}>
+                <h3 className={styles.sectionHeading}>
+                  {t('channels.editor.section.credentials')}
+                </h3>
+                {platformFields.map(renderField)}
+              </section>
+            ) : null}
+
+            {sessionScopeField ? (
+              <section className={styles.section}>
+                <h3 className={styles.sectionHeading}>
+                  {t('channels.editor.section.session')}
+                </h3>
+                {renderField(sessionScopeField)}
+              </section>
+            ) : null}
 
             {(() => {
               const descriptorPolicy = hasDescriptorSenderPolicy(descriptor);
diff --git a/packages/web-shell/client/components/channels/channel-editor-state.test.ts b/packages/web-shell/client/components/channels/channel-editor-state.test.ts
index fc15e9540ff..ae0dfd9c8fd 100644
--- a/packages/web-shell/client/components/channels/channel-editor-state.test.ts
+++ b/packages/web-shell/client/components/channels/channel-editor-state.test.ts
@@ -34,6 +34,19 @@ const DINGTALK: DaemonChannelTypeDescriptor = {
       required: true,
       envResolvable: true,
     },
+    {
+      key: 'sessionScope',
+      label: 'Session scope',
+      kind: 'enum',
+      required: true,
+      default: 'user',
+      options: [
+        { value: 'user', label: 'Per user and chat' },
+        { value: 'thread', label: 'Per thread' },
+        { value: 'chat_thread', label: 'Per chat and thread' },
+        { value: 'single', label: 'One shared session' },
+      ],
+    },
   ],
 };
 
@@ -70,6 +83,7 @@ describe('Channel editor state', () => {
       config: {
         type: 'dingtalk',
         clientId: 'ding-client-id',
+        sessionScope: 'user',
         senderPolicy: 'pairing',
       },
       secrets: {
@@ -103,6 +117,15 @@ describe('Channel editor state', () => {
     });
   });
 
+  it('shows the effective scope default for a legacy instance', () => {
+    const instance = configuredInstance();
+    delete instance.config.sessionScope;
+
+    const draft = createChannelEditorDraft(DINGTALK, instance);
+
+    expect(draft.values.sessionScope).toBe('user');
+  });
+
   it('supports explicitly clearing a stored secret', () => {
     const instance = configuredInstance();
     const draft = createChannelEditorDraft(DINGTALK, instance);
diff --git a/packages/web-shell/client/components/channels/channel-editor-state.ts b/packages/web-shell/client/components/channels/channel-editor-state.ts
index 70c9b484f2c..7cd84bf2995 100644
--- a/packages/web-shell/client/components/channels/channel-editor-state.ts
+++ b/packages/web-shell/client/components/channels/channel-editor-state.ts
@@ -71,7 +71,9 @@ function initialFieldValue(
   }
   if (field.kind === 'enum') {
     if (typeof value === 'string' && value) return value;
-    return instance ? '' : (field.default ?? field.options?.[0]?.value ?? '');
+    return instance && field.key !== 'sessionScope'
+      ? ''
+      : (field.default ?? field.options?.[0]?.value ?? '');
   }
   return typeof value === 'string' ? value : '';
 }
diff --git a/packages/web-shell/client/e2e/web-shell.channels.spec.ts b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
index 147d058e357..337dc730c0c 100644
--- a/packages/web-shell/client/e2e/web-shell.channels.spec.ts
+++ b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
@@ -95,6 +95,19 @@ test('creates and deletes a typed Channel configuration', async ({
             required: true,
             envResolvable: true,
           },
+          {
+            key: 'sessionScope',
+            label: 'Session scope',
+            kind: 'enum',
+            required: true,
+            default: 'user',
+            options: [
+              { value: 'user', label: 'Per user and chat' },
+              { value: 'thread', label: 'Per thread' },
+              { value: 'chat_thread', label: 'Per chat and thread' },
+              { value: 'single', label: 'One shared session' },
+            ],
+          },
         ],
       },
       {
@@ -144,6 +157,8 @@ test('creates and deletes a typed Channel configuration', async ({
   await page.getByLabel('Instance name').fill('release-bot');
   await page.getByLabel('Client ID (AppKey)').fill('ding-client-id');
   await page.getByLabel('Client Secret (AppSecret)').fill('ding-client-secret');
+  await page.getByLabel('Session scope').click();
+  await page.getByRole('option', { name: 'Per thread' }).click();
   await page.getByRole('button', { name: 'Save' }).click();
 
   await expect(
@@ -165,6 +180,7 @@ test('creates and deletes a typed Channel configuration', async ({
           config: {
             type: 'dingtalk',
             clientId: 'ding-client-id',
+            sessionScope: 'thread',
             senderPolicy: 'pairing',
           },
           secrets: {
@@ -181,6 +197,7 @@ test('creates and deletes a typed Channel configuration', async ({
   await expect(
     page.getByRole('heading', { name: 'Edit DingTalk' }),
   ).toBeVisible();
+  await expect(page.getByLabel('Session scope')).toHaveText('Per thread');
   await expect(page.getByText('Ada', { exact: true })).toBeVisible();
   await expect(page.getByText('ABCD1234', { exact: true })).toBeVisible();
   await page
diff --git a/packages/web-shell/client/i18n.tsx b/packages/web-shell/client/i18n.tsx
index 8629ee019ef..9f2550e60e6 100644
--- a/packages/web-shell/client/i18n.tsx
+++ b/packages/web-shell/client/i18n.tsx
@@ -2439,10 +2439,19 @@ const EN: Messages = {
     'Update public settings or explicitly change stored credentials.',
   'channels.editor.section.identity': 'Identity',
   'channels.editor.section.credentials': 'Credentials',
+  'channels.editor.section.session': 'Session',
   'channels.editor.section.access': 'Access policy',
   'channels.editor.instanceName': 'Instance name',
   'channels.editor.instanceNamePlaceholder': 'e.g. release-bot',
   'channels.editor.environmentReference': '$ENV_VAR supported',
+  'channels.editor.field.sessionScope': 'Session scope',
+  'channels.editor.field.sessionScope.description':
+    'Controls which incoming conversations share one agent session.',
+  'channels.editor.field.sessionScope.option.user': 'Per user and chat',
+  'channels.editor.field.sessionScope.option.thread': 'Per thread',
+  'channels.editor.field.sessionScope.option.chat_thread':
+    'Per chat and thread',
+  'channels.editor.field.sessionScope.option.single': 'One shared session',
   'channels.editor.field.dingtalk.clientId': 'Client ID (AppKey)',
   'channels.editor.field.dingtalk.clientSecret': 'Client Secret (AppSecret)',
   'channels.editor.field.wecom.botId': 'Bot ID',
@@ -4962,10 +4971,18 @@ const ZH: Messages = {
   'channels.editor.editDescription': '更新公开配置，或明确更改已保存的凭据。',
   'channels.editor.section.identity': '频道标识',
   'channels.editor.section.credentials': '应用凭据',
+  'channels.editor.section.session': '会话',
   'channels.editor.section.access': '准入策略',
   'channels.editor.instanceName': '实例名称',
   'channels.editor.instanceNamePlaceholder': '例如 release-bot',
   'channels.editor.environmentReference': '支持 $ENV_VAR',
+  'channels.editor.field.sessionScope': '会话作用域',
+  'channels.editor.field.sessionScope.description':
+    '控制哪些来源的消息共享同一个 Agent 会话。',
+  'channels.editor.field.sessionScope.option.user': '按用户和对话',
+  'channels.editor.field.sessionScope.option.thread': '按话题',
+  'channels.editor.field.sessionScope.option.chat_thread': '按对话和话题',
+  'channels.editor.field.sessionScope.option.single': '整个频道共享',
   'channels.editor.field.dingtalk.clientId': 'Client ID（原 AppKey）',
   'channels.editor.field.dingtalk.clientSecret':
     'Client Secret（原 AppSecret）',

From c587b583ad765eb13b428dff27ef6b1fb5e07b34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=8B=E7=AB=9F?= <dingbingzhi.dbz@alibaba-inc.com>
Date: Mon, 3 Aug 2026 23:18:57 +0800
Subject: [PATCH 03/16] fix(web-shell): refresh channel session transcripts

---
 ...08-03-web-shell-channel-session-sidebar.md | 12 ++++
 packages/acp-bridge/src/bridge.test.ts        | 64 +++++++++++++++++++
 packages/acp-bridge/src/bridge.ts             | 32 ++++++++--
 packages/acp-bridge/src/bridgeTypes.ts        |  2 +
 .../acp-bridge/src/transcript-replay.test.ts  | 33 ++++++++++
 packages/acp-bridge/src/transcript-replay.ts  |  2 +-
 .../channels/base/src/ChannelAgentBridge.ts   |  9 ++-
 .../channels/base/src/ChannelBase.test.ts     | 20 +++++-
 packages/channels/base/src/ChannelBase.ts     |  1 +
 .../base/src/DaemonChannelBridge.test.ts      | 33 ++++++++++
 .../channels/base/src/DaemonChannelBridge.ts  | 19 +++++-
 .../acp-integration/session/Session.test.ts   | 20 ++++++
 .../src/acp-integration/session/Session.ts    | 17 ++++-
 .../src/ui/utils/resumeHistoryUtils.test.ts   |  9 +++
 .../cli/src/ui/utils/resumeHistoryUtils.ts    |  2 +-
 .../core/src/services/sessionService.test.ts  | 24 +++++++
 packages/core/src/services/sessionService.ts  | 17 ++++-
 .../components/sidebar/WebShellSidebar.tsx    | 10 ++-
 ...WebShellSidebar.workspace-removal.test.tsx | 32 ++++++++++
 .../client/e2e/web-shell.channels.spec.ts     | 10 +++
 20 files changed, 351 insertions(+), 17 deletions(-)

diff --git a/docs/design/2026-08-03-web-shell-channel-session-sidebar.md b/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
index 0bbf0e498a0..15b281180dc 100644
--- a/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
+++ b/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
@@ -22,6 +22,15 @@ and do not show a control they cannot support.
 The selected source is applied consistently to active, pinned, archived, and
 secondary-workspace session requests. Existing session rows, workspace
 sections, grouping, search, polling, and open-session actions are reused.
+Because channel sessions can be created by external messages without a Web
+Shell mutation event, the expanded Channels list uses the active-session poll
+interval instead of the 30-second idle interval.
+
+Channel adapters still prepend their model-facing instructions and contextual
+history. The daemon prompt carries the user-authored text separately as
+transcript display metadata, so live and replayed Web Shell messages do not
+expose that hidden context and channel session titles derive from the same
+visible text.
 
 ## Boundaries
 
@@ -36,5 +45,8 @@ sections, grouping, search, polling, and open-session actions are reused.
 - Assert Tasks is initially selected and requests `sourceType: "default"`.
 - Assert selecting Channels requests `sourceType: "channel"` for primary and
   workspace-qualified lists.
+- Assert the Channels list polls on the active-session interval.
+- Assert channel prompts preserve full model context while recording only the
+  user-authored text for transcript display.
 - Run the sidebar and workspace-section unit tests, Web Shell build, and
   TypeScript typecheck.
diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts
index f1c0ef27165..bdc6c7c6945 100644
--- a/packages/acp-bridge/src/bridge.test.ts
+++ b/packages/acp-bridge/src/bridge.test.ts
@@ -5717,6 +5717,23 @@ describe('createAcpSessionBridge', () => {
       await bridge.shutdown();
     });
 
+    it('strips channel display metadata from non-channel sessions', async () => {
+      const handle = makeChannel();
+      const bridge = makeBridge({ channelFactory: async () => handle.channel });
+      const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
+
+      await bridge.sendPrompt(session.sessionId, {
+        sessionId: session.sessionId,
+        prompt: [{ type: 'text', text: 'model text' }],
+        _meta: { 'qwen.daemon.promptDisplayText': 'hidden transcript text' },
+      } as PromptRequest);
+
+      expect(
+        handle.agent.promptCalls[0]?._meta?.['qwen.daemon.promptDisplayText'],
+      ).toBeUndefined();
+      await bridge.shutdown();
+    });
+
     it('strips spoofed delivery metadata and injects only trusted context', async () => {
       const handle = makeChannel();
       const bridge = makeBridge({ channelFactory: async () => handle.channel });
@@ -6183,6 +6200,53 @@ describe('createAcpSessionBridge', () => {
       await bridge.shutdown();
     });
 
+    it('echoes only channel display text while forwarding full model context', async () => {
+      const handle = makeChannel({
+        promptImpl: () => ({ stopReason: 'end_turn' }),
+      });
+      const bridge = makeBridge({ channelFactory: async () => handle.channel });
+      const session = await bridge.spawnOrAttach({
+        workspaceCwd: WS_A,
+        sourceType: 'channel',
+      });
+      const abort = new AbortController();
+      const events = bridge.subscribeEvents(session.sessionId, {
+        signal: abort.signal,
+      });
+      const userChunk = (async () => {
+        for await (const event of events) {
+          if (event.type !== 'session_update') continue;
+          const update = (
+            event.data as {
+              update?: { sessionUpdate?: string; content?: unknown };
+            }
+          ).update;
+          if (update?.sessionUpdate === 'user_message_chunk') return update;
+        }
+        throw new Error('no user_message_chunk observed');
+      })();
+
+      await bridge.sendPrompt(session.sessionId, {
+        sessionId: session.sessionId,
+        prompt: [
+          { type: 'text', text: 'internal channel instructions\n\nhello' },
+        ],
+        _meta: { 'qwen.daemon.promptDisplayText': 'hello' },
+      } as PromptRequest);
+
+      await expect(userChunk).resolves.toMatchObject({
+        content: { type: 'text', text: 'hello' },
+      });
+      expect(handle.agent.promptCalls[0]).toMatchObject({
+        prompt: [
+          { type: 'text', text: 'internal channel instructions\n\nhello' },
+        ],
+        _meta: { 'qwen.daemon.promptDisplayText': 'hello' },
+      });
+      abort.abort();
+      await bridge.shutdown();
+    });
+
     it('echoes one user_message_chunk per content block (multi-modal)', async () => {
       const factory: ChannelFactory = async () =>
         makeChannel({ promptImpl: () => ({ stopReason: 'end_turn' }) }).channel;
diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts
index ce456a588cc..2b97b607b00 100644
--- a/packages/acp-bridge/src/bridge.ts
+++ b/packages/acp-bridge/src/bridge.ts
@@ -102,6 +102,7 @@ import {
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
+  DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_HIDE_INHERITED_META_KEY,
   LOAD_REPLAY_META_KEY,
@@ -930,15 +931,25 @@ function echoPromptToSessionBus(
   // contract — cheaper than a thrown `TypeError` mid-echo.
   const prompt = req.prompt;
   if (!Array.isArray(prompt) || prompt.length === 0) return;
+  const displayText =
+    entry.sourceType === 'channel' &&
+    typeof req._meta?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] === 'string'
+      ? req._meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]
+      : undefined;
+  let displayTextPublished = false;
   const serverTimestamp = Date.now();
   const blockCount = Math.min(prompt.length, MAX_ECHO_CONTENT_BLOCKS);
   for (let i = 0; i < blockCount; i += 1) {
     const part = prompt[i];
     if (!part || typeof part !== 'object' || Array.isArray(part)) continue;
-    // Every `ContentBlock` variant (text, image, audio, resource) is
-    // published to the bus verbatim. The SDK's `normalizeDaemonEvent`
-    // accepts any `content` shape; rich rendering of non-text blocks is
-    // the consumer's responsibility.
+    let displayPart = part;
+    if (displayText !== undefined && part.type === 'text') {
+      if (displayTextPublished) continue;
+      displayTextPublished = true;
+      displayPart = { ...part, text: displayText };
+    }
+    // Non-text blocks are published verbatim. Channel text uses the display
+    // projection so hidden model context never reaches transcript consumers.
     try {
       entry.events.publish({
         type: 'session_update',
@@ -947,7 +958,7 @@ function echoPromptToSessionBus(
           sessionId: req.sessionId,
           update: {
             sessionUpdate: 'user_message_chunk',
-            content: part,
+            content: displayPart,
             // `_meta` lives inside the `update` object rather than at
             // envelope level. `_meta` is a standard JSON-RPC/MCP extension
             // field permitted alongside spec fields, the SDK normalizer
@@ -5655,6 +5666,12 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
                     copy._meta && typeof copy._meta === 'object'
                       ? { ...copy._meta }
                       : {};
+                  const promptDisplayText =
+                    entry.sourceType === 'channel' &&
+                    typeof meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] ===
+                      'string'
+                      ? meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]
+                      : undefined;
                   delete meta[DAEMON_RETRY_META_KEY];
                   delete meta[INVOCATION_CONTEXT_META_KEY];
                   delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
@@ -5663,6 +5680,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
                   // below) re-arms it after this strip.
                   delete meta[DAEMON_CONTINUE_META_KEY];
                   delete meta[DAEMON_CHANNEL_DELIVERY_META_KEY];
+                  delete meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
                   }
@@ -5673,6 +5691,10 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
                     meta[DAEMON_CHANNEL_DELIVERY_META_KEY] =
                       context.channelDelivery;
                   }
+                  if (promptDisplayText !== undefined) {
+                    meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] =
+                      promptDisplayText;
+                  }
                   meta[INVOCATION_CONTEXT_META_KEY] = invocationContext;
                   if (Object.keys(meta).length > 0) {
                     copy._meta = meta;
diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts
index 53d4ccd8d7a..83d55502d56 100644
--- a/packages/acp-bridge/src/bridgeTypes.ts
+++ b/packages/acp-bridge/src/bridgeTypes.ts
@@ -564,6 +564,8 @@ export interface BridgeClientRequestContext {
 }
 
 export const DAEMON_CHANNEL_DELIVERY_META_KEY = 'qwen.daemon.channelDelivery';
+export const DAEMON_PROMPT_DISPLAY_TEXT_META_KEY =
+  'qwen.daemon.promptDisplayText';
 
 /**
  * Returned from `recordHeartbeat`. `lastSeenAt` is the server-side
diff --git a/packages/acp-bridge/src/transcript-replay.test.ts b/packages/acp-bridge/src/transcript-replay.test.ts
index 3431904ecbe..96b4e40468c 100644
--- a/packages/acp-bridge/src/transcript-replay.test.ts
+++ b/packages/acp-bridge/src/transcript-replay.test.ts
@@ -282,6 +282,39 @@ describe('createTranscriptReplayMachine', () => {
       expect(projected).toHaveLength(2);
     });
 
+    it('does not replay hidden text when an image-only prompt has empty display text', () => {
+      const projected = updates(
+        createTranscriptReplayMachine(),
+        record('user-empty-display', 'user', {
+          message: {
+            role: 'user',
+            parts: [
+              {
+                inlineData: {
+                  data: 'abc',
+                  mimeType: 'image/png',
+                },
+              },
+              { text: 'internal channel instructions' },
+            ],
+          },
+          systemPayload: { displayText: '' },
+        }),
+      );
+
+      expect(projected).toMatchObject([
+        {
+          sessionUpdate: 'user_message_chunk',
+          content: {
+            type: 'image',
+            data: 'abc',
+            mimeType: 'image/png',
+          },
+        },
+      ]);
+      expect(projected).toHaveLength(1);
+    });
+
     it('strips a trailing whole-part tagged block when displayText is absent', () => {
       const projected = updates(
         createTranscriptReplayMachine(),
diff --git a/packages/acp-bridge/src/transcript-replay.ts b/packages/acp-bridge/src/transcript-replay.ts
index 23adc7dea1b..701c9eb9a07 100644
--- a/packages/acp-bridge/src/transcript-replay.ts
+++ b/packages/acp-bridge/src/transcript-replay.ts
@@ -559,7 +559,7 @@ class DefaultTranscriptReplayMachine implements TranscriptReplayMachine {
           ? payload['displayText']
           : undefined;
       yield* this.projectMessageParts(
-        displayText
+        displayText !== undefined
           ? this.withUserPromptDisplayText(record, displayText)
           : this.withoutTrailingUserPromptSubmitContext(record),
         'user',
diff --git a/packages/channels/base/src/ChannelAgentBridge.ts b/packages/channels/base/src/ChannelAgentBridge.ts
index 4f6d166f6c7..3e426fcf3f2 100644
--- a/packages/channels/base/src/ChannelAgentBridge.ts
+++ b/packages/channels/base/src/ChannelAgentBridge.ts
@@ -90,6 +90,13 @@ export interface ChannelAgentBridgeSessionOptions {
   sourceId?: string;
 }
 
+export interface ChannelAgentBridgePromptOptions {
+  imageBase64?: string;
+  imageMimeType?: string;
+  /** User-authored text shown in transcripts when `text` includes hidden context. */
+  displayText?: string;
+}
+
 export interface ChannelAgentBridge {
   readonly availableCommands: AvailableCommand[];
   getAvailableCommands?(sessionId: string): AvailableCommand[];
@@ -115,7 +122,7 @@ export interface ChannelAgentBridge {
   prompt(
     sessionId: string,
     text: string,
-    options?: { imageBase64?: string; imageMimeType?: string },
+    options?: ChannelAgentBridgePromptOptions,
   ): Promise<string>;
   cancelSession(sessionId: string): Promise<void>;
   /** Release a bridge-owned session that will not be routed to a caller. */
diff --git a/packages/channels/base/src/ChannelBase.test.ts b/packages/channels/base/src/ChannelBase.test.ts
index 1799d109968..07c44258379 100644
--- a/packages/channels/base/src/ChannelBase.test.ts
+++ b/packages/channels/base/src/ChannelBase.test.ts
@@ -7759,7 +7759,11 @@ describe('ChannelBase', () => {
 
       await ch.handleInbound(envelope({ text: '/schedule list' }));
 
-      expect(bridge.prompt).toHaveBeenCalledWith('s-1', '/schedule list', {});
+      expect(bridge.prompt).toHaveBeenCalledWith('s-1', '/schedule list', {
+        displayText: '/schedule list',
+        imageBase64: undefined,
+        imageMimeType: undefined,
+      });
       expect(ch.sent).toEqual([{ chatId: 'chat1', text: 'agent response' }]);
     });
 
@@ -9941,6 +9945,19 @@ describe('ChannelBase', () => {
       expect(secondPrompt).not.toContain('Be concise.');
     });
 
+    it('keeps channel context out of the user-facing prompt text', async () => {
+      const ch = createChannel({ instructions: 'Be concise.' });
+
+      await ch.handleInbound(envelope({ text: 'hello' }));
+
+      const [sessionId, modelText, options] = (
+        bridge.prompt as ReturnType<typeof vi.fn>
+      ).mock.calls[0]!;
+      expect(sessionId).toEqual(expect.any(String));
+      expect(modelText).toContain('Be concise.');
+      expect(options).toMatchObject({ displayText: 'hello' });
+    });
+
     it('prepends channel boundary metadata after custom instructions once per session', async () => {
       const ch = createChannel({
         instructions: 'Be concise.',
@@ -13390,6 +13407,7 @@ describe('ChannelBase', () => {
       await ch.handleInbound(envelope({ text: '!echo hello' }));
 
       expect(bridge.prompt).toHaveBeenCalledWith('s-1', '!echo hello', {
+        displayText: '!echo hello',
         imageBase64: undefined,
         imageMimeType: undefined,
       });
diff --git a/packages/channels/base/src/ChannelBase.ts b/packages/channels/base/src/ChannelBase.ts
index 10450bcf359..ecac0f40cae 100644
--- a/packages/channels/base/src/ChannelBase.ts
+++ b/packages/channels/base/src/ChannelBase.ts
@@ -5530,6 +5530,7 @@ export abstract class ChannelBase {
         const response = await promptBridge.prompt(sessionId, promptToSend, {
           imageBase64,
           imageMimeType,
+          displayText: promptText,
         });
 
         await this.settleCancelRequested(promptState);
diff --git a/packages/channels/base/src/DaemonChannelBridge.test.ts b/packages/channels/base/src/DaemonChannelBridge.test.ts
index e4a3122a9c8..02d8903df8c 100644
--- a/packages/channels/base/src/DaemonChannelBridge.test.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.test.ts
@@ -1865,6 +1865,39 @@ describe('DaemonChannelBridge', () => {
     bridge.stop();
   });
 
+  it('forwards a distinct user-facing prompt text in daemon metadata', async () => {
+    const events = new EventQueue();
+    const session = createFakeSession(events);
+    const bridge = new DaemonChannelBridge({
+      cwd: '/repo',
+      sessionFactory: vi.fn().mockResolvedValue(session),
+    });
+
+    await bridge.start();
+    await bridge.newSession('/repo');
+
+    const promptPromise = bridge.prompt(
+      'session-1',
+      'internal context\n\nhello',
+      {
+        displayText: 'hello',
+      },
+    );
+    await waitFor(() => expect(session.prompt).toHaveBeenCalledOnce());
+    expect(session.prompt).toHaveBeenCalledWith(
+      {
+        prompt: [{ type: 'text', text: 'internal context\n\nhello' }],
+        _meta: { 'qwen.daemon.promptDisplayText': 'hello' },
+      },
+      expect.any(AbortSignal),
+    );
+
+    events.push(turnCompleteEvent());
+    await promptPromise;
+    events.close();
+    bridge.stop();
+  });
+
   it('aborts in-flight prompts when the bridge stops', async () => {
     const events = new EventQueue();
     const session = createFakeSession(events);
diff --git a/packages/channels/base/src/DaemonChannelBridge.ts b/packages/channels/base/src/DaemonChannelBridge.ts
index afcd6c8606a..a5fd71deee2 100644
--- a/packages/channels/base/src/DaemonChannelBridge.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.ts
@@ -7,6 +7,7 @@ import type {
   AvailableCommand,
   BridgeSessionInfo,
   ChannelAgentBridge,
+  ChannelAgentBridgePromptOptions,
   ChannelAgentBridgeSessionOptions,
   ChannelLoopToolHandler,
   ToolCallEvent,
@@ -19,6 +20,7 @@ import {
 import type { SessionScope } from './types.js';
 
 const MAX_RESPONDED_PERMISSION_REQUESTS = 256;
+const DAEMON_PROMPT_DISPLAY_TEXT_META_KEY = 'qwen.daemon.promptDisplayText';
 
 export interface DaemonChannelEvent {
   id?: number;
@@ -35,6 +37,7 @@ export interface DaemonChannelSessionClient {
   prompt(
     req: {
       prompt: Array<Record<string, unknown>>;
+      _meta?: Record<string, unknown>;
     },
     signal?: AbortSignal,
   ): Promise<{ stopReason?: string; [key: string]: unknown }>;
@@ -346,7 +349,7 @@ export class DaemonChannelBridge
   async prompt(
     sessionId: string,
     text: string,
-    options?: { imageBase64?: string; imageMimeType?: string },
+    options?: ChannelAgentBridgePromptOptions,
   ): Promise<string> {
     const session = this.ensureSession(sessionId);
     if (this.activePrompts.has(sessionId)) {
@@ -404,7 +407,19 @@ export class DaemonChannelBridge
     prompt.push({ type: 'text', text });
 
     try {
-      const result = await session.prompt({ prompt }, controller.signal);
+      const result = await session.prompt(
+        {
+          prompt,
+          ...(options?.displayText !== undefined
+            ? {
+                _meta: {
+                  [DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText,
+                },
+              }
+            : {}),
+        },
+        controller.signal,
+      );
       // Prefer turn_complete for deterministic chunk collection (SSE path).
       // Fall back to one event-loop tick for non-SSE prompt paths (blocking
       // HTTP, non-202 responses) where turn_complete never arrives.
diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts
index b7e9498ff8e..bf046493bd1 100644
--- a/packages/cli/src/acp-integration/session/Session.test.ts
+++ b/packages/cli/src/acp-integration/session/Session.test.ts
@@ -4377,6 +4377,26 @@ describe('Session', () => {
       );
     });
 
+    it('records daemon prompt display text separately from model context', async () => {
+      mockChat.sendMessageStream = vi
+        .fn()
+        .mockResolvedValue(createEmptyStream());
+
+      await session.prompt({
+        sessionId: 'test-session-id',
+        prompt: [
+          { type: 'text', text: 'internal channel instructions\n\nhello' },
+        ],
+        _meta: { 'qwen.daemon.promptDisplayText': 'hello' },
+      });
+
+      expect(mockChatRecordingService.recordUserMessage).toHaveBeenCalledWith(
+        'internal channel instructions\n\nhello',
+        undefined,
+        { displayText: 'hello' },
+      );
+    });
+
     it('degrades an oversized inline image to a text placeholder before sending to the model', async () => {
       const ENV_KEY = 'QWEN_CODE_MAX_INLINE_MEDIA_BYTES';
       const original = process.env[ENV_KEY];
diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts
index 39a91ec35cc..037e90d9b6e 100644
--- a/packages/cli/src/acp-integration/session/Session.ts
+++ b/packages/cli/src/acp-integration/session/Session.ts
@@ -172,6 +172,7 @@ import { NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE } from '@qwen-code/acp-bridge/b
 // so a rename can't desync caller and answerer into a silent -32601 latch.
 import {
   DAEMON_CHANNEL_DELIVERY_META_KEY,
+  DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   MID_TURN_QUEUE_DRAIN_METHOD,
   TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
 } from '@qwen-code/acp-bridge/bridgeTypes';
@@ -2820,6 +2821,11 @@ export class Session implements SessionContext {
               .filter((block) => block.type === 'text')
               .map((block) => (block.type === 'text' ? block.text : ''))
               .join(' ');
+            const promptDisplayText =
+              typeof promptMetadata?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] ===
+              'string'
+                ? promptMetadata[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]
+                : undefined;
 
             // Log user prompt
             logUserPrompt(
@@ -2904,9 +2910,14 @@ export class Session implements SessionContext {
               this.#getCurrentChat().stripOrphanedUserEntriesFromHistory();
             } else {
               // record user message for session management
-              this.config
-                .getChatRecordingService()
-                ?.recordUserMessage(promptText);
+              const recordingService = this.config.getChatRecordingService();
+              if (recordingService && promptDisplayText !== undefined) {
+                recordingService.recordUserMessage(promptText, undefined, {
+                  displayText: promptDisplayText,
+                });
+              } else {
+                recordingService?.recordUserMessage(promptText);
+              }
             }
 
             // Check if the input contains a slash command
diff --git a/packages/cli/src/ui/utils/resumeHistoryUtils.test.ts b/packages/cli/src/ui/utils/resumeHistoryUtils.test.ts
index 0a6bbdcd993..82208943a3f 100644
--- a/packages/cli/src/ui/utils/resumeHistoryUtils.test.ts
+++ b/packages/cli/src/ui/utils/resumeHistoryUtils.test.ts
@@ -236,6 +236,15 @@ describe('resumeHistoryUtils', () => {
       expect(items).toEqual([{ id: 1_001, type: 'user', text: 'my prompt' }]);
     });
 
+    it('does not fall back to hidden text when displayText is empty', () => {
+      const items = buildUserItems({
+        type: 'user',
+        message: { parts: [{ text: 'internal channel instructions' }] },
+        systemPayload: { displayText: '' },
+      });
+      expect(items).toEqual([]);
+    });
+
     it('prefers displayText over the tag-strip fallback', () => {
       // Fixture where the two branches disagree: without displayText the
       // tag-strip path would expose the middle "expanded extra" part.
diff --git a/packages/cli/src/ui/utils/resumeHistoryUtils.ts b/packages/cli/src/ui/utils/resumeHistoryUtils.ts
index 385898bf9de..c143d052a11 100644
--- a/packages/cli/src/ui/utils/resumeHistoryUtils.ts
+++ b/packages/cli/src/ui/utils/resumeHistoryUtils.ts
@@ -50,7 +50,7 @@ function extractUserRecordDisplayText(
   record: ConversationRecord['messages'][number],
 ): string {
   const payload = record.systemPayload as UserPromptRecordPayload | undefined;
-  if (payload?.displayText) {
+  if (payload?.displayText !== undefined) {
     return payload.displayText;
   }
   const parts = (record.message?.parts as Part[] | undefined) ?? [];
diff --git a/packages/core/src/services/sessionService.test.ts b/packages/core/src/services/sessionService.test.ts
index b9c9a6467af..6817b53fb5f 100644
--- a/packages/core/src/services/sessionService.test.ts
+++ b/packages/core/src/services/sessionService.test.ts
@@ -364,6 +364,30 @@ describe('SessionService', () => {
       expect(result.items[0].gitBranch).toBe('main');
     });
 
+    it('should use recorded display text for the session list prompt', async () => {
+      readdirSyncSpy.mockReturnValue([
+        `${sessionIdA}.jsonl`,
+      ] as unknown as Array<fs.Dirent<Buffer>>);
+      statSyncSpy.mockReturnValue({
+        mtimeMs: Date.now(),
+        isFile: () => true,
+      } as fs.Stats);
+      vi.mocked(jsonl.readLines).mockResolvedValue([
+        {
+          ...recordA1,
+          message: {
+            role: 'user',
+            parts: [{ text: 'internal channel instructions\n\nhello' }],
+          },
+          systemPayload: { displayText: 'hello' },
+        },
+      ]);
+
+      const result = await sessionService.listSessions();
+
+      expect(result.items[0].prompt).toBe('hello');
+    });
+
     it('should NOT populate messageCount during listing', async () => {
       // Listing must avoid the full-file readline that counting requires
       // — message counts are now lazy and provided by
diff --git a/packages/core/src/services/sessionService.ts b/packages/core/src/services/sessionService.ts
index 9396ef75640..5a800e1208d 100644
--- a/packages/core/src/services/sessionService.ts
+++ b/packages/core/src/services/sessionService.ts
@@ -21,6 +21,7 @@ import type {
   FileHistorySnapshotRecordPayload,
   TitleSource,
   UiTelemetryRecordPayload,
+  UserPromptRecordPayload,
 } from './chatRecordingService.js';
 import type { FileHistorySnapshot } from './fileHistoryService.js';
 import {
@@ -843,8 +844,22 @@ export class SessionService {
   private extractFirstPromptFromRecords(records: ChatRecord[]): string {
     for (const record of records) {
       if (record.type !== 'user') continue;
+      const payload = record.systemPayload as
+        | UserPromptRecordPayload
+        | undefined;
+      if (payload?.displayText !== undefined) {
+        const displayText = payload.displayText;
+        if (displayText) {
+          return displayText.length > 200
+            ? `${displayText.slice(0, 200)}...`
+            : displayText;
+        }
+        continue;
+      }
       const prompt = this.extractPromptText(record.message);
-      if (prompt) return prompt;
+      if (prompt) {
+        return prompt.length > 200 ? `${prompt.slice(0, 200)}...` : prompt;
+      }
     }
     return '';
   }
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 1169619ebb0..60c962f7747 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -1412,7 +1412,7 @@ export function WebShellSidebar({
   useEffect(() => {
     if (!projectExpanded && !hasRunningSession) return;
     const pollInterval =
-      hasRunningSession && !error
+      (hasRunningSession || selectedSessionSource === 'channel') && !error
         ? ACTIVE_SESSION_POLL_INTERVAL_MS
         : IDLE_SESSION_POLL_INTERVAL_MS;
     const intervalId = window.setInterval(() => {
@@ -1423,7 +1423,13 @@ export function WebShellSidebar({
       });
     }, pollInterval);
     return () => window.clearInterval(intervalId);
-  }, [error, hasRunningSession, projectExpanded, reload]);
+  }, [
+    error,
+    hasRunningSession,
+    projectExpanded,
+    reload,
+    selectedSessionSource,
+  ]);
 
   const prevReloadTokenRef = useRef(sessionListReloadToken);
   useEffect(() => {
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 7fdfbb13100..8053e6d51ab 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -2950,6 +2950,38 @@ describe('WebShellSidebar session source switch', () => {
       ),
     ).toBe(true);
   });
+
+  it('polls channel sessions on the active-session interval', async () => {
+    const setIntervalSpy = vi.spyOn(window, 'setInterval');
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    const channelsTab = Array.from(
+      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
+    ).find((button) => button.textContent?.trim() === 'Channels');
+
+    await act(async () => {
+      channelsTab!.dispatchEvent(
+        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
+      );
+      channelsTab!.click();
+      await Promise.resolve();
+    });
+    expect(channelsTab?.getAttribute('data-state')).toBe('active');
+    const activePoll = setIntervalSpy.mock.calls.findLast(
+      ([, timeout]) => timeout === 2_000,
+    );
+    expect(activePoll).toBeDefined();
+    active.reload.mockClear();
+
+    await act(async () => {
+      const callback = activePoll![0];
+      expect(callback).toBeTypeOf('function');
+      if (typeof callback === 'function') callback();
+      await Promise.resolve();
+    });
+
+    expect(active.reload).toHaveBeenCalledOnce();
+  });
 });
 
 describe('WebShellSidebar archived session export', () => {
diff --git a/packages/web-shell/client/e2e/web-shell.channels.spec.ts b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
index 337dc730c0c..065a9ef3985 100644
--- a/packages/web-shell/client/e2e/web-shell.channels.spec.ts
+++ b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
@@ -57,6 +57,16 @@ test('shows channel sessions in the sidebar channel catalog', async ({
     page.getByText('DingTalk conversation', { exact: true }),
   ).toBeVisible();
   await expect(page.getByText('Web Shell task')).toHaveCount(0);
+
+  scenario.sessions.push({
+    sessionId: 'new-dingtalk-session',
+    displayName: 'New DingTalk conversation',
+    sourceType: 'channel',
+    sourceId: 'release-bot',
+  });
+  await expect(
+    page.getByText('New DingTalk conversation', { exact: true }),
+  ).toBeVisible({ timeout: 5_000 });
 });
 
 test('creates and deletes a typed Channel configuration', async ({

From 2ad35da0b5d56761367b5d08bef629ee4f52a917 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=8B=E7=AB=9F?= <dingbingzhi.dbz@alibaba-inc.com>
Date: Mon, 3 Aug 2026 23:45:15 +0800
Subject: [PATCH 04/16] feat(web-shell): group channel sessions by platform

---
 ...08-03-web-shell-channel-session-sidebar.md |  16 ++
 .../WebShellSidebar.collapse-persist.test.tsx |   1 +
 .../components/sidebar/WebShellSidebar.tsx    | 110 +++++++++---
 ...WebShellSidebar.workspace-removal.test.tsx | 168 ++++++++++++++++++
 .../sidebar/WorkspaceSection.test.tsx         |  76 ++++++++
 .../components/sidebar/WorkspaceSection.tsx   |  76 ++++++++
 .../sidebar/channelSessionGroups.test.ts      |  83 +++++++++
 .../sidebar/channelSessionGroups.ts           |  46 +++++
 .../sidebar/collapsedSessionSections.ts       |   2 +-
 .../client/e2e/web-shell.channels.spec.ts     |  80 +++++++++
 packages/web-shell/client/i18n.tsx            |   2 +
 11 files changed, 632 insertions(+), 28 deletions(-)
 create mode 100644 packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
 create mode 100644 packages/web-shell/client/components/sidebar/channelSessionGroups.ts

diff --git a/docs/design/2026-08-03-web-shell-channel-session-sidebar.md b/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
index 15b281180dc..e79ae6186e3 100644
--- a/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
+++ b/docs/design/2026-08-03-web-shell-channel-session-sidebar.md
@@ -26,6 +26,17 @@ Because channel sessions can be created by external messages without a Web
 Shell mutation event, the expanded Channels list uses the active-session poll
 interval instead of the 30-second idle interval.
 
+When the selected workspace also advertises `channel_management`, the Channels
+catalog joins each session's immutable channel instance name (`sourceId`) to
+the current channel configuration and groups sessions by `config.type`. The
+type catalog supplies the platform label, so multiple instances of the same
+platform share one collapsible section. Sessions whose instance no longer
+exists remain visible under Other channels. If the catalog is unavailable, the
+list keeps its existing fallback instead of hiding sessions. Channel type grouping
+overrides user-defined session groups in the Channels view; Tasks keeps its
+existing organization behavior. Secondary workspaces resolve their own
+workspace-scoped channel catalog.
+
 Channel adapters still prepend their model-facing instructions and contextual
 history. The daemon prompt carries the user-authored text separately as
 transcript display metadata, so live and replayed Web Shell messages do not
@@ -38,6 +49,8 @@ visible text.
 - Session source metadata and daemon list APIs are unchanged.
 - Session Overview and Split View keep their existing default-session scope.
 - The switch is in-memory UI state and resets to Tasks on page reload.
+- Channel type classification reflects the current workspace configuration;
+  sessions do not persist a historical platform type.
 
 ## Verification
 
@@ -46,6 +59,9 @@ visible text.
 - Assert selecting Channels requests `sourceType: "channel"` for primary and
   workspace-qualified lists.
 - Assert the Channels list polls on the active-session interval.
+- Assert multiple instances of one platform share a collapsible type section,
+  other platform sessions remain separate, pinned sessions stay in their type
+  section, and unmatched sessions remain under Other channels.
 - Assert channel prompts preserve full model context while recording only the
   user-authored text for transcript display.
 - Run the sidebar and workspace-section unit tests, Web Shell build, and
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.collapse-persist.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.collapse-persist.test.tsx
index eb2e55edb07..16db70ef2cb 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.collapse-persist.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.collapse-persist.test.tsx
@@ -83,6 +83,7 @@ vi.mock('@qwen-code/webui/daemon-react-sdk', () => ({
   useActions: () => ({ renameSession: vi.fn() }),
   useWorkspace: () => workspace,
   useWorkspaceActions: () => workspaceActions,
+  useChannels: () => ({ data: undefined, catalog: [], channels: {} }),
   useSessions: (options?: { archiveState?: string; group?: string }) => {
     if (options?.archiveState === 'archived') return archived;
     if (options?.group === 'pinned') return pinned;
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 60c962f7747..7f1911e1236 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -12,6 +12,7 @@ import {
 } from 'react';
 import {
   useActions,
+  useChannels,
   useConnection,
   useSessions,
   useWorkspace,
@@ -84,6 +85,7 @@ import { DialogShell } from '../dialogs/DialogShell';
 import { WorkspaceSection } from './WorkspaceSection';
 import { SessionGroupSection } from './SessionGroupSection';
 import { SessionDetailsSubmenu } from './SessionDetailsSubmenu';
+import { groupSessionsByChannelType } from './channelSessionGroups';
 import { resolveSessionDetailsCollisionBoundary } from './sessionDetailsCollisionBoundary';
 import {
   isPrimaryCollapsedSectionId,
@@ -574,6 +576,18 @@ export function WebShellSidebar({
   const selectedSessionSource = sourceMetadataEnabled
     ? sessionSource
     : undefined;
+  const channelGroupingEnabled = Boolean(
+    selectedSessionSource === 'channel' &&
+      workspace.capabilities?.features.includes('channel_management'),
+  );
+  const {
+    data: channelCatalogData,
+    catalog: channelTypeCatalog,
+    channels: channelInstances,
+  } = useChannels({
+    autoLoad: channelGroupingEnabled,
+    enabled: channelGroupingEnabled,
+  });
   const sessionArchiveEnabled = Boolean(
     connection.capabilities?.features?.includes('session_archive'),
   );
@@ -2547,7 +2561,10 @@ export function WebShellSidebar({
 
   const filteredSessions = useMemo(() => {
     const query = searchQuery.trim().toLowerCase();
-    const unpinnedSessions = sessions.filter((session) => !session.isPinned);
+    const unpinnedSessions =
+      selectedSessionSource === 'channel'
+        ? sessions
+        : sessions.filter((session) => !session.isPinned);
     const nextSessions = query
       ? unpinnedSessions.filter((session) => {
           const label = getSessionLabel(session).toLowerCase();
@@ -2571,7 +2588,27 @@ export function WebShellSidebar({
         (createdTimeById.get(b.sessionId) ?? 0) -
         (createdTimeById.get(a.sessionId) ?? 0),
     );
-  }, [organizationEnabled, searchQuery, sessions]);
+  }, [organizationEnabled, searchQuery, selectedSessionSource, sessions]);
+
+  const channelSessionSections = useMemo(
+    () =>
+      selectedSessionSource === 'channel' && channelCatalogData
+        ? groupSessionsByChannelType(
+            filteredSessions,
+            channelTypeCatalog,
+            channelInstances,
+            t('sidebar.channelType.other'),
+          )
+        : null,
+    [
+      channelCatalogData,
+      channelInstances,
+      channelTypeCatalog,
+      filteredSessions,
+      selectedSessionSource,
+      t,
+    ],
+  );
 
   const sessionSections = useMemo<SessionSection[]>(() => {
     if (!organizationEnabled) return [];
@@ -3430,12 +3467,27 @@ export function WebShellSidebar({
     }
     if (
       filteredSessions.length === 0 &&
-      (searchQuery.trim() ||
+      (channelSessionSections !== null ||
+        searchQuery.trim() ||
         !organizationEnabled ||
         sessionSections.length === 0)
     ) {
       return <div className={styles.notice}>{t('sidebar.searchEmpty')}</div>;
     }
+    if (channelSessionSections) {
+      return channelSessionSections.map((section) => (
+        <SessionGroupSection
+          key={section.id}
+          id={section.id}
+          label={section.label}
+          count={section.sessions.length}
+          expanded={!collapsedSessionSectionIds.has(section.id)}
+          onToggle={() => toggleSessionSection(section.id)}
+        >
+          {section.sessions.map((session) => renderSessionRow(session))}
+        </SessionGroupSection>
+      ));
+    }
     if (!organizationEnabled) {
       return filteredSessions.map((session) => renderSessionRow(session));
     }
@@ -3476,6 +3528,7 @@ export function WebShellSidebar({
   }, [
     collapsedSessionSectionIds,
     canOrganizeWorkspace,
+    channelSessionSections,
     error,
     filteredSessions,
     groupBusy,
@@ -4105,30 +4158,32 @@ export function WebShellSidebar({
                 </TabsList>
               </Tabs>
             )}
-            {!collapsed && pinnedSessions.length > 0 && (
-              <>
-                <div className={styles.projectsHeader}>
-                  <button
-                    className={styles.projectsHeaderToggle}
-                    type="button"
-                    aria-expanded={pinnedExpanded}
-                    onClick={() => setPinnedExpanded((expanded) => !expanded)}
-                  >
-                    <span>{t('sidebar.pinnedSessions')}</span>
-                    <IconChevron expanded={pinnedExpanded} />
-                  </button>
-                </div>
-                {pinnedExpanded && (
-                  <div className={styles.pinnedSessionList}>
-                    {pinnedSessions.map((session) =>
-                      renderSessionRow(session, {
-                        readOnly: isActiveSessionReadOnly(session),
-                      }),
-                    )}
+            {!collapsed &&
+              selectedSessionSource !== 'channel' &&
+              pinnedSessions.length > 0 && (
+                <>
+                  <div className={styles.projectsHeader}>
+                    <button
+                      className={styles.projectsHeaderToggle}
+                      type="button"
+                      aria-expanded={pinnedExpanded}
+                      onClick={() => setPinnedExpanded((expanded) => !expanded)}
+                    >
+                      <span>{t('sidebar.pinnedSessions')}</span>
+                      <IconChevron expanded={pinnedExpanded} />
+                    </button>
                   </div>
-                )}
-              </>
-            )}
+                  {pinnedExpanded && (
+                    <div className={styles.pinnedSessionList}>
+                      {pinnedSessions.map((session) =>
+                        renderSessionRow(session, {
+                          readOnly: isActiveSessionReadOnly(session),
+                        }),
+                      )}
+                    </div>
+                  )}
+                </>
+              )}
             {!collapsed && !hideProjectHeader && (
               <div className={styles.projectsHeader}>
                 <button
@@ -4215,6 +4270,7 @@ export function WebShellSidebar({
                             loadErrorLabel={t('sidebar.loadFailed')}
                             organizationEnabled={organizationEnabled}
                             sourceType={selectedSessionSource}
+                            channelGroupingEnabled={channelGroupingEnabled}
                             ungroupedLabel={t('sidebar.groupUngrouped')}
                             onRenameGroup={
                               canOrganizeWorkspace(ws.cwd)
@@ -4229,7 +4285,7 @@ export function WebShellSidebar({
                             renameGroupLabel={t('sidebar.groupRename')}
                             deleteGroupLabel={t('sidebar.groupDelete')}
                             groupActionsDisabled={groupBusy}
-                            excludePinned
+                            excludePinned={selectedSessionSource !== 'channel'}
                             onOpenGitDiff={onOpenGitDiff}
                             onOpenCommit={onOpenCommit}
                             formatTime={(iso) => formatRelativeTime(iso, t)}
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 8053e6d51ab..f139222ab85 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -24,6 +24,7 @@ const {
   exportSession,
   exportArchivedSession,
   sessionActions,
+  channelState,
 } = vi.hoisted(() => {
   const makeSessions = () => ({
     sessions: [] as DaemonSessionSummary[],
@@ -113,6 +114,26 @@ const {
     exportSession,
     exportArchivedSession,
     sessionActions,
+    channelState: {
+      data: undefined as
+        | {
+            catalog: Array<{
+              type: string;
+              displayName: string;
+              manageable: boolean;
+              fields: [];
+            }>;
+            snapshot: { revision: string; instances: Record<string, unknown> };
+          }
+        | undefined,
+      catalog: [] as Array<{
+        type: string;
+        displayName: string;
+        manageable: boolean;
+        fields: [];
+      }>,
+      channels: {} as Record<string, unknown>,
+    },
   };
 });
 
@@ -122,6 +143,7 @@ vi.mock('@qwen-code/webui/daemon-react-sdk', () => ({
   useWorkspace: () => workspace,
   useWorkspaceActions: () => workspaceActions,
   useSessions,
+  useChannels: () => channelState,
 }));
 
 const { I18nProvider } = await import('../../i18n');
@@ -487,6 +509,9 @@ beforeEach(() => {
   useSessions.mockClear();
   active.sessions.length = 0;
   archived.sessions.length = 0;
+  channelState.data = undefined;
+  channelState.catalog = [];
+  channelState.channels = {};
 });
 
 afterEach(() => {
@@ -2982,6 +3007,149 @@ describe('WebShellSidebar session source switch', () => {
 
     expect(active.reload).toHaveBeenCalledOnce();
   });
+
+  it('keeps a flat channel list when channel metadata is unavailable', async () => {
+    active.sessions.push({
+      sessionId: 'legacy-channel-session',
+      displayName: 'Legacy channel',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'channel',
+      sourceId: 'legacy-bot',
+    });
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    const channelsTab = Array.from(
+      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
+    ).find((button) => button.textContent?.trim() === 'Channels');
+    await act(async () => {
+      channelsTab!.dispatchEvent(
+        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
+      );
+      channelsTab!.click();
+      await Promise.resolve();
+    });
+
+    expect(container.textContent).toContain('Legacy channel');
+    expect(container.querySelector('section[aria-label]')).toBeNull();
+  });
+
+  it('groups channel sessions by platform type and toggles each group', async () => {
+    const channelCapabilities = {
+      ...capabilities,
+      features: [...capabilities.features, 'channel_management'],
+    };
+    connection.capabilities = channelCapabilities;
+    workspace.capabilities = channelCapabilities;
+    channelState.catalog = [
+      {
+        type: 'dingtalk',
+        displayName: 'DingTalk',
+        manageable: true,
+        fields: [],
+      },
+      {
+        type: 'feishu',
+        displayName: 'Feishu',
+        manageable: true,
+        fields: [],
+      },
+    ];
+    channelState.channels = {
+      'ding-one': {
+        name: 'ding-one',
+        config: { type: 'dingtalk' },
+        secrets: {},
+        startsWithServe: false,
+        runtime: { state: 'connected' },
+      },
+      'ding-two': {
+        name: 'ding-two',
+        config: { type: 'dingtalk' },
+        secrets: {},
+        startsWithServe: false,
+        runtime: { state: 'connected' },
+      },
+      feishu: {
+        name: 'feishu',
+        config: { type: 'feishu' },
+        secrets: {},
+        startsWithServe: false,
+        runtime: { state: 'connected' },
+      },
+    };
+    channelState.data = {
+      catalog: channelState.catalog,
+      snapshot: { revision: '1', instances: channelState.channels },
+    };
+    active.sessions.push(
+      {
+        sessionId: 'ding-one-session',
+        displayName: 'DingTalk one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'ding-one',
+      },
+      {
+        sessionId: 'feishu-session',
+        displayName: 'Feishu one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'feishu',
+      },
+      {
+        sessionId: 'ding-two-session',
+        displayName: 'DingTalk two',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'ding-two',
+        isPinned: true,
+      },
+      {
+        sessionId: 'legacy-channel-session',
+        displayName: 'Legacy channel',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+      },
+    );
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    const channelsTab = Array.from(
+      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
+    ).find((button) => button.textContent?.trim() === 'Channels');
+    await act(async () => {
+      channelsTab!.dispatchEvent(
+        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
+      );
+      channelsTab!.click();
+      await Promise.resolve();
+    });
+
+    const dingTalkGroup = container.querySelector<HTMLElement>(
+      'section[aria-label="DingTalk"]',
+    );
+    expect(dingTalkGroup).not.toBeNull();
+    expect(dingTalkGroup!.textContent).toContain('DingTalk one');
+    expect(dingTalkGroup?.textContent).toContain('DingTalk two');
+    expect(dingTalkGroup?.textContent).not.toContain('Feishu one');
+    expect(
+      container.querySelector('section[aria-label="Feishu"]')?.textContent,
+    ).toContain('Feishu one');
+    expect(
+      container.querySelector('section[aria-label="Other channels"]')
+        ?.textContent,
+    ).toContain('Legacy channel');
+
+    const toggle = dingTalkGroup?.querySelector<HTMLButtonElement>(
+      'button[aria-expanded="true"]',
+    );
+    await act(async () => click(toggle!));
+    expect(toggle?.getAttribute('aria-expanded')).toBe('false');
+    expect(dingTalkGroup?.textContent).not.toContain('DingTalk one');
+    await act(async () => click(toggle!));
+    expect(toggle?.getAttribute('aria-expanded')).toBe('true');
+    expect(dingTalkGroup?.textContent).toContain('DingTalk one');
+  });
 });
 
 describe('WebShellSidebar archived session export', () => {
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index 6e2f5871f70..0b58054c156 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -146,6 +146,8 @@ function renderSection(
     client: DaemonClient;
     reloadToken: number;
     expanded: boolean;
+    sourceType: string;
+    channelGroupingEnabled: boolean;
   }> = {},
 ): void {
   act(() => {
@@ -162,6 +164,8 @@ function renderSection(
           noSessionsLabel="No sessions"
           loadErrorLabel="Load failed"
           organizationEnabled={false}
+          sourceType={overrides.sourceType}
+          channelGroupingEnabled={overrides.channelGroupingEnabled}
           ungroupedLabel="Ungrouped"
           formatTime={() => ''}
           renderSession={(session: DaemonSessionSummary): ReactNode => (
@@ -237,6 +241,78 @@ describe('WorkspaceSection label', () => {
       container.querySelector('[title="A very long session name"]'),
     ).not.toBeNull();
   });
+
+  it('groups a secondary workspace with its own channel catalog', async () => {
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessions: vi.fn().mockResolvedValue([
+          {
+            sessionId: 'ding-session',
+            displayName: 'DingTalk secondary',
+            sourceType: 'channel',
+            sourceId: 'secondary-ding',
+          },
+          {
+            sessionId: 'feishu-session',
+            displayName: 'Feishu secondary',
+            sourceType: 'channel',
+            sourceId: 'secondary-feishu',
+          },
+        ]),
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+        workspaceChannelTypes: vi.fn().mockResolvedValue([
+          {
+            type: 'dingtalk',
+            displayName: 'DingTalk',
+            manageable: true,
+            fields: [],
+          },
+          {
+            type: 'feishu',
+            displayName: 'Feishu',
+            manageable: true,
+            fields: [],
+          },
+        ]),
+        workspaceChannels: vi.fn().mockResolvedValue({
+          revision: '1',
+          instances: {
+            'secondary-ding': {
+              name: 'secondary-ding',
+              config: { type: 'dingtalk' },
+              secrets: {},
+              startsWithServe: false,
+              runtime: { state: 'connected' },
+            },
+            'secondary-feishu': {
+              name: 'secondary-feishu',
+              config: { type: 'feishu' },
+              secrets: {},
+              startsWithServe: false,
+              runtime: { state: 'connected' },
+            },
+          },
+        }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({
+      workspace: { ...trustedWorkspace, primary: false },
+      client,
+      expanded: true,
+      sourceType: 'channel',
+      channelGroupingEnabled: true,
+    });
+    await flush();
+
+    expect(
+      container.querySelector('section[aria-label="DingTalk"]')?.textContent,
+    ).toContain('DingTalk secondary');
+    expect(
+      container.querySelector('section[aria-label="Feishu"]')?.textContent,
+    ).toContain('Feishu secondary');
+  });
 });
 
 describe('WorkspaceSection git chip', () => {
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index 172a4064345..9b55d6140fc 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -8,6 +8,8 @@ import {
 } from 'react';
 import type { DaemonClient } from '@qwen-code/sdk/daemon';
 import type {
+  DaemonChannelsSnapshot,
+  DaemonChannelTypeCatalog,
   DaemonSessionGroup,
   DaemonSessionSummary,
   DaemonWorkspaceCapability,
@@ -24,6 +26,7 @@ import {
 } from './collapsedSessionSections';
 import { workspaceLabel } from '../../utils/workspace';
 import { SessionGroupSection } from './SessionGroupSection';
+import { groupSessionsByChannelType } from './channelSessionGroups';
 import styles from './WorkspaceSection.module.css';
 
 function cx(...classes: Array<string | false | undefined>): string {
@@ -69,6 +72,7 @@ interface WorkspaceSectionProps {
   loadErrorLabel: string;
   organizationEnabled: boolean;
   sourceType?: string;
+  channelGroupingEnabled?: boolean;
   ungroupedLabel: string;
   formatTime: (iso: string) => string;
   searchQuery?: string;
@@ -111,6 +115,7 @@ export function WorkspaceSection({
   loadErrorLabel,
   organizationEnabled,
   sourceType,
+  channelGroupingEnabled = false,
   ungroupedLabel,
   formatTime,
   searchQuery = '',
@@ -131,6 +136,10 @@ export function WorkspaceSection({
 }: WorkspaceSectionProps) {
   const [sessions, setSessions] = useState<DaemonSessionSummary[]>([]);
   const [groups, setGroups] = useState<DaemonSessionGroup[]>([]);
+  const [channelCatalog, setChannelCatalog] = useState<{
+    catalog: DaemonChannelTypeCatalog;
+    snapshot: DaemonChannelsSnapshot;
+  }>();
   const [loadError, setLoadError] = useState(false);
   const [internalExpanded, setInternalExpanded] = useState(false);
   const [collapsedGroupIds, setCollapsedGroupIds] = useState<Set<string>>(() =>
@@ -211,6 +220,38 @@ export function WorkspaceSection({
     workspace.cwd,
   ]);
 
+  useEffect(() => {
+    if (!renderSessions || disabled || !channelGroupingEnabled) {
+      setChannelCatalog(undefined);
+      return;
+    }
+    if (!expanded && !searchQuery.trim()) return;
+    let cancelled = false;
+    const workspaceClient = client.workspaceByCwd(workspace.cwd);
+    void Promise.all([
+      workspaceClient.workspaceChannelTypes(),
+      workspaceClient.workspaceChannels(),
+    ])
+      .then(([catalog, snapshot]) => {
+        if (!cancelled) setChannelCatalog({ catalog, snapshot });
+      })
+      .catch((err: unknown) => {
+        console.warn('[WorkspaceSection] channel catalog load failed:', err);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    channelGroupingEnabled,
+    client,
+    disabled,
+    expanded,
+    reloadToken,
+    renderSessions,
+    searchQuery,
+    workspace.cwd,
+  ]);
+
   useEffect(() => {
     if (!renderSessions) return;
     if (!expanded && !searchQuery.trim()) return;
@@ -315,6 +356,19 @@ export function WorkspaceSection({
     };
   }, [groups, organizationEnabled, visibleSessions]);
 
+  const channelSessionGroups = useMemo(
+    () =>
+      channelCatalog
+        ? groupSessionsByChannelType(
+            visibleSessions,
+            channelCatalog.catalog,
+            channelCatalog.snapshot.instances,
+            t('sidebar.channelType.other'),
+          )
+        : null,
+    [channelCatalog, t, visibleSessions],
+  );
+
   return (
     <div className={styles.section}>
       <div
@@ -395,6 +449,28 @@ export function WorkspaceSection({
               </div>
             ) : visibleSessions.length === 0 ? (
               <div className={styles.empty}>{noSessionsLabel}</div>
+            ) : channelSessionGroups ? (
+              <>
+                {channelSessionGroups.map((group) => (
+                  <SessionGroupSection
+                    id={group.id}
+                    key={group.id}
+                    label={group.label}
+                    count={group.sessions.length}
+                    expanded={!collapsedGroupIds.has(group.id)}
+                    onToggle={() => {
+                      setCollapsedGroupIds((current) => {
+                        const next = new Set(current);
+                        if (next.has(group.id)) next.delete(group.id);
+                        else next.add(group.id);
+                        return next;
+                      });
+                    }}
+                  >
+                    {group.sessions.map((session) => renderSession(session))}
+                  </SessionGroupSection>
+                ))}
+              </>
             ) : groupedSessions ? (
               <>
                 {groupedSessions.sections.map(({ group, sessions }) => (
diff --git a/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
new file mode 100644
index 00000000000..0459a00925e
--- /dev/null
+++ b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  DaemonChannelInstanceSnapshot,
+  DaemonChannelTypeCatalog,
+  DaemonSessionSummary,
+} from '@qwen-code/sdk/daemon';
+import { groupSessionsByChannelType } from './channelSessionGroups';
+
+function session(sessionId: string, sourceId?: string): DaemonSessionSummary {
+  return {
+    sessionId,
+    workspaceCwd: '/workspace',
+    sourceType: 'channel',
+    sourceId,
+  };
+}
+
+const catalog: DaemonChannelTypeCatalog = [
+  { type: 'dingtalk', displayName: 'DingTalk', manageable: true, fields: [] },
+  { type: 'feishu', displayName: 'Feishu', manageable: true, fields: [] },
+];
+
+function instance(name: string, type: string): DaemonChannelInstanceSnapshot {
+  return {
+    name,
+    config: { type },
+    secrets: {},
+    startsWithServe: false,
+    runtime: { state: 'stopped' },
+  };
+}
+
+describe('groupSessionsByChannelType', () => {
+  it('combines channel instances of the same type in first-seen order', () => {
+    const groups = groupSessionsByChannelType(
+      [
+        session('d1', 'ding-one'),
+        session('f1', 'feishu'),
+        session('d2', 'ding-two'),
+      ],
+      catalog,
+      {
+        'ding-one': instance('ding-one', 'dingtalk'),
+        'ding-two': instance('ding-two', 'dingtalk'),
+        feishu: instance('feishu', 'feishu'),
+      },
+      'Other channels',
+    );
+
+    expect(
+      groups.map(({ id, label, sessions }) => ({
+        id,
+        label,
+        sessions: sessions.map((item) => item.sessionId),
+      })),
+    ).toEqual([
+      {
+        id: 'channel-type:dingtalk',
+        label: 'DingTalk',
+        sessions: ['d1', 'd2'],
+      },
+      {
+        id: 'channel-type:feishu',
+        label: 'Feishu',
+        sessions: ['f1'],
+      },
+    ]);
+  });
+
+  it('uses the raw type or fallback group when catalog metadata is incomplete', () => {
+    const groups = groupSessionsByChannelType(
+      [session('github', 'github'), session('legacy')],
+      catalog,
+      { github: instance('github', 'github') },
+      'Other channels',
+    );
+
+    expect(groups.map(({ label }) => label)).toEqual([
+      'github',
+      'Other channels',
+    ]);
+  });
+});
diff --git a/packages/web-shell/client/components/sidebar/channelSessionGroups.ts b/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
new file mode 100644
index 00000000000..bf27b571d74
--- /dev/null
+++ b/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
@@ -0,0 +1,46 @@
+import type {
+  DaemonChannelInstanceSnapshot,
+  DaemonChannelTypeCatalog,
+  DaemonSessionSummary,
+} from '@qwen-code/sdk/daemon';
+
+export interface ChannelSessionGroup {
+  id: string;
+  label: string;
+  sessions: DaemonSessionSummary[];
+}
+
+export function groupSessionsByChannelType(
+  sessions: readonly DaemonSessionSummary[],
+  catalog: DaemonChannelTypeCatalog,
+  instances: Readonly<Record<string, DaemonChannelInstanceSnapshot>>,
+  otherLabel: string,
+): ChannelSessionGroup[] {
+  const labels = new Map(
+    catalog.map((descriptor) => [descriptor.type, descriptor.displayName]),
+  );
+  const groups = new Map<string, ChannelSessionGroup>();
+
+  for (const session of sessions) {
+    const configuredType = session.sourceId
+      ? instances[session.sourceId]?.config['type']
+      : undefined;
+    const type =
+      typeof configuredType === 'string'
+        ? configuredType.trim() || undefined
+        : undefined;
+    const id = type ? `channel-type:${type}` : 'channel-type-fallback';
+    const existing = groups.get(id);
+    if (existing) {
+      existing.sessions.push(session);
+      continue;
+    }
+    groups.set(id, {
+      id,
+      label: type ? (labels.get(type) ?? type) : otherLabel,
+      sessions: [session],
+    });
+  }
+
+  return [...groups.values()];
+}
diff --git a/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts b/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts
index 33c2c744db5..dc88d68ee16 100644
--- a/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts
+++ b/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts
@@ -4,7 +4,7 @@
  * key so preferences survive reload without competing overwrites.
  *
  * Id conventions:
- * - Primary catalog: `group:<id>`, `recent`, `color:<name>`
+ * - Primary catalog: `group:<id>`, `recent`, `color:<name>`, `channel-type:<type>`
  * - Workspace-scoped: `ws:<workspaceId>|group:<id>`, `ws:<workspaceId>|ungrouped`
  */
 
diff --git a/packages/web-shell/client/e2e/web-shell.channels.spec.ts b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
index 065a9ef3985..76323fba7c5 100644
--- a/packages/web-shell/client/e2e/web-shell.channels.spec.ts
+++ b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
@@ -22,8 +22,49 @@ test('shows channel sessions in the sidebar channel catalog', async ({
         'session_permission_vote',
         'session_scope_override',
         'session_source_metadata',
+        'channel_management',
       ],
     },
+    channelTypes: [
+      {
+        type: 'dingtalk',
+        displayName: 'DingTalk',
+        manageable: true,
+        fields: [],
+      },
+      {
+        type: 'feishu',
+        displayName: 'Feishu',
+        manageable: true,
+        fields: [],
+      },
+    ],
+    channels: {
+      revision: '1',
+      instances: {
+        'release-bot': {
+          name: 'release-bot',
+          config: { type: 'dingtalk' },
+          secrets: {},
+          startsWithServe: false,
+          runtime: { state: 'connected' },
+        },
+        'ops-bot': {
+          name: 'ops-bot',
+          config: { type: 'dingtalk' },
+          secrets: {},
+          startsWithServe: false,
+          runtime: { state: 'connected' },
+        },
+        'feishu-main': {
+          name: 'feishu-main',
+          config: { type: 'feishu' },
+          secrets: {},
+          startsWithServe: false,
+          runtime: { state: 'connected' },
+        },
+      },
+    },
     sessions: [
       {
         sessionId: 'task-session',
@@ -36,6 +77,24 @@ test('shows channel sessions in the sidebar channel catalog', async ({
         sourceType: 'channel',
         sourceId: 'release-bot',
       },
+      {
+        sessionId: 'dingtalk-ops-session',
+        displayName: 'DingTalk ops conversation',
+        sourceType: 'channel',
+        sourceId: 'ops-bot',
+        isPinned: true,
+      },
+      {
+        sessionId: 'feishu-session',
+        displayName: 'Feishu conversation',
+        sourceType: 'channel',
+        sourceId: 'feishu-main',
+      },
+      {
+        sessionId: 'legacy-channel-session',
+        displayName: 'Legacy channel conversation',
+        sourceType: 'channel',
+      },
     ],
   });
   const daemon = await installMockDaemon(page, scenario, {
@@ -57,6 +116,26 @@ test('shows channel sessions in the sidebar channel catalog', async ({
     page.getByText('DingTalk conversation', { exact: true }),
   ).toBeVisible();
   await expect(page.getByText('Web Shell task')).toHaveCount(0);
+  const dingTalkGroup = page.getByRole('region', { name: 'DingTalk' });
+  await expect(dingTalkGroup).toContainText('DingTalk conversation');
+  await expect(dingTalkGroup).toContainText('DingTalk ops conversation');
+  await expect(dingTalkGroup).not.toContainText('Feishu conversation');
+  await expect(page.getByRole('region', { name: 'Feishu' })).toContainText(
+    'Feishu conversation',
+  );
+  await expect(
+    page.getByRole('region', { name: 'Other channels' }),
+  ).toContainText('Legacy channel conversation');
+
+  const dingTalkToggle = dingTalkGroup.getByRole('button').first();
+  await expect(dingTalkToggle).toHaveAttribute('aria-expanded', 'true');
+  await dingTalkToggle.click();
+  await expect(dingTalkToggle).toHaveAttribute('aria-expanded', 'false');
+  await expect(
+    page.getByText('DingTalk conversation', { exact: true }),
+  ).toHaveCount(0);
+  await dingTalkToggle.click();
+  await expect(dingTalkToggle).toHaveAttribute('aria-expanded', 'true');
 
   scenario.sessions.push({
     sessionId: 'new-dingtalk-session',
@@ -67,6 +146,7 @@ test('shows channel sessions in the sidebar channel catalog', async ({
   await expect(
     page.getByText('New DingTalk conversation', { exact: true }),
   ).toBeVisible({ timeout: 5_000 });
+  await expect(dingTalkGroup).toContainText('New DingTalk conversation');
 });
 
 test('creates and deletes a typed Channel configuration', async ({
diff --git a/packages/web-shell/client/i18n.tsx b/packages/web-shell/client/i18n.tsx
index 9f2550e60e6..de0d793c3af 100644
--- a/packages/web-shell/client/i18n.tsx
+++ b/packages/web-shell/client/i18n.tsx
@@ -1075,6 +1075,7 @@ const EN: Messages = {
   'sidebar.sessionSource': 'Session source',
   'sidebar.sessionSource.tasks': 'Tasks',
   'sidebar.sessionSource.channels': 'Channels',
+  'sidebar.channelType.other': 'Other channels',
   'sidebar.project': 'Project',
   'sidebar.pinnedSessions': 'Pinned',
   'sidebar.workspaceSelectLabel': 'Workspace',
@@ -3709,6 +3710,7 @@ const ZH: Messages = {
   'sidebar.sessionSource': '会话来源',
   'sidebar.sessionSource.tasks': '任务',
   'sidebar.sessionSource.channels': '频道',
+  'sidebar.channelType.other': '其他频道',
   'sidebar.project': '项目',
   'sidebar.pinnedSessions': '置顶',
   'sidebar.workspaceSelectLabel': '工作区',

From f7085afa0322cb3128c7c5f43baffc665f374af4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=8B=E7=AB=9F?= <dingbingzhi.dbz@alibaba-inc.com>
Date: Tue, 4 Aug 2026 11:07:31 +0800
Subject: [PATCH 05/16] fix(channels): address session review feedback

---
 packages/acp-bridge/src/bridge.test.ts        | 13 +++-
 packages/acp-bridge/src/bridge.ts             |  6 +-
 packages/channels/base/src/AcpBridge.test.ts  | 20 ++++++
 packages/channels/base/src/AcpBridge.ts       | 11 +++-
 .../channels/base/src/ChannelAgentBridge.ts   |  5 ++
 .../channels/base/src/ChannelBase.test.ts     | 40 +++++++++---
 packages/channels/base/src/ChannelBase.ts     | 25 ++++++--
 .../base/src/DaemonChannelBridge.test.ts      | 20 ++++++
 .../channels/base/src/DaemonChannelBridge.ts  | 20 +++++-
 packages/channels/base/src/types.ts           |  2 +
 .../commands/channel/daemon-worker.test.ts    | 54 +++++++++++++++-
 .../cli/src/commands/channel/daemon-worker.ts | 27 ++++++++
 .../channel/memory-intent-classifier.test.ts  | 28 ++++++++-
 .../channel/memory-intent-classifier.ts       | 12 +++-
 .../components/sidebar/WebShellSidebar.tsx    | 30 +++++++--
 ...WebShellSidebar.workspace-removal.test.tsx | 61 ++++++++++++++++---
 .../sidebar/WorkspaceSection.test.tsx         | 42 +++++++++++++
 .../components/sidebar/WorkspaceSection.tsx   | 31 +++++++---
 18 files changed, 399 insertions(+), 48 deletions(-)

diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts
index bdc6c7c6945..cb8106ffc27 100644
--- a/packages/acp-bridge/src/bridge.test.ts
+++ b/packages/acp-bridge/src/bridge.test.ts
@@ -7237,7 +7237,10 @@ describe('createAcpSessionBridge', () => {
       const bridge = makeBridge({
         channelFactory: async () => handle.channel,
       });
-      const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
+      const session = await bridge.spawnOrAttach({
+        workspaceCwd: WS_A,
+        sourceType: 'channel',
+      });
       const sub = (async () => {
         for await (const ev of bridge.subscribeEvents(session.sessionId)) {
           events.push(ev);
@@ -7257,7 +7260,10 @@ describe('createAcpSessionBridge', () => {
         session.sessionId,
         {
           sessionId: session.sessionId,
-          prompt: [{ type: 'text', text: 'queued behind first' }],
+          prompt: [
+            { type: 'text', text: 'hidden context\n\nqueued behind first' },
+          ],
+          _meta: { 'qwen.daemon.promptDisplayText': 'queued behind first' },
         },
         undefined,
         { promptId: 'prompt-second' },
@@ -7303,6 +7309,9 @@ describe('createAcpSessionBridge', () => {
         (startedEvents[0] as BridgeEvent & { data: { text: string } }).data
           .text,
       ).toBe('queued behind first');
+      expect(handle.agent.promptCalls[1]?.prompt).toEqual([
+        { type: 'text', text: 'hidden context\n\nqueued behind first' },
+      ]);
       const completedEvents = events.filter(
         (e) => e.type === 'pending_prompt_completed',
       );
diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts
index 2b97b607b00..96e2a52851a 100644
--- a/packages/acp-bridge/src/bridge.ts
+++ b/packages/acp-bridge/src/bridge.ts
@@ -5482,7 +5482,11 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
         promptId,
         queuedAt,
         ...(originatorClientId !== undefined ? { originatorClientId } : {}),
-        text: extractPromptText(req.prompt),
+        text:
+          entry.sourceType === 'channel' &&
+          typeof req._meta?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] === 'string'
+            ? req._meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]
+            : extractPromptText(req.prompt),
         abortController: pendingAbort,
         state: isQueued ? 'queued' : 'running',
       };
diff --git a/packages/channels/base/src/AcpBridge.test.ts b/packages/channels/base/src/AcpBridge.test.ts
index 9e33aca4002..2b909e5bffd 100644
--- a/packages/channels/base/src/AcpBridge.test.ts
+++ b/packages/channels/base/src/AcpBridge.test.ts
@@ -432,6 +432,26 @@ describe('AcpBridge', () => {
     );
   });
 
+  it('forwards the user-facing prompt projection to the daemon', async () => {
+    const bridge = new AcpBridge({
+      cliEntryPath: '/tmp/qwen',
+      cwd: '/tmp',
+    }) as unknown as TestableAcpBridge;
+    const prompt = vi.fn().mockResolvedValue({});
+    bridge.child = { killed: false, exitCode: null };
+    bridge.connection = { extMethod: vi.fn(), prompt };
+
+    await bridge.prompt('s-1', 'hidden context\n\nhello', {
+      displayText: 'hello',
+    });
+
+    expect(prompt).toHaveBeenCalledWith({
+      sessionId: 's-1',
+      prompt: [{ type: 'text', text: 'hidden context\n\nhello' }],
+      _meta: { 'qwen.daemon.promptDisplayText': 'hello' },
+    });
+  });
+
   it('excludes nested subagent text from the final response', async () => {
     const bridge = new AcpBridge({
       cliEntryPath: '/tmp/qwen',
diff --git a/packages/channels/base/src/AcpBridge.ts b/packages/channels/base/src/AcpBridge.ts
index 881d0d905f5..00107bd404e 100644
--- a/packages/channels/base/src/AcpBridge.ts
+++ b/packages/channels/base/src/AcpBridge.ts
@@ -17,10 +17,12 @@ import type {
 import type {
   AvailableCommand,
   ChannelAgentBridge,
+  ChannelAgentBridgePromptOptions,
   ChannelAgentBridgeSessionOptions,
   ChannelLoopToolHandler,
   ToolCallEvent,
 } from './ChannelAgentBridge.js';
+import { CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY } from './ChannelAgentBridge.js';
 import {
   CHANNEL_LOOP_MCP_SERVER_NAME,
   CLIENT_MCP_MESSAGE_METHOD,
@@ -244,7 +246,7 @@ export class AcpBridge extends EventEmitter implements ChannelAgentBridge {
   async prompt(
     sessionId: string,
     text: string,
-    options?: { imageBase64?: string; imageMimeType?: string },
+    options?: ChannelAgentBridgePromptOptions,
   ): Promise<string> {
     const conn = this.ensureConnection();
 
@@ -280,6 +282,13 @@ export class AcpBridge extends EventEmitter implements ChannelAgentBridge {
       await conn.prompt({
         sessionId,
         prompt: prompt as Array<{ type: 'text'; text: string }>,
+        ...(options?.displayText !== undefined
+          ? {
+              _meta: {
+                [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText,
+              },
+            }
+          : {}),
       });
     } finally {
       this.off('textChunk', onChunk);
diff --git a/packages/channels/base/src/ChannelAgentBridge.ts b/packages/channels/base/src/ChannelAgentBridge.ts
index 3e426fcf3f2..cb5876c5cc0 100644
--- a/packages/channels/base/src/ChannelAgentBridge.ts
+++ b/packages/channels/base/src/ChannelAgentBridge.ts
@@ -3,6 +3,9 @@ import type {
   RequestPermissionResponse,
 } from '@agentclientprotocol/sdk';
 
+export const CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY =
+  'qwen.daemon.promptDisplayText';
+
 export interface AvailableCommand {
   name: string;
   description: string;
@@ -130,6 +133,8 @@ export interface ChannelAgentBridge {
     sessionId: string,
     expectedBindingToken?: object,
   ): Promise<void>;
+  /** Permanently remove an internal bridge session and its persisted data. */
+  deleteSessionData?(sessionId: string): Promise<void>;
   respondToPermission?(
     requestId: string,
     response: RequestPermissionResponse,
diff --git a/packages/channels/base/src/ChannelBase.test.ts b/packages/channels/base/src/ChannelBase.test.ts
index 07c44258379..5fe8b4b05b2 100644
--- a/packages/channels/base/src/ChannelBase.test.ts
+++ b/packages/channels/base/src/ChannelBase.test.ts
@@ -9945,16 +9945,39 @@ describe('ChannelBase', () => {
       expect(secondPrompt).not.toContain('Be concise.');
     });
 
-    it('keeps channel context out of the user-facing prompt text', async () => {
-      const ch = createChannel({ instructions: 'Be concise.' });
+    it('keeps all model-only context out of the user-facing prompt text', async () => {
+      const ch = createChannel({
+        instructions: 'Be concise.',
+        sessionScope: 'thread',
+        groupPolicy: 'open',
+      });
 
-      await ch.handleInbound(envelope({ text: 'hello' }));
+      await ch.handleInbound(
+        envelope({
+          text: 'hello',
+          isGroup: true,
+          isMentioned: true,
+          referencedText: 'earlier message',
+          metadata: 'Issue: hidden metadata',
+          attachments: [
+            {
+              type: 'file',
+              filePath: '/tmp/hidden.txt',
+              mimeType: 'text/plain',
+            },
+          ],
+        }),
+      );
 
       const [sessionId, modelText, options] = (
         bridge.prompt as ReturnType<typeof vi.fn>
       ).mock.calls[0]!;
       expect(sessionId).toEqual(expect.any(String));
       expect(modelText).toContain('Be concise.');
+      expect(modelText).toContain('[User 1]');
+      expect(modelText).toContain('earlier message');
+      expect(modelText).toContain('/tmp/hidden.txt');
+      expect(modelText).toContain('Issue: hidden metadata');
       expect(options).toMatchObject({ displayText: 'hello' });
     });
 
@@ -15473,7 +15496,7 @@ describe('ChannelBase', () => {
           expect.stringContaining(
             '[External event "ci_failed" from github-ci]',
           ),
-          {},
+          { displayText: 'CI failed' },
         );
         expect(ch.proactive).toEqual([
           { chatId: 'group-1', text: 'CI failed because lint broke.' },
@@ -16079,6 +16102,9 @@ describe('ChannelBase', () => {
         const collectedPrompt = (bridge.prompt as ReturnType<typeof vi.fn>).mock
           .calls[1][1] as string;
         expect(collectedPrompt).toContain('follow-up while webhook runs');
+        expect(
+          (bridge.prompt as ReturnType<typeof vi.fn>).mock.calls[1][2],
+        ).toMatchObject({ displayText: 'follow-up while webhook runs' });
       });
 
       it('waits for bridge recovery before resolving a webhook session', async () => {
@@ -16410,7 +16436,7 @@ describe('ChannelBase', () => {
       expect(bridge.prompt).toHaveBeenLastCalledWith(
         expect.any(String),
         '[Loop "daily summary" created by Alice] Scheduled task running unattended: no one is present to answer questions, and your final response is delivered to this chat automatically — do whatever work the task requires, then put the result in your final response instead of trying to deliver it to this chat yourself.\n\npost summary',
-        {},
+        { displayText: 'post summary' },
       );
       expect(ch.proactive).toEqual([
         { chatId: 'group-1', text: 'loop response' },
@@ -17729,7 +17755,7 @@ describe('ChannelBase', () => {
         expect(bridge.prompt).toHaveBeenLastCalledWith(
           's-1',
           '[Loop "daily summary" created by Alice] Scheduled task running unattended: no one is present to answer questions, and your final response is delivered to this chat automatically — do whatever work the task requires, then put the result in your final response instead of trying to deliver it to this chat yourself.\n\npost again',
-          {},
+          { displayText: 'post again' },
         );
         expect(ch.proactive).toEqual([
           { chatId: 'chat1', text: 'second response' },
@@ -18415,7 +18441,7 @@ describe('ChannelBase', () => {
       expect(bridge.prompt).toHaveBeenLastCalledWith(
         expect.any(String),
         'while loop runs',
-        expect.any(Object),
+        { displayText: 'while loop runs' },
       );
     });
 
diff --git a/packages/channels/base/src/ChannelBase.ts b/packages/channels/base/src/ChannelBase.ts
index ecac0f40cae..30252df4746 100644
--- a/packages/channels/base/src/ChannelBase.ts
+++ b/packages/channels/base/src/ChannelBase.ts
@@ -269,7 +269,11 @@ type PendingPermissionLookup =
   | { kind: 'found'; pending: PendingPermission }
   | { kind: 'none'; explicit: boolean }
   | { kind: 'ambiguous'; requestIds: string[] };
-type CollectBufferEntry = { text: string; envelope: Envelope };
+type CollectBufferEntry = {
+  text: string;
+  displayText: string;
+  envelope: Envelope;
+};
 type ActivePrompt = {
   runId: string;
   owner?: ChannelPromptOwner;
@@ -1408,11 +1412,13 @@ export abstract class ChannelBase {
     this.collectBuffers.delete(sessionId);
     const lost = buffer.length;
     const coalesced = buffer.map((b) => b.text).join('\n\n');
+    const coalescedDisplayText = buffer.map((b) => b.displayText).join('\n\n');
     const lastEnvelope = buffer[buffer.length - 1]!.envelope;
     this.notifyPromptBufferDrained(lastEnvelope.chatId, sessionId, buffer);
     const syntheticEnvelope: Envelope = {
       ...lastEnvelope,
       text: coalesced,
+      displayText: coalescedDisplayText,
       alreadyPrefixed: true,
       referencedText: undefined,
       attachments: undefined,
@@ -1635,6 +1641,7 @@ export abstract class ChannelBase {
           promptBridge,
           sessionId,
           promptToSend,
+          job.prompt,
           promptState,
           job.id,
           options.timeoutMs,
@@ -1806,6 +1813,9 @@ export abstract class ChannelBase {
       },
     );
     const promptText = buildChannelWebhookPrompt(task, target);
+    const displayText = [task.title, task.summary]
+      .filter((part): part is string => Boolean(part))
+      .join('\n\n');
     const taskId = `webhook:${task.source}:${task.eventType}`;
     const safeTaskId = sanitizeLogText(taskId, 64);
     const safeChannel = sanitizeLogText(this.name, 64);
@@ -1931,6 +1941,7 @@ export abstract class ChannelBase {
           promptBridge,
           sessionId,
           promptToSend,
+          displayText,
           promptState,
           taskId,
           options.timeoutMs,
@@ -2035,11 +2046,12 @@ export abstract class ChannelBase {
     promptBridge: ChannelAgentBridge,
     sessionId: string,
     promptText: string,
+    displayText: string,
     promptState: ActivePrompt,
     jobId: string,
     timeoutMs: number | undefined,
   ): Promise<string> {
-    const prompt = promptBridge.prompt(sessionId, promptText, {});
+    const prompt = promptBridge.prompt(sessionId, promptText, { displayText });
     prompt.catch(() => {});
     if (timeoutMs === undefined) {
       return prompt;
@@ -4950,6 +4962,7 @@ export abstract class ChannelBase {
       this.observedContactEnvelopes.add(envelope);
       await this.recordObservedContact(envelope);
     }
+    const displayText = envelope.displayText ?? envelope.text;
 
     let memoryIntent: ResolvedChannelMemoryIntent | null =
       parseChannelMemoryIntent(envelope.text);
@@ -5197,7 +5210,7 @@ export abstract class ChannelBase {
             buffer = [];
             this.collectBuffers.set(sessionId, buffer);
           }
-          buffer.push({ text: promptText, envelope });
+          buffer.push({ text: promptText, displayText, envelope });
           try {
             this.onPromptBuffered(
               envelope.chatId,
@@ -5530,7 +5543,7 @@ export abstract class ChannelBase {
         const response = await promptBridge.prompt(sessionId, promptToSend, {
           imageBase64,
           imageMimeType,
-          displayText: promptText,
+          displayText,
         });
 
         await this.settleCancelRequested(promptState);
@@ -5681,6 +5694,9 @@ export abstract class ChannelBase {
           this.collectBuffers.delete(sessionId);
           const lost = buffer.length;
           const coalesced = buffer.map((b) => b.text).join('\n\n');
+          const coalescedDisplayText = buffer
+            .map((b) => b.displayText)
+            .join('\n\n');
           const lastEnvelope = buffer[buffer.length - 1]!.envelope;
           this.notifyPromptBufferDrained(
             lastEnvelope.chatId,
@@ -5691,6 +5707,7 @@ export abstract class ChannelBase {
           const syntheticEnvelope: Envelope = {
             ...lastEnvelope,
             text: coalesced,
+            displayText: coalescedDisplayText,
             // Coalesced text already carries each message's [sender] prefix.
             alreadyPrefixed: true,
             // Clear attachments/references — already resolved in original text
diff --git a/packages/channels/base/src/DaemonChannelBridge.test.ts b/packages/channels/base/src/DaemonChannelBridge.test.ts
index 02d8903df8c..d3410beb4ae 100644
--- a/packages/channels/base/src/DaemonChannelBridge.test.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.test.ts
@@ -131,6 +131,26 @@ function turnCompleteEvent(sessionId = 'session-1'): DaemonChannelEvent {
 }
 
 describe('DaemonChannelBridge', () => {
+  it('deletes an internal session through its owning workspace', async () => {
+    const events = new EventQueue();
+    const session = createFakeSession(events);
+    const deleteSessionData = vi.fn().mockResolvedValue(undefined);
+    const bridge = new DaemonChannelBridge({
+      cwd: '/repo',
+      sessionFactory: vi.fn().mockResolvedValue(session),
+      deleteSessionData,
+    });
+
+    await bridge.start();
+    await bridge.newSession('/repo');
+    await bridge.deleteSessionData?.('session-1');
+
+    expect(deleteSessionData).toHaveBeenCalledWith('session-1', '/repo');
+    expect(bridge.listSessions()).toEqual([]);
+    events.close();
+    bridge.stop();
+  });
+
   it('registers the loop MCP server for the exact daemon session', async () => {
     const events = new EventQueue();
     const session = createFakeSession(events);
diff --git a/packages/channels/base/src/DaemonChannelBridge.ts b/packages/channels/base/src/DaemonChannelBridge.ts
index a5fd71deee2..a82b0c66bdf 100644
--- a/packages/channels/base/src/DaemonChannelBridge.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.ts
@@ -12,6 +12,7 @@ import type {
   ChannelLoopToolHandler,
   ToolCallEvent,
 } from './ChannelAgentBridge.js';
+import { CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY } from './ChannelAgentBridge.js';
 import { readAvailableCommandAltNames } from './AcpBridge.js';
 import {
   ChannelLoopMcpServer,
@@ -20,7 +21,6 @@ import {
 import type { SessionScope } from './types.js';
 
 const MAX_RESPONDED_PERMISSION_REQUESTS = 256;
-const DAEMON_PROMPT_DISPLAY_TEXT_META_KEY = 'qwen.daemon.promptDisplayText';
 
 export interface DaemonChannelEvent {
   id?: number;
@@ -87,6 +87,10 @@ export interface DaemonChannelBridgeOptions {
   modelServiceId?: string;
   sessionScope?: SessionScope;
   channelLoopMcpHost?: DaemonChannelLoopMcpHost;
+  deleteSessionData?: (
+    sessionId: string,
+    workspaceCwd: string,
+  ) => Promise<void>;
 }
 
 export interface DaemonPermissionRequestEvent {
@@ -234,10 +238,22 @@ export class DaemonChannelBridge
   private lifecycleGeneration = 0;
   private latestAvailableCommandsSessionId: string | undefined;
   private lastError: unknown;
+  readonly deleteSessionData?: (sessionId: string) => Promise<void>;
 
   constructor(options: DaemonChannelBridgeOptions) {
     super();
     this.options = options;
+    const deleteSessionData = options.deleteSessionData;
+    if (deleteSessionData) {
+      this.deleteSessionData = async (sessionId) => {
+        const session = this.ensureSession(sessionId);
+        try {
+          await deleteSessionData(sessionId, session.workspaceCwd);
+        } finally {
+          this.removeSessionBinding(sessionId);
+        }
+      };
+    }
     this.on('error', (error) => {
       this.lastError = error;
     });
@@ -413,7 +429,7 @@ export class DaemonChannelBridge
           ...(options?.displayText !== undefined
             ? {
                 _meta: {
-                  [DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText,
+                  [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText,
                 },
               }
             : {}),
diff --git a/packages/channels/base/src/types.ts b/packages/channels/base/src/types.ts
index f5338cc5646..aba8cb92fc0 100644
--- a/packages/channels/base/src/types.ts
+++ b/packages/channels/base/src/types.ts
@@ -106,6 +106,8 @@ export interface Envelope {
   chatId: string;
   chatName?: string;
   text: string;
+  /** User-authored text to display when `text` contains model-only context. */
+  displayText?: string;
   threadId?: string;
   /** Platform-specific message ID for response correlation. */
   messageId?: string;
diff --git a/packages/cli/src/commands/channel/daemon-worker.test.ts b/packages/cli/src/commands/channel/daemon-worker.test.ts
index 2c297c9b93e..234efa5db8d 100644
--- a/packages/cli/src/commands/channel/daemon-worker.test.ts
+++ b/packages/cli/src/commands/channel/daemon-worker.test.ts
@@ -155,7 +155,7 @@ const mockChannelLoopScheduler = vi.hoisted(() =>
   })),
 );
 const mockDaemonChannelBridge = vi.hoisted(() =>
-  vi.fn(() => ({
+  vi.fn((_options?: unknown) => ({
     get availableCommands() {
       return [];
     },
@@ -306,6 +306,11 @@ const deliveryRequest = {
 };
 
 function createSdk() {
+  const deleteSessionsData = vi.fn().mockResolvedValue({
+    removed: ['classifier-session'],
+    notFound: [],
+    errors: [],
+  });
   const client = {
     capabilities: vi.fn().mockResolvedValue({
       v: 1,
@@ -314,6 +319,7 @@ function createSdk() {
       modelServices: [],
       workspaceCwd: '/workspace',
     }),
+    workspaceByCwd: vi.fn(() => ({ deleteSessionsData })),
   };
   const DaemonClient = vi.fn(() => client);
   const DaemonSessionClient = {
@@ -336,7 +342,7 @@ function createSdk() {
       respondToPermission: vi.fn(),
     }),
   };
-  return { client, DaemonClient, DaemonSessionClient };
+  return { client, DaemonClient, DaemonSessionClient, deleteSessionsData };
 }
 
 beforeEach(() => {
@@ -645,6 +651,27 @@ describe('createDaemonChannelBridgeFacade', () => {
     expect(respondToPermission).toHaveBeenCalledWith('req-1', response);
   });
 
+  it('forwards permanent internal-session deletion when present', async () => {
+    const deleteSessionData = vi.fn().mockResolvedValue(undefined);
+    const bridge = {
+      availableCommands: [],
+      on: mockBridgeOn,
+      off: mockBridgeOff,
+      newSession: mockBridgeNewSession,
+      loadSession: mockBridgeLoadSession,
+      prompt: mockBridgePrompt,
+      cancelSession: mockBridgeCancelSession,
+      deleteSessionData,
+    };
+    const facade = createDaemonChannelBridgeFacade(bridge, {
+      exposeShellCommand: false,
+    });
+
+    await facade.deleteSessionData?.('classifier-session');
+
+    expect(deleteSessionData).toHaveBeenCalledWith('classifier-session');
+  });
+
   it('omits permission responses when absent on bridge', () => {
     const bridge = {
       availableCommands: [],
@@ -662,6 +689,7 @@ describe('createDaemonChannelBridgeFacade', () => {
 
     expect('respondToPermission' in facade).toBe(false);
     expect('discardSession' in facade).toBe(false);
+    expect('deleteSessionData' in facade).toBe(false);
   });
 
   it('omits listSessions when absent on bridge', () => {
@@ -711,6 +739,28 @@ describe('createDaemonChannelBridgeFacade', () => {
 });
 
 describe('runChannelDaemonWorker', () => {
+  it('wires permanent classifier-session deletion to the owning workspace', async () => {
+    const sdk = createSdk();
+    const handle = await runChannelDaemonWorker({
+      daemonUrl: 'http://127.0.0.1:4170',
+      workspace: '/workspace',
+      selection: { mode: 'names', names: ['telegram'] },
+      loadDaemonSdk: async () => sdk,
+    });
+    const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
+      deleteSessionData?: (
+        sessionId: string,
+        workspaceCwd: string,
+      ) => Promise<void>;
+    };
+
+    await options.deleteSessionData?.('classifier-session', '/workspace');
+
+    expect(sdk.client.workspaceByCwd).toHaveBeenCalledWith('/workspace');
+    expect(sdk.deleteSessionsData).toHaveBeenCalledWith(['classifier-session']);
+    await handle.close();
+  });
+
   it('forwards router discard through the daemon bridge facade', async () => {
     const sdk = createSdk();
     const handle = await runChannelDaemonWorker({
diff --git a/packages/cli/src/commands/channel/daemon-worker.ts b/packages/cli/src/commands/channel/daemon-worker.ts
index 11764342fba..54f9158d647 100644
--- a/packages/cli/src/commands/channel/daemon-worker.ts
+++ b/packages/cli/src/commands/channel/daemon-worker.ts
@@ -110,6 +110,13 @@ interface DaemonCapabilitiesLike {
 
 interface DaemonClientLike {
   capabilities(): Promise<DaemonCapabilitiesLike>;
+  workspaceByCwd?(cwd: string): {
+    deleteSessionsData(sessionIds: string[]): Promise<{
+      removed: string[];
+      notFound: string[];
+      errors: Array<{ sessionId: string; error: string }>;
+    }>;
+  };
 }
 
 interface DaemonSessionClientStaticLike {
@@ -245,6 +252,10 @@ export function createDaemonChannelBridgeFacade(
     facade.discardSession = bridge.discardSession.bind(bridge);
   }
 
+  if (bridge.deleteSessionData) {
+    facade.deleteSessionData = bridge.deleteSessionData.bind(bridge);
+  }
+
   if (bridge.getAvailableCommands) {
     facade.getAvailableCommands = bridge.getAvailableCommands.bind(bridge);
   }
@@ -472,6 +483,22 @@ export async function runChannelDaemonWorker(
       DaemonSessionClient: sdk.DaemonSessionClient,
       clientId: `qwen-channel-worker:${process.pid}`,
     }),
+    deleteSessionData: async (sessionId, workspaceCwd) => {
+      const workspaceClient = client.workspaceByCwd?.(workspaceCwd);
+      if (!workspaceClient) {
+        throw new Error('Daemon SDK does not support session data deletion.');
+      }
+      const result = await workspaceClient.deleteSessionsData([sessionId]);
+      if (
+        !result.removed.includes(sessionId) &&
+        !result.notFound.includes(sessionId)
+      ) {
+        const detail = result.errors.find(
+          (entry) => entry.sessionId === sessionId,
+        )?.error;
+        throw new Error(detail ?? `Session ${sessionId} was not deleted.`);
+      }
+    },
     ...(modelServiceId ? { modelServiceId } : {}),
     ...(opts.channelLoopMcpHost
       ? { channelLoopMcpHost: opts.channelLoopMcpHost }
diff --git a/packages/cli/src/commands/channel/memory-intent-classifier.test.ts b/packages/cli/src/commands/channel/memory-intent-classifier.test.ts
index ab00ab43a16..0115021a76d 100644
--- a/packages/cli/src/commands/channel/memory-intent-classifier.test.ts
+++ b/packages/cli/src/commands/channel/memory-intent-classifier.test.ts
@@ -56,11 +56,35 @@ describe('BridgeChannelMemoryIntentClassifier', () => {
     expect(bridge.prompt).toHaveBeenCalledWith(
       'classifier-session',
       expect.stringContaining('"你记一下以后回复前说 1122"'),
-      {},
+      { displayText: '' },
     );
     expect(bridge.cancelSession).toHaveBeenCalledWith('classifier-session');
   });
 
+  it('discards the internal classifier session when supported', async () => {
+    const bridge = bridgeWithResponse('{"intent":"none","confidence":0.9}');
+    bridge.discardSession = vi.fn();
+    const classifier = new BridgeChannelMemoryIntentClassifier(bridge, '/tmp');
+
+    await classifier.classifyChannelMemoryIntent('memory architecture');
+
+    expect(bridge.discardSession).toHaveBeenCalledWith('classifier-session');
+    expect(bridge.cancelSession).not.toHaveBeenCalled();
+  });
+
+  it('permanently deletes the internal classifier session when supported', async () => {
+    const bridge = bridgeWithResponse('{"intent":"none","confidence":0.9}');
+    bridge.discardSession = vi.fn();
+    bridge.deleteSessionData = vi.fn();
+    const classifier = new BridgeChannelMemoryIntentClassifier(bridge, '/tmp');
+
+    await classifier.classifyChannelMemoryIntent('memory architecture');
+
+    expect(bridge.deleteSessionData).toHaveBeenCalledWith('classifier-session');
+    expect(bridge.discardSession).not.toHaveBeenCalled();
+    expect(bridge.cancelSession).not.toHaveBeenCalled();
+  });
+
   it('canonicalizes plural facts and asks the model to split independent durable facts', async () => {
     const { bridge, classifier } = classifierFor(
       '{"intent":"remember","memories":["默认使用 staging","回复使用中文"],"confidence":0.93}',
@@ -402,7 +426,7 @@ describe('BridgeChannelMemoryIntentClassifier', () => {
       confidence: 0.93,
     });
     expect(stderrSpy).toHaveBeenCalledWith(
-      '[classifier] cancelSession failed: transport closed\n',
+      '[classifier] session cleanup failed: transport closed\n',
     );
     stderrSpy.mockRestore();
   });
diff --git a/packages/cli/src/commands/channel/memory-intent-classifier.ts b/packages/cli/src/commands/channel/memory-intent-classifier.ts
index bb630b039ee..37010039110 100644
--- a/packages/cli/src/commands/channel/memory-intent-classifier.ts
+++ b/packages/cli/src/commands/channel/memory-intent-classifier.ts
@@ -223,7 +223,7 @@ export class BridgeChannelMemoryIntentClassifier
       const response = await bridge.prompt(
         sessionId,
         `${CLASSIFIER_PROMPT}${JSON.stringify(text)}${buildMemoryManifest(entries)}`,
-        {},
+        { displayText: '' },
       );
       try {
         return normalizeClassifierResult(extractJsonObject(response), entries);
@@ -234,11 +234,17 @@ export class BridgeChannelMemoryIntentClassifier
       }
     } finally {
       try {
-        await bridge.cancelSession(sessionId);
+        if (bridge.deleteSessionData) {
+          await bridge.deleteSessionData(sessionId);
+        } else if (bridge.discardSession) {
+          await bridge.discardSession(sessionId);
+        } else {
+          await bridge.cancelSession(sessionId);
+        }
       } catch (error) {
         // session cleanup must not mask a successful classification
         process.stderr.write(
-          `[classifier] cancelSession failed: ${sanitizeLogText(
+          `[classifier] session cleanup failed: ${sanitizeLogText(
             error instanceof Error ? error.message : String(error),
             200,
           )}\n`,
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 7f1911e1236..fe6c1bdc662 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -120,6 +120,17 @@ const DEFAULT_CUSTOM_GROUP_COLOR: DaemonSessionGroupHexColor = '#416ef5';
 
 type SidebarSessionSource = 'default' | 'channel';
 
+function matchesSessionSource(
+  session: DaemonSessionSummary,
+  source: SidebarSessionSource | undefined,
+): boolean {
+  if (source === 'channel') return session.sourceType === 'channel';
+  if (source === 'default') {
+    return session.sourceType === undefined || session.sourceType === 'default';
+  }
+  return true;
+}
+
 function getSessionIdentity(
   sessionId: string,
   workspaceCwd: string | undefined,
@@ -644,10 +655,12 @@ export function WebShellSidebar({
     !organizationEnabled ||
     !includePrimaryWorkspaceSessions ||
     sessionsPage !== undefined;
+  const loadPinnedSessions =
+    organizationEnabled && selectedSessionSource !== 'channel';
   const { sessions: primaryPinnedSessions, reload: reloadPinnedSessions } =
     useSessions({
-      autoLoad: organizationEnabled,
-      enabled: organizationEnabled && includePrimaryWorkspaceSessions,
+      autoLoad: loadPinnedSessions,
+      enabled: loadPinnedSessions && includePrimaryWorkspaceSessions,
       pageSize: SESSION_LIST_PAGE_SIZE,
       archiveState: 'active',
       ...(selectedSessionSource ? { sourceType: selectedSessionSource } : {}),
@@ -840,6 +853,7 @@ export function WebShellSidebar({
       ...(includePrimaryWorkspaceSessions ? primaryPinnedSessions : []),
       ...secondaryPinnedSessions,
     ]) {
+      if (!matchesSessionSource(session, selectedSessionSource)) continue;
       byId.set(
         getSessionIdentity(
           session.sessionId,
@@ -853,6 +867,7 @@ export function WebShellSidebar({
     includePrimaryWorkspaceSessions,
     primaryWorkspaceCwd,
     primaryPinnedSessions,
+    selectedSessionSource,
     secondaryPinnedSessions,
   ]);
   const resolveSessionWorkspaceScope = useCallback(
@@ -1067,7 +1082,7 @@ export function WebShellSidebar({
   );
 
   useEffect(() => {
-    if (!organizationEnabled) {
+    if (!organizationEnabled || selectedSessionSource === 'channel') {
       setSecondaryPinnedSessions([]);
       return;
     }
@@ -1117,6 +1132,7 @@ export function WebShellSidebar({
       ...(includePrimaryWorkspaceSessions ? archivedSessions : []),
       ...secondaryArchivedSessions,
     ]) {
+      if (!matchesSessionSource(session, selectedSessionSource)) continue;
       byIdentity.set(getIdentityForSession(session), session);
     }
     return [...byIdentity.values()];
@@ -1124,6 +1140,7 @@ export function WebShellSidebar({
     archivedSessions,
     getIdentityForSession,
     includePrimaryWorkspaceSessions,
+    selectedSessionSource,
     secondaryArchivedSessions,
   ]);
   const effectiveArchivedLoading =
@@ -2561,10 +2578,13 @@ export function WebShellSidebar({
 
   const filteredSessions = useMemo(() => {
     const query = searchQuery.trim().toLowerCase();
+    const sourceScopedSessions = sessions.filter((session) =>
+      matchesSessionSource(session, selectedSessionSource),
+    );
     const unpinnedSessions =
       selectedSessionSource === 'channel'
-        ? sessions
-        : sessions.filter((session) => !session.isPinned);
+        ? sourceScopedSessions
+        : sourceScopedSessions.filter((session) => !session.isPinned);
     const nextSessions = query
       ? unpinnedSessions.filter((session) => {
           const label = getSessionLabel(session).toLowerCase();
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index f139222ab85..93de9743a69 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -59,8 +59,11 @@ const {
   const active = makeSessions();
   const archived = makeSessions();
   const useSessions = vi.fn(
-    (options?: { archiveState?: string; sourceType?: string }) =>
-      options?.archiveState === 'archived' ? archived : active,
+    (options?: {
+      archiveState?: string;
+      sourceType?: string;
+      group?: string;
+    }) => (options?.archiveState === 'archived' ? archived : active),
   );
   const exportArchivedSession = vi.fn();
   const sessionActions = { renameSession: vi.fn() };
@@ -2916,6 +2919,42 @@ describe('WebShellSidebar primary workspace header', () => {
 });
 
 describe('WebShellSidebar session source switch', () => {
+  it('never renders primary sessions from the inactive source', async () => {
+    active.sessions.push(
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+      },
+      {
+        sessionId: 'channel-session',
+        displayName: 'Channel session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+      },
+    );
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    expect(container.textContent).toContain('Task session');
+    expect(container.textContent).not.toContain('Channel session');
+
+    const channelsTab = Array.from(
+      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
+    ).find((button) => button.textContent?.trim() === 'Channels');
+    await act(async () => {
+      channelsTab!.dispatchEvent(
+        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
+      );
+      channelsTab!.click();
+      await Promise.resolve();
+    });
+
+    expect(container.textContent).not.toContain('Task session');
+    expect(container.textContent).toContain('Channel session');
+  });
+
   it('switches primary and workspace-qualified lists from tasks to channels', async () => {
     renderSidebar();
 
@@ -2931,10 +2970,11 @@ describe('WebShellSidebar session source switch', () => {
     expect(tasksTab?.getAttribute('data-state')).toBe('active');
     expect(channelsTab).toBeDefined();
     expect(
-      useSessions.mock.calls.some(
-        ([options]) => options?.sourceType === 'default',
-      ),
-    ).toBe(true);
+      useSessions.mock.calls.find(
+        ([options]) =>
+          options?.archiveState === 'active' && options.group !== 'pinned',
+      )?.[0]?.sourceType,
+    ).toBe('default');
 
     await act(async () => {
       channelsTab!.dispatchEvent(
@@ -2946,10 +2986,11 @@ describe('WebShellSidebar session source switch', () => {
 
     expect(channelsTab?.getAttribute('data-state')).toBe('active');
     expect(
-      useSessions.mock.calls.some(
-        ([options]) => options?.sourceType === 'channel',
-      ),
-    ).toBe(true);
+      useSessions.mock.calls.findLast(
+        ([options]) =>
+          options?.archiveState === 'active' && options.group !== 'pinned',
+      )?.[0]?.sourceType,
+    ).toBe('channel');
 
     await expandWorkspace('other');
     expect(
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index 0b58054c156..67c72b2da50 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -242,6 +242,48 @@ describe('WorkspaceSection label', () => {
     ).not.toBeNull();
   });
 
+  it('does not render sessions loaded for the previous source', async () => {
+    let resolveChannel: (sessions: DaemonSessionSummary[]) => void = () => {};
+    const channelSessions = new Promise<DaemonSessionSummary[]>((resolve) => {
+      resolveChannel = resolve;
+    });
+    const listWorkspaceSessions = vi.fn((options?: { sourceType?: string }) =>
+      options?.sourceType === 'channel'
+        ? channelSessions
+        : Promise.resolve([
+            {
+              sessionId: 'task-session',
+              displayName: 'Task session',
+              sourceType: 'default',
+            },
+          ]),
+    );
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessions,
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({ client, expanded: true, sourceType: 'default' });
+    await flush();
+    expect(container.textContent).toContain('Task session');
+
+    renderSection({ client, expanded: true, sourceType: 'channel' });
+    expect(container.textContent).not.toContain('Task session');
+
+    resolveChannel([
+      {
+        sessionId: 'channel-session',
+        displayName: 'Channel session',
+        sourceType: 'channel',
+      },
+    ]);
+    await flush();
+    expect(container.textContent).toContain('Channel session');
+  });
+
   it('groups a secondary workspace with its own channel catalog', async () => {
     const client = {
       workspaceByCwd: vi.fn(() => ({
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index 9b55d6140fc..2cb376e5d10 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -135,6 +135,9 @@ export function WorkspaceSection({
   onOpenCommit,
 }: WorkspaceSectionProps) {
   const [sessions, setSessions] = useState<DaemonSessionSummary[]>([]);
+  const [sessionsSourceType, setSessionsSourceType] = useState(
+    sourceType ?? '',
+  );
   const [groups, setGroups] = useState<DaemonSessionGroup[]>([]);
   const [channelCatalog, setChannelCatalog] = useState<{
     catalog: DaemonChannelTypeCatalog;
@@ -148,10 +151,12 @@ export function WorkspaceSection({
   const [actionsVisible, setActionsVisible] = useState(false);
   const [gitStatus, setGitStatus] = useState<DaemonWorkspaceGitStatus>();
   const [branchPickerOpen, setBranchPickerOpen] = useState(false);
+  const sessionLoadRequestId = useRef(0);
   const { t } = useI18n();
   const expanded = controlledExpanded ?? internalExpanded;
   const readOnly = !workspace.primary && !workspace.trusted;
   const disabled = workspace.primary && !workspace.trusted;
+  const searchActive = searchQuery.trim().length > 0;
 
   // A workspace always starts collapsed, including the primary workspace.
   useEffect(() => {
@@ -172,6 +177,7 @@ export function WorkspaceSection({
 
   const loadSessions = useCallback(async () => {
     if (disabled) return;
+    const requestId = ++sessionLoadRequestId.current;
     try {
       const result = await client
         .workspaceByCwd(workspace.cwd)
@@ -183,13 +189,18 @@ export function WorkspaceSection({
             ? { view: 'organized' as const, group: 'all' }
             : {}),
         });
-      setSessions(result);
-      setLoadError(false);
+      if (requestId === sessionLoadRequestId.current) {
+        setSessions(result);
+        setSessionsSourceType(sourceType ?? '');
+        setLoadError(false);
+      }
     } catch (err) {
       // Surface connectivity failures so users can distinguish a broken
       // daemon from genuinely zero sessions.
       console.warn('[WorkspaceSection] session poll failed:', err);
-      setLoadError(true);
+      if (requestId === sessionLoadRequestId.current) {
+        setLoadError(true);
+      }
     }
   }, [client, disabled, organizationEnabled, sourceType, workspace.cwd]);
 
@@ -221,11 +232,11 @@ export function WorkspaceSection({
   ]);
 
   useEffect(() => {
-    if (!renderSessions || disabled || !channelGroupingEnabled) {
+    if (!renderSessions || disabled || readOnly || !channelGroupingEnabled) {
       setChannelCatalog(undefined);
       return;
     }
-    if (!expanded && !searchQuery.trim()) return;
+    if (!expanded && !searchActive) return;
     let cancelled = false;
     const workspaceClient = client.workspaceByCwd(workspace.cwd);
     void Promise.all([
@@ -246,15 +257,16 @@ export function WorkspaceSection({
     client,
     disabled,
     expanded,
+    readOnly,
     reloadToken,
     renderSessions,
-    searchQuery,
+    searchActive,
     workspace.cwd,
   ]);
 
   useEffect(() => {
     if (!renderSessions) return;
-    if (!expanded && !searchQuery.trim()) return;
+    if (!expanded && !searchActive) return;
     void loadSessions();
     if (readOnly) return;
     const timer = setInterval(() => void loadSessions(), 10_000);
@@ -265,7 +277,7 @@ export function WorkspaceSection({
     readOnly,
     reloadToken,
     renderSessions,
-    searchQuery,
+    searchActive,
   ]);
 
   // Undefined when `cwd` is not a real path (synthetic fallback workspace), so
@@ -327,6 +339,7 @@ export function WorkspaceSection({
   ]);
 
   const visibleSessions = useMemo(() => {
+    if (sessionsSourceType !== (sourceType ?? '')) return [];
     const query = searchQuery.trim().toLowerCase();
     return sessions.filter((session) => {
       if (excludePinned && session.isPinned) return false;
@@ -336,7 +349,7 @@ export function WorkspaceSection({
         label.includes(query) || session.sessionId.toLowerCase().includes(query)
       );
     });
-  }, [excludePinned, searchQuery, sessions]);
+  }, [excludePinned, searchQuery, sessions, sessionsSourceType, sourceType]);
 
   const groupedSessions = useMemo(() => {
     if (!organizationEnabled || groups.length === 0) return null;

From 7b8cb27b211d8f269ee1787f2cf47a45175d785a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=8B=E7=AB=9F?= <dingbingzhi.dbz@alibaba-inc.com>
Date: Tue, 4 Aug 2026 11:16:50 +0800
Subject: [PATCH 06/16] test(web-shell): harden channel session coverage

---
 .../core/src/services/sessionService.test.ts  | 24 +++++++
 ...WebShellSidebar.workspace-removal.test.tsx | 68 +++++++++++++------
 .../sidebar/WorkspaceSection.test.tsx         | 21 +++++-
 .../sidebar/channelSessionGroups.test.ts      | 26 +++++--
 4 files changed, 111 insertions(+), 28 deletions(-)

diff --git a/packages/core/src/services/sessionService.test.ts b/packages/core/src/services/sessionService.test.ts
index 6817b53fb5f..108322c4b00 100644
--- a/packages/core/src/services/sessionService.test.ts
+++ b/packages/core/src/services/sessionService.test.ts
@@ -388,6 +388,30 @@ describe('SessionService', () => {
       expect(result.items[0].prompt).toBe('hello');
     });
 
+    it('should keep an intentionally empty display prompt empty', async () => {
+      readdirSyncSpy.mockReturnValue([
+        `${sessionIdA}.jsonl`,
+      ] as unknown as Array<fs.Dirent<Buffer>>);
+      statSyncSpy.mockReturnValue({
+        mtimeMs: Date.now(),
+        isFile: () => true,
+      } as fs.Stats);
+      vi.mocked(jsonl.readLines).mockResolvedValue([
+        {
+          ...recordA1,
+          message: {
+            role: 'user',
+            parts: [{ text: 'internal channel instructions' }],
+          },
+          systemPayload: { displayText: '' },
+        },
+      ]);
+
+      const result = await sessionService.listSessions();
+
+      expect(result.items[0].prompt).toBe('');
+    });
+
     it('should NOT populate messageCount during listing', async () => {
       // Listing must avoid the full-file readline that counting requires
       // — message counts are now lazy and provided by
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 93de9743a69..80c4444380e 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -16,6 +16,7 @@ const {
   active,
   archived,
   useSessions,
+  useChannels,
   listWorkspaceSessions,
   archiveSessionsData,
   unarchiveSessionsData,
@@ -67,6 +68,27 @@ const {
   );
   const exportArchivedSession = vi.fn();
   const sessionActions = { renameSession: vi.fn() };
+  const channelState = {
+    data: undefined as
+      | {
+          catalog: Array<{
+            type: string;
+            displayName: string;
+            manageable: boolean;
+            fields: [];
+          }>;
+          snapshot: { revision: string; instances: Record<string, unknown> };
+        }
+      | undefined,
+    catalog: [] as Array<{
+      type: string;
+      displayName: string;
+      manageable: boolean;
+      fields: [];
+    }>,
+    channels: {} as Record<string, unknown>,
+  };
+  const useChannels = vi.fn(() => channelState);
   return {
     connection: {
       status: 'connected',
@@ -109,6 +131,7 @@ const {
     active,
     archived,
     useSessions,
+    useChannels,
     listWorkspaceSessions,
     archiveSessionsData,
     unarchiveSessionsData,
@@ -117,26 +140,7 @@ const {
     exportSession,
     exportArchivedSession,
     sessionActions,
-    channelState: {
-      data: undefined as
-        | {
-            catalog: Array<{
-              type: string;
-              displayName: string;
-              manageable: boolean;
-              fields: [];
-            }>;
-            snapshot: { revision: string; instances: Record<string, unknown> };
-          }
-        | undefined,
-      catalog: [] as Array<{
-        type: string;
-        displayName: string;
-        manageable: boolean;
-        fields: [];
-      }>,
-      channels: {} as Record<string, unknown>,
-    },
+    channelState,
   };
 });
 
@@ -146,7 +150,7 @@ vi.mock('@qwen-code/webui/daemon-react-sdk', () => ({
   useWorkspace: () => workspace,
   useWorkspaceActions: () => workspaceActions,
   useSessions,
-  useChannels: () => channelState,
+  useChannels,
 }));
 
 const { I18nProvider } = await import('../../i18n');
@@ -510,6 +514,7 @@ beforeEach(() => {
   archived.reload.mockReset();
   archived.reload.mockResolvedValue(undefined);
   useSessions.mockClear();
+  useChannels.mockClear();
   active.sessions.length = 0;
   archived.sessions.length = 0;
   channelState.data = undefined;
@@ -3000,7 +3005,7 @@ describe('WebShellSidebar session source switch', () => {
     ).toBe(true);
   });
 
-  it('hides the switch and keeps legacy session requests unfiltered', () => {
+  it('hides the switch and keeps legacy session requests unfiltered', async () => {
     connection.capabilities = {
       ...capabilities,
       features: capabilities.features.filter(
@@ -3015,12 +3020,22 @@ describe('WebShellSidebar session source switch', () => {
         ([options]) => options?.sourceType === undefined,
       ),
     ).toBe(true);
+    await expandWorkspace('other');
+    expect(listWorkspaceSessions).toHaveBeenCalled();
+    expect(
+      listWorkspaceSessions.mock.calls.every(
+        ([options]) => options?.sourceType === undefined,
+      ),
+    ).toBe(true);
   });
 
   it('polls channel sessions on the active-session interval', async () => {
     const setIntervalSpy = vi.spyOn(window, 'setInterval');
     renderSidebar();
     await ensureWorkspaceExpanded('project');
+    expect(
+      setIntervalSpy.mock.calls.some(([, timeout]) => timeout === 2_000),
+    ).toBe(false);
     const channelsTab = Array.from(
       container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
     ).find((button) => button.textContent?.trim() === 'Channels');
@@ -3070,6 +3085,10 @@ describe('WebShellSidebar session source switch', () => {
       await Promise.resolve();
     });
 
+    expect(useChannels).toHaveBeenCalledWith({
+      autoLoad: false,
+      enabled: false,
+    });
     expect(container.textContent).toContain('Legacy channel');
     expect(container.querySelector('section[aria-label]')).toBeNull();
   });
@@ -3166,6 +3185,11 @@ describe('WebShellSidebar session source switch', () => {
       await Promise.resolve();
     });
 
+    expect(useChannels).toHaveBeenCalledWith({
+      autoLoad: true,
+      enabled: true,
+    });
+
     const dingTalkGroup = container.querySelector<HTMLElement>(
       'section[aria-label="DingTalk"]',
     );
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index 67c72b2da50..91987ff2119 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -148,6 +148,7 @@ function renderSection(
     expanded: boolean;
     sourceType: string;
     channelGroupingEnabled: boolean;
+    organizationEnabled: boolean;
   }> = {},
 ): void {
   act(() => {
@@ -163,7 +164,7 @@ function renderSection(
           trustToOpenLabel="Trust to open"
           noSessionsLabel="No sessions"
           loadErrorLabel="Load failed"
-          organizationEnabled={false}
+          organizationEnabled={overrides.organizationEnabled ?? false}
           sourceType={overrides.sourceType}
           channelGroupingEnabled={overrides.channelGroupingEnabled}
           ungroupedLabel="Ungrouped"
@@ -294,6 +295,7 @@ describe('WorkspaceSection label', () => {
             displayName: 'DingTalk secondary',
             sourceType: 'channel',
             sourceId: 'secondary-ding',
+            groupId: 'organization-group',
           },
           {
             sessionId: 'feishu-session',
@@ -302,7 +304,18 @@ describe('WorkspaceSection label', () => {
             sourceId: 'secondary-feishu',
           },
         ]),
-        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+        listSessionGroups: vi.fn().mockResolvedValue({
+          groups: [
+            {
+              id: 'organization-group',
+              name: 'Organization group',
+              color: 'blue',
+              order: 0,
+              createdAt: '2026-01-01T00:00:00.000Z',
+              updatedAt: '2026-01-01T00:00:00.000Z',
+            },
+          ],
+        }),
         workspaceChannelTypes: vi.fn().mockResolvedValue([
           {
             type: 'dingtalk',
@@ -345,6 +358,7 @@ describe('WorkspaceSection label', () => {
       expanded: true,
       sourceType: 'channel',
       channelGroupingEnabled: true,
+      organizationEnabled: true,
     });
     await flush();
 
@@ -354,6 +368,9 @@ describe('WorkspaceSection label', () => {
     expect(
       container.querySelector('section[aria-label="Feishu"]')?.textContent,
     ).toContain('Feishu secondary');
+    expect(
+      container.querySelector('section[aria-label="Organization group"]'),
+    ).toBeNull();
   });
 });
 
diff --git a/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
index 0459a00925e..395989f2d78 100644
--- a/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
+++ b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
@@ -69,15 +69,33 @@ describe('groupSessionsByChannelType', () => {
 
   it('uses the raw type or fallback group when catalog metadata is incomplete', () => {
     const groups = groupSessionsByChannelType(
-      [session('github', 'github'), session('legacy')],
+      [
+        session('github', 'github'),
+        session('legacy-one'),
+        session('legacy-two'),
+      ],
       catalog,
       { github: instance('github', 'github') },
       'Other channels',
     );
 
-    expect(groups.map(({ label }) => label)).toEqual([
-      'github',
-      'Other channels',
+    expect(
+      groups.map(({ id, label, sessions }) => ({
+        id,
+        label,
+        sessions: sessions.map((item) => item.sessionId),
+      })),
+    ).toEqual([
+      {
+        id: 'channel-type:github',
+        label: 'github',
+        sessions: ['github'],
+      },
+      {
+        id: 'channel-type-fallback',
+        label: 'Other channels',
+        sessions: ['legacy-one', 'legacy-two'],
+      },
     ]);
   });
 });

From 9a89c606a6d6c66ec75e0116841f0d998021e169 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=8B=E7=AB=9F?= <dingbingzhi.dbz@alibaba-inc.com>
Date: Tue, 4 Aug 2026 06:10:10 +0000
Subject: [PATCH 07/16] test: pin remaining channel session review findings

Close the round-1 review gaps the previous fixes left unpinned: the
channel-base/acp-bridge display-text wire key now has a cross-package
equality assertion, the secondary-workspace catalog test covers pinned
channel sessions, the collect-coalescing test pins the raw display text
when buffered messages carry model-only metadata, the editor descriptor
labels diverge from the i18n values so missing keys surface, and the
channels e2e asserts the legacy fixture is absent from the Tasks tab.
---
 .../channels/base/src/ChannelBase.test.ts     | 19 +++++++++++++++++--
 packages/channels/base/src/index.ts           |  1 +
 .../channel/display-text-wire-key.test.ts     | 15 +++++++++++++++
 .../channels/ChannelEditorDialog.test.tsx     | 13 ++++++++-----
 .../sidebar/WorkspaceSection.test.tsx         |  3 +++
 .../client/e2e/web-shell.channels.spec.ts     |  1 +
 6 files changed, 45 insertions(+), 7 deletions(-)
 create mode 100644 packages/cli/src/commands/channel/display-text-wire-key.test.ts

diff --git a/packages/channels/base/src/ChannelBase.test.ts b/packages/channels/base/src/ChannelBase.test.ts
index 5fe8b4b05b2..fb0bf47613b 100644
--- a/packages/channels/base/src/ChannelBase.test.ts
+++ b/packages/channels/base/src/ChannelBase.test.ts
@@ -13479,10 +13479,18 @@ describe('ChannelBase', () => {
 
       // Send two more messages while first is busy — these should buffer
       const p2 = ch.handleInbound(
-        envelope({ text: 'second', messageId: 'msg-2' }),
+        envelope({
+          text: 'second',
+          messageId: 'msg-2',
+          metadata: 'hidden policy second',
+        }),
       );
       const p3 = ch.handleInbound(
-        envelope({ text: 'third', messageId: 'msg-3' }),
+        envelope({
+          text: 'third',
+          messageId: 'msg-3',
+          metadata: 'hidden policy third',
+        }),
       );
 
       // p2 and p3 should resolve immediately (buffered, not queued)
@@ -13519,6 +13527,13 @@ describe('ChannelBase', () => {
         .calls[1][1] as string;
       expect(secondCallText).toContain('second');
       expect(secondCallText).toContain('third');
+      // Metadata stays model-facing; the coalesced projection carries only
+      // the raw user-authored texts.
+      expect(secondCallText).toContain('hidden policy second');
+      expect(secondCallText).toContain('hidden policy third');
+      expect(
+        (bridge.prompt as ReturnType<typeof vi.fn>).mock.calls[1][2],
+      ).toMatchObject({ displayText: 'second\n\nthird' });
 
       // Both responses should have been sent
       expect(ch.sent).toEqual(
diff --git a/packages/channels/base/src/index.ts b/packages/channels/base/src/index.ts
index c454c9393d5..dd344685cf2 100644
--- a/packages/channels/base/src/index.ts
+++ b/packages/channels/base/src/index.ts
@@ -5,6 +5,7 @@ export {
 } from './paths.js';
 export { PollingChannelBase } from './PollingChannelBase.js';
 export { ACP_EVENT_LOOP_STALL_RESTART_MS, AcpBridge } from './AcpBridge.js';
+export { CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY } from './ChannelAgentBridge.js';
 export type {
   AvailableCommand,
   BridgeSessionInfo,
diff --git a/packages/cli/src/commands/channel/display-text-wire-key.test.ts b/packages/cli/src/commands/channel/display-text-wire-key.test.ts
new file mode 100644
index 00000000000..41038fc0158
--- /dev/null
+++ b/packages/cli/src/commands/channel/display-text-wire-key.test.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY } from '@qwen-code/channel-base';
+import { DAEMON_PROMPT_DISPLAY_TEXT_META_KEY } from '@qwen-code/acp-bridge/bridgeTypes';
+
+// The channel bridges write the display projection under the channel-base key
+// and the daemon-side Session reads it under the acp-bridge key; the packages
+// have no dependency path between them, so pin the wire contract here where
+// both packages are importable.
+describe('channel prompt display text wire key', () => {
+  it('is identical across channel-base and acp-bridge', () => {
+    expect(CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY).toBe(
+      DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
+    );
+  });
+});
diff --git a/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx b/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx
index 7069ef000e2..8d84da022a6 100644
--- a/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx
+++ b/packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx
@@ -35,15 +35,18 @@ const DINGTALK: DaemonChannelTypeDescriptor = {
     },
     {
       key: 'sessionScope',
-      label: 'Session scope',
+      // Descriptor labels intentionally differ from the i18n values so a
+      // missing i18n key surfaces the untranslated fallback instead of
+      // passing the copy assertions below.
+      label: 'Session scope (descriptor)',
       kind: 'enum',
       required: true,
       default: 'user',
       options: [
-        { value: 'user', label: 'Per user and chat' },
-        { value: 'thread', label: 'Per thread' },
-        { value: 'chat_thread', label: 'Per chat and thread' },
-        { value: 'single', label: 'One shared session' },
+        { value: 'user', label: 'Descriptor per user' },
+        { value: 'thread', label: 'Descriptor per thread' },
+        { value: 'chat_thread', label: 'Descriptor per chat' },
+        { value: 'single', label: 'Descriptor shared' },
       ],
     },
   ],
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index 91987ff2119..037c2eacc65 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -302,6 +302,9 @@ describe('WorkspaceSection label', () => {
             displayName: 'Feishu secondary',
             sourceType: 'channel',
             sourceId: 'secondary-feishu',
+            // Channel mode must keep pinned rows inside their platform
+            // section (excludePinned is off for the channel source).
+            isPinned: true,
           },
         ]),
         listSessionGroups: vi.fn().mockResolvedValue({
diff --git a/packages/web-shell/client/e2e/web-shell.channels.spec.ts b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
index 76323fba7c5..ff8fef8ac3a 100644
--- a/packages/web-shell/client/e2e/web-shell.channels.spec.ts
+++ b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
@@ -111,6 +111,7 @@ test('shows channel sessions in the sidebar channel catalog', async ({
 
   await expect(page.getByText('Web Shell task', { exact: true })).toBeVisible();
   await expect(page.getByText('DingTalk conversation')).toHaveCount(0);
+  await expect(page.getByText('Legacy channel conversation')).toHaveCount(0);
   await page.getByRole('tab', { name: 'Channels' }).click();
   await expect(
     page.getByText('DingTalk conversation', { exact: true }),

From f65f88e7eced835c0a723eea4de575d77ca57f60 Mon Sep 17 00:00:00 2001
From: qwen-code-dev-bot <qwen-code-dev-bot@users.noreply.github.com>
Date: Tue, 4 Aug 2026 14:59:20 +0000
Subject: [PATCH 08/16] fix: harden channel session sidebar and display
 projections (#8457)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Round-2 review fixes:

- Guard the sidebar channel-instance lookup with Object.hasOwn so a
  sourceId like 'constructor' cannot crash the Channels view through
  Object.prototype (R2-1).
- Drop the {text:''} part synthesis for empty displayText replays so
  image-only channel prompts stop emitting a spurious
  unknown_record_or_part diagnostic and complete:false (R2-2).
- Route the webhook display projection through the same
  truncate+sanitize treatment as the model prompt via a shared helper
  (R2-3).
- Refresh the per-workspace channel catalog on the session poll tick
  and render the channel list flat — never under organization groups —
  while the catalog is unavailable (R2-4).
- Remove the dead prompt re-truncation in sessionService (R2-5).
- Extract getChannelPromptDisplayText as the single source of truth for
  the echo, pending-entry, and re-arm display-text reads (R2-7).
- Add workspaceCwd to the channel e2e session fixtures (R2-8).
- Pin the archived source switch, the deleteSessionData validation
  contract, and the stale-response ordering guard with tests
  (R2-10, R2-11, R2-13).
---
 packages/acp-bridge/src/bridge.ts             |  39 +++--
 .../acp-bridge/src/transcript-replay.test.ts  |  55 ++++++-
 packages/acp-bridge/src/transcript-replay.ts  |  14 +-
 .../channels/base/src/ChannelBase.test.ts     |  38 +++++
 packages/channels/base/src/ChannelBase.ts     |   5 +-
 .../channels/base/src/ChannelWebhookTask.ts   |  26 +++
 .../commands/channel/daemon-worker.test.ts    |  78 +++++++++
 packages/core/src/services/sessionService.ts  |   2 +-
 ...WebShellSidebar.workspace-removal.test.tsx |  46 ++++++
 .../sidebar/WorkspaceSection.test.tsx         | 152 +++++++++++++++++-
 .../components/sidebar/WorkspaceSection.tsx   |  49 +++---
 .../sidebar/channelSessionGroups.test.ts      |  36 +++++
 .../sidebar/channelSessionGroups.ts           |  11 +-
 .../client/e2e/web-shell.channels.spec.ts     |  11 ++
 14 files changed, 506 insertions(+), 56 deletions(-)

diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts
index 96e2a52851a..10661242079 100644
--- a/packages/acp-bridge/src/bridge.ts
+++ b/packages/acp-bridge/src/bridge.ts
@@ -235,6 +235,23 @@ function sessionSourceRequestMeta(
     : {};
 }
 
+/**
+ * The daemon's channel adapter carries the user-facing display projection in
+ * prompt meta; only channel sessions may use it — every other source echoes
+ * its prompt content verbatim. Single source of truth for the echo, the
+ * pending-entry text, and the re-arm strip so their `''`/missing-meta
+ * semantics cannot drift apart.
+ */
+function getChannelPromptDisplayText(
+  entry: Pick<SessionEntry, 'sourceType'>,
+  meta: Record<string, unknown> | null | undefined,
+): string | undefined {
+  const displayText = meta?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
+  return entry.sourceType === 'channel' && typeof displayText === 'string'
+    ? displayText
+    : undefined;
+}
+
 function isDefinitiveAcpRequestError(error: unknown): boolean {
   if (error instanceof RequestError) return true;
   if (!isRecord(error)) return false;
@@ -931,11 +948,7 @@ function echoPromptToSessionBus(
   // contract — cheaper than a thrown `TypeError` mid-echo.
   const prompt = req.prompt;
   if (!Array.isArray(prompt) || prompt.length === 0) return;
-  const displayText =
-    entry.sourceType === 'channel' &&
-    typeof req._meta?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] === 'string'
-      ? req._meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]
-      : undefined;
+  const displayText = getChannelPromptDisplayText(entry, req._meta);
   let displayTextPublished = false;
   const serverTimestamp = Date.now();
   const blockCount = Math.min(prompt.length, MAX_ECHO_CONTENT_BLOCKS);
@@ -5483,10 +5496,8 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
         queuedAt,
         ...(originatorClientId !== undefined ? { originatorClientId } : {}),
         text:
-          entry.sourceType === 'channel' &&
-          typeof req._meta?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] === 'string'
-            ? req._meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]
-            : extractPromptText(req.prompt),
+          getChannelPromptDisplayText(entry, req._meta) ??
+          extractPromptText(req.prompt),
         abortController: pendingAbort,
         state: isQueued ? 'queued' : 'running',
       };
@@ -5670,12 +5681,10 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
                     copy._meta && typeof copy._meta === 'object'
                       ? { ...copy._meta }
                       : {};
-                  const promptDisplayText =
-                    entry.sourceType === 'channel' &&
-                    typeof meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] ===
-                      'string'
-                      ? meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY]
-                      : undefined;
+                  const promptDisplayText = getChannelPromptDisplayText(
+                    entry,
+                    meta,
+                  );
                   delete meta[DAEMON_RETRY_META_KEY];
                   delete meta[INVOCATION_CONTEXT_META_KEY];
                   delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
diff --git a/packages/acp-bridge/src/transcript-replay.test.ts b/packages/acp-bridge/src/transcript-replay.test.ts
index 96b4e40468c..d912bba2695 100644
--- a/packages/acp-bridge/src/transcript-replay.test.ts
+++ b/packages/acp-bridge/src/transcript-replay.test.ts
@@ -283,8 +283,9 @@ describe('createTranscriptReplayMachine', () => {
     });
 
     it('does not replay hidden text when an image-only prompt has empty display text', () => {
+      const onDiagnostic = vi.fn();
       const projected = updates(
-        createTranscriptReplayMachine(),
+        createTranscriptReplayMachine({ onDiagnostic }),
         record('user-empty-display', 'user', {
           message: {
             role: 'user',
@@ -313,6 +314,58 @@ describe('createTranscriptReplayMachine', () => {
         },
       ]);
       expect(projected).toHaveLength(1);
+      // An empty displayText is a first-class "no visible text" state; it
+      // must not synthesize a {text:''} part that the projector would flag
+      // as unknown and flip the replay to complete:false.
+      expect(onDiagnostic).not.toHaveBeenCalled();
+    });
+
+    it('emits nothing (and no diagnostic) for an empty display text without parts', () => {
+      const onDiagnostic = vi.fn();
+      const projected = updates(
+        createTranscriptReplayMachine({ onDiagnostic }),
+        record('user-empty-display-no-parts', 'user', {
+          message: { role: 'user', parts: [] },
+          systemPayload: { displayText: '' },
+        }),
+      );
+
+      expect(projected).toEqual([]);
+      expect(onDiagnostic).not.toHaveBeenCalled();
+    });
+
+    it('appends no text part for an empty display text on an image-only record', () => {
+      const onDiagnostic = vi.fn();
+      const projected = updates(
+        createTranscriptReplayMachine({ onDiagnostic }),
+        record('user-empty-display-image-only', 'user', {
+          message: {
+            role: 'user',
+            parts: [
+              {
+                inlineData: {
+                  data: 'abc',
+                  mimeType: 'image/png',
+                },
+              },
+            ],
+          },
+          systemPayload: { displayText: '' },
+        }),
+      );
+
+      expect(projected).toMatchObject([
+        {
+          sessionUpdate: 'user_message_chunk',
+          content: {
+            type: 'image',
+            data: 'abc',
+            mimeType: 'image/png',
+          },
+        },
+      ]);
+      expect(projected).toHaveLength(1);
+      expect(onDiagnostic).not.toHaveBeenCalled();
     });
 
     it('strips a trailing whole-part tagged block when displayText is absent', () => {
diff --git a/packages/acp-bridge/src/transcript-replay.ts b/packages/acp-bridge/src/transcript-replay.ts
index 701c9eb9a07..049dba69dfe 100644
--- a/packages/acp-bridge/src/transcript-replay.ts
+++ b/packages/acp-bridge/src/transcript-replay.ts
@@ -599,7 +599,11 @@ class DefaultTranscriptReplayMachine implements TranscriptReplayMachine {
   /**
    * Rebuilds a plain user record for display: strip trailing tagged hook
    * context, then replace every text part with a single `displayText` part at
-   * the first text position so images keep their relative order.
+   * the first text position so images keep their relative order. An empty
+   * `displayText` means "no user-visible text" (e.g. an image-only channel
+   * prompt): the text parts are dropped WITHOUT synthesizing a `{text:''}`
+   * part, which projectMessageParts would flag as an unknown part and flip
+   * the replay to `complete:false` even though nothing was lost.
    */
   private withUserPromptDisplayText(
     record: TranscriptRecordInput,
@@ -612,7 +616,7 @@ class DefaultTranscriptReplayMachine implements TranscriptReplayMachine {
         ...stripped,
         message: {
           ...stripped.message,
-          parts: [{ text: displayText }],
+          parts: displayText === '' ? [] : [{ text: displayText }],
         },
       };
     }
@@ -621,14 +625,16 @@ class DefaultTranscriptReplayMachine implements TranscriptReplayMachine {
     for (const part of parts) {
       if (isObjectRecord(part) && typeof part['text'] === 'string') {
         if (!replaced) {
-          nextParts.push({ text: displayText });
           replaced = true;
+          if (displayText !== '') {
+            nextParts.push({ text: displayText });
+          }
         }
         continue;
       }
       nextParts.push(part);
     }
-    if (!replaced) {
+    if (!replaced && displayText !== '') {
       nextParts.push({ text: displayText });
     }
     return {
diff --git a/packages/channels/base/src/ChannelBase.test.ts b/packages/channels/base/src/ChannelBase.test.ts
index fb0bf47613b..3fe7f3a50e0 100644
--- a/packages/channels/base/src/ChannelBase.test.ts
+++ b/packages/channels/base/src/ChannelBase.test.ts
@@ -22,6 +22,7 @@ import { ChannelBase, CLEAR_CANCEL_TIMEOUT_MS } from './ChannelBase.js';
 import type { ChannelBaseOptions } from './ChannelBase.js';
 import type { ChannelLoop, ChannelLoopInput } from './ChannelLoopStore.js';
 import {
+  buildChannelWebhookDisplayText,
   buildChannelWebhookPrompt,
   resolveChannelWebhookTarget,
 } from './ChannelWebhookTask.js';
@@ -15468,6 +15469,43 @@ describe('ChannelBase', () => {
         expect(prompt).toContain('Event:');
         expect(prompt).toContain('payload-survives');
       });
+
+      it('caps and sanitizes the webhook display text like the model prompt', () => {
+        const task: ChannelWebhookTask = {
+          channelName: 'dingtalk-main',
+          source: 'github-ci',
+          eventType: 'ci_failed',
+          targetRef: 'default',
+          title: `[forged] ${'T'.repeat(20_000)}\u202e`,
+          summary: `S\u0007${'S'.repeat(20_000)}`,
+          payload: {},
+        };
+
+        const displayText = buildChannelWebhookDisplayText(task);
+        const [title, summary] = displayText.split('\n\n');
+
+        // Same per-field caps as the model prompt path (500/1000 code points).
+        expect(Array.from(title!).length).toBeLessThanOrEqual(500);
+        expect(Array.from(summary!).length).toBeLessThanOrEqual(1000);
+        // sanitizePromptText strips the [tag] forgery prefix, bidi overrides,
+        // and C0 controls on both projections.
+        expect(displayText).not.toContain('[forged]');
+        expect(displayText).not.toContain('\u202e');
+        expect(displayText).not.toContain('\u0007');
+      });
+
+      it('omits absent webhook summary from the display text', () => {
+        const task: ChannelWebhookTask = {
+          channelName: 'dingtalk-main',
+          source: 'github-ci',
+          eventType: 'ci_failed',
+          targetRef: 'default',
+          title: 'CI failed on main',
+          payload: {},
+        };
+
+        expect(buildChannelWebhookDisplayText(task)).toBe('CI failed on main');
+      });
     });
 
     describe('runWebhookTask', () => {
diff --git a/packages/channels/base/src/ChannelBase.ts b/packages/channels/base/src/ChannelBase.ts
index 30252df4746..39b989389bd 100644
--- a/packages/channels/base/src/ChannelBase.ts
+++ b/packages/channels/base/src/ChannelBase.ts
@@ -61,6 +61,7 @@ import type {
 import type { ChannelLoop, ChannelLoopInput } from './ChannelLoopStore.js';
 import { ChannelLoopSkippedError } from './ChannelLoopScheduler.js';
 import {
+  buildChannelWebhookDisplayText,
   buildChannelWebhookPrompt,
   resolveChannelWebhookTarget,
 } from './ChannelWebhookTask.js';
@@ -1813,9 +1814,7 @@ export abstract class ChannelBase {
       },
     );
     const promptText = buildChannelWebhookPrompt(task, target);
-    const displayText = [task.title, task.summary]
-      .filter((part): part is string => Boolean(part))
-      .join('\n\n');
+    const displayText = buildChannelWebhookDisplayText(task);
     const taskId = `webhook:${task.source}:${task.eventType}`;
     const safeTaskId = sanitizeLogText(taskId, 64);
     const safeChannel = sanitizeLogText(this.name, 64);
diff --git a/packages/channels/base/src/ChannelWebhookTask.ts b/packages/channels/base/src/ChannelWebhookTask.ts
index d305d765812..33f4e434464 100644
--- a/packages/channels/base/src/ChannelWebhookTask.ts
+++ b/packages/channels/base/src/ChannelWebhookTask.ts
@@ -108,6 +108,32 @@ export function buildChannelWebhookPrompt(
   return truncateCodePoints(lines.join('\n'), MAX_WEBHOOK_PROMPT_CHARS);
 }
 
+/**
+ * User-visible projection of a webhook task (session-bus displayText,
+ * transcript). Mirrors the model-prompt treatment in
+ * buildChannelWebhookPrompt — same per-field caps and sanitizePromptText —
+ * so an oversized or crafted title/summary cannot reach the transcript
+ * uncapped while the model side stays bounded and sanitized.
+ */
+export function buildChannelWebhookDisplayText(
+  task: ChannelWebhookTask,
+): string {
+  const title = truncateCodePoints(
+    sanitizePromptText(task.title),
+    MAX_WEBHOOK_TITLE_CHARS,
+  );
+  const summary =
+    task.summary === undefined
+      ? undefined
+      : truncateCodePoints(
+          sanitizePromptText(task.summary),
+          MAX_WEBHOOK_SUMMARY_CHARS,
+        );
+  return [title, summary]
+    .filter((part): part is string => Boolean(part))
+    .join('\n\n');
+}
+
 function truncateCodePoints(text: string, maxChars: number): string {
   const chars = Array.from(text);
   return chars.length > maxChars ? chars.slice(0, maxChars).join('') : text;
diff --git a/packages/cli/src/commands/channel/daemon-worker.test.ts b/packages/cli/src/commands/channel/daemon-worker.test.ts
index 234efa5db8d..0efb2ebe2f2 100644
--- a/packages/cli/src/commands/channel/daemon-worker.test.ts
+++ b/packages/cli/src/commands/channel/daemon-worker.test.ts
@@ -761,6 +761,84 @@ describe('runChannelDaemonWorker', () => {
     await handle.close();
   });
 
+  it('treats an already-deleted classifier session as deletion success', async () => {
+    const sdk = createSdk();
+    sdk.deleteSessionsData.mockResolvedValue({
+      removed: [],
+      notFound: ['classifier-session'],
+      errors: [],
+    });
+    const handle = await runChannelDaemonWorker({
+      daemonUrl: 'http://127.0.0.1:4170',
+      workspace: '/workspace',
+      selection: { mode: 'names', names: ['telegram'] },
+      loadDaemonSdk: async () => sdk,
+    });
+    const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
+      deleteSessionData?: (
+        sessionId: string,
+        workspaceCwd: string,
+      ) => Promise<void>;
+    };
+
+    await expect(
+      options.deleteSessionData?.('classifier-session', '/workspace'),
+    ).resolves.toBeUndefined();
+    await handle.close();
+  });
+
+  it('propagates per-session daemon deletion errors as a rejection', async () => {
+    const sdk = createSdk();
+    sdk.deleteSessionsData.mockResolvedValue({
+      removed: [],
+      notFound: [],
+      errors: [{ sessionId: 'classifier-session', error: 'storage locked' }],
+    });
+    const handle = await runChannelDaemonWorker({
+      daemonUrl: 'http://127.0.0.1:4170',
+      workspace: '/workspace',
+      selection: { mode: 'names', names: ['telegram'] },
+      loadDaemonSdk: async () => sdk,
+    });
+    const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
+      deleteSessionData?: (
+        sessionId: string,
+        workspaceCwd: string,
+      ) => Promise<void>;
+    };
+
+    await expect(
+      options.deleteSessionData?.('classifier-session', '/workspace'),
+    ).rejects.toThrow('storage locked');
+    await handle.close();
+  });
+
+  it('rejects when the deletion result omits the session entirely', async () => {
+    const sdk = createSdk();
+    sdk.deleteSessionsData.mockResolvedValue({
+      removed: [],
+      notFound: [],
+      errors: [],
+    });
+    const handle = await runChannelDaemonWorker({
+      daemonUrl: 'http://127.0.0.1:4170',
+      workspace: '/workspace',
+      selection: { mode: 'names', names: ['telegram'] },
+      loadDaemonSdk: async () => sdk,
+    });
+    const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
+      deleteSessionData?: (
+        sessionId: string,
+        workspaceCwd: string,
+      ) => Promise<void>;
+    };
+
+    await expect(
+      options.deleteSessionData?.('classifier-session', '/workspace'),
+    ).rejects.toThrow('Session classifier-session was not deleted.');
+    await handle.close();
+  });
+
   it('forwards router discard through the daemon bridge facade', async () => {
     const sdk = createSdk();
     const handle = await runChannelDaemonWorker({
diff --git a/packages/core/src/services/sessionService.ts b/packages/core/src/services/sessionService.ts
index 5a800e1208d..1e392c2d9da 100644
--- a/packages/core/src/services/sessionService.ts
+++ b/packages/core/src/services/sessionService.ts
@@ -858,7 +858,7 @@ export class SessionService {
       }
       const prompt = this.extractPromptText(record.message);
       if (prompt) {
-        return prompt.length > 200 ? `${prompt.slice(0, 200)}...` : prompt;
+        return prompt;
       }
     }
     return '';
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 80c4444380e..133459933b1 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -2960,6 +2960,52 @@ describe('WebShellSidebar session source switch', () => {
     expect(container.textContent).toContain('Channel session');
   });
 
+  it('applies the source switch to the archived list', async () => {
+    archived.sessions.push(
+      {
+        sessionId: 'archived-task-session',
+        displayName: 'Archived task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+        isArchived: true,
+      },
+      {
+        sessionId: 'archived-channel-session',
+        displayName: 'Archived channel session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        isArchived: true,
+      },
+    );
+    renderSidebar();
+    await expandArchived();
+
+    expect(container.textContent).toContain('Archived task session');
+    expect(container.textContent).not.toContain('Archived channel session');
+
+    const channelsTab = Array.from(
+      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
+    ).find((button) => button.textContent?.trim() === 'Channels');
+    await act(async () => {
+      channelsTab!.dispatchEvent(
+        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
+      );
+      channelsTab!.click();
+      await Promise.resolve();
+    });
+
+    // Both halves of the archived application: the request carries the
+    // channel sourceType, and the client-side dedupe filter keeps archived
+    // task sessions out of the Channels tab.
+    expect(
+      useSessions.mock.calls.findLast(
+        ([options]) => options?.archiveState === 'archived',
+      )?.[0]?.sourceType,
+    ).toBe('channel');
+    expect(container.textContent).toContain('Archived channel session');
+    expect(container.textContent).not.toContain('Archived task session');
+  });
+
   it('switches primary and workspace-qualified lists from tasks to channels', async () => {
     renderSidebar();
 
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index 037c2eacc65..c71c709d5bc 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -248,16 +248,16 @@ describe('WorkspaceSection label', () => {
     const channelSessions = new Promise<DaemonSessionSummary[]>((resolve) => {
       resolveChannel = resolve;
     });
+    // Every default-source request gets its OWN pending promise so the
+    // pre-switch request can settle late, after the switch.
+    const defaultResolvers: Array<(sessions: DaemonSessionSummary[]) => void> =
+      [];
     const listWorkspaceSessions = vi.fn((options?: { sourceType?: string }) =>
       options?.sourceType === 'channel'
         ? channelSessions
-        : Promise.resolve([
-            {
-              sessionId: 'task-session',
-              displayName: 'Task session',
-              sourceType: 'default',
-            },
-          ]),
+        : new Promise<DaemonSessionSummary[]>((resolve) => {
+            defaultResolvers.push(resolve);
+          }),
     );
     const client = {
       workspaceByCwd: vi.fn(() => ({
@@ -268,10 +268,31 @@ describe('WorkspaceSection label', () => {
     } as unknown as DaemonClient;
 
     renderSection({ client, expanded: true, sourceType: 'default' });
+    defaultResolvers[0]!([
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        sourceType: 'default',
+      },
+    ]);
     await flush();
     expect(container.textContent).toContain('Task session');
 
-    renderSection({ client, expanded: true, sourceType: 'channel' });
+    // A poll tick still on the default source issues a second request that
+    // stays pending across the source switch below.
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'default',
+      reloadToken: 1,
+    });
+
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'channel',
+      reloadToken: 1,
+    });
     expect(container.textContent).not.toContain('Task session');
 
     resolveChannel([
@@ -283,6 +304,22 @@ describe('WorkspaceSection label', () => {
     ]);
     await flush();
     expect(container.textContent).toContain('Channel session');
+
+    // The pending pre-switch default response settles AFTER the switch; the
+    // requestId ordering guard must drop it — without it the stale write
+    // clobbers the new-source list and the section renders the empty
+    // placeholder until the next poll (indefinitely for read-only
+    // workspaces, which have no polling interval).
+    defaultResolvers[1]!([
+      {
+        sessionId: 'stale-task-session',
+        displayName: 'Stale task session',
+        sourceType: 'default',
+      },
+    ]);
+    await flush();
+    expect(container.textContent).toContain('Channel session');
+    expect(container.textContent).not.toContain('Stale task session');
   });
 
   it('groups a secondary workspace with its own channel catalog', async () => {
@@ -375,6 +412,105 @@ describe('WorkspaceSection label', () => {
       container.querySelector('section[aria-label="Organization group"]'),
     ).toBeNull();
   });
+
+  it('renders channel sessions flat while the channel catalog failed to load', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessions: vi.fn().mockResolvedValue([
+          {
+            sessionId: 'ding-session',
+            displayName: 'DingTalk session',
+            sourceType: 'channel',
+            sourceId: 'ding-one',
+            groupId: 'organization-group',
+          },
+        ]),
+        listSessionGroups: vi.fn().mockResolvedValue({
+          groups: [
+            {
+              id: 'organization-group',
+              name: 'Organization group',
+              color: 'blue',
+              order: 0,
+              createdAt: '2026-01-01T00:00:00.000Z',
+              updatedAt: '2026-01-01T00:00:00.000Z',
+            },
+          ],
+        }),
+        workspaceChannelTypes: vi.fn().mockRejectedValue(new Error('boom')),
+        workspaceChannels: vi.fn().mockRejectedValue(new Error('boom')),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'channel',
+      channelGroupingEnabled: true,
+      organizationEnabled: true,
+    });
+    await flush();
+
+    // Without a catalog the channel list is not groupable yet; it must stay
+    // flat instead of falling through to organization groups, which would
+    // invert the "channel grouping overrides user groups" precedence.
+    expect(container.textContent).toContain('DingTalk session');
+    expect(
+      container.querySelector('section[aria-label="Organization group"]'),
+    ).toBeNull();
+    warn.mockRestore();
+  });
+
+  it('refreshes the channel catalog on the session poll tick', async () => {
+    const workspaceChannelTypes = vi.fn().mockResolvedValue([
+      {
+        type: 'dingtalk',
+        displayName: 'DingTalk',
+        manageable: true,
+        fields: [],
+      },
+    ]);
+    const workspaceChannels = vi.fn().mockResolvedValue({
+      revision: '1',
+      instances: {},
+    });
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessions: vi.fn().mockResolvedValue([]),
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+        workspaceChannelTypes,
+        workspaceChannels,
+      })),
+    } as unknown as DaemonClient;
+    const setIntervalSpy = vi.spyOn(window, 'setInterval');
+
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'channel',
+      channelGroupingEnabled: true,
+    });
+    await flush();
+    expect(workspaceChannelTypes).toHaveBeenCalledTimes(1);
+
+    const poll = setIntervalSpy.mock.calls.findLast(
+      ([, timeout]) => timeout === 10_000,
+    );
+    expect(poll).toBeDefined();
+    await act(async () => {
+      const callback = poll![0];
+      expect(callback).toBeTypeOf('function');
+      if (typeof callback === 'function') callback();
+      await Promise.resolve();
+    });
+    await flush();
+
+    expect(workspaceChannelTypes).toHaveBeenCalledTimes(2);
+    setIntervalSpy.mockRestore();
+  });
 });
 
 describe('WorkspaceSection git chip', () => {
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index 2cb376e5d10..3bf11789adc 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -231,37 +231,38 @@ export function WorkspaceSection({
     workspace.cwd,
   ]);
 
+  const loadChannelCatalog = useCallback(async () => {
+    if (disabled || readOnly || !channelGroupingEnabled) return;
+    try {
+      const workspaceClient = client.workspaceByCwd(workspace.cwd);
+      const [catalog, snapshot] = await Promise.all([
+        workspaceClient.workspaceChannelTypes(),
+        workspaceClient.workspaceChannels(),
+      ]);
+      setChannelCatalog({ catalog, snapshot });
+    } catch (err) {
+      // Keep the last known catalog across a transient failure; the next
+      // poll tick retries.
+      console.warn('[WorkspaceSection] channel catalog load failed:', err);
+    }
+  }, [channelGroupingEnabled, client, disabled, readOnly, workspace.cwd]);
+
   useEffect(() => {
     if (!renderSessions || disabled || readOnly || !channelGroupingEnabled) {
       setChannelCatalog(undefined);
       return;
     }
     if (!expanded && !searchActive) return;
-    let cancelled = false;
-    const workspaceClient = client.workspaceByCwd(workspace.cwd);
-    void Promise.all([
-      workspaceClient.workspaceChannelTypes(),
-      workspaceClient.workspaceChannels(),
-    ])
-      .then(([catalog, snapshot]) => {
-        if (!cancelled) setChannelCatalog({ catalog, snapshot });
-      })
-      .catch((err: unknown) => {
-        console.warn('[WorkspaceSection] channel catalog load failed:', err);
-      });
-    return () => {
-      cancelled = true;
-    };
+    void loadChannelCatalog();
   }, [
     channelGroupingEnabled,
-    client,
     disabled,
     expanded,
+    loadChannelCatalog,
     readOnly,
     reloadToken,
     renderSessions,
     searchActive,
-    workspace.cwd,
   ]);
 
   useEffect(() => {
@@ -269,10 +270,16 @@ export function WorkspaceSection({
     if (!expanded && !searchActive) return;
     void loadSessions();
     if (readOnly) return;
-    const timer = setInterval(() => void loadSessions(), 10_000);
+    // The catalog rides the session tick so instances added or removed while
+    // a section is expanded reach the grouping logic without a collapse cycle.
+    const timer = setInterval(() => {
+      void loadSessions();
+      void loadChannelCatalog();
+    }, 10_000);
     return () => clearInterval(timer);
   }, [
     expanded,
+    loadChannelCatalog,
     loadSessions,
     readOnly,
     reloadToken,
@@ -371,7 +378,7 @@ export function WorkspaceSection({
 
   const channelSessionGroups = useMemo(
     () =>
-      channelCatalog
+      channelGroupingEnabled && channelCatalog
         ? groupSessionsByChannelType(
             visibleSessions,
             channelCatalog.catalog,
@@ -379,7 +386,7 @@ export function WorkspaceSection({
             t('sidebar.channelType.other'),
           )
         : null,
-    [channelCatalog, t, visibleSessions],
+    [channelCatalog, channelGroupingEnabled, t, visibleSessions],
   );
 
   return (
@@ -484,7 +491,7 @@ export function WorkspaceSection({
                   </SessionGroupSection>
                 ))}
               </>
-            ) : groupedSessions ? (
+            ) : groupedSessions && !channelGroupingEnabled ? (
               <>
                 {groupedSessions.sections.map(({ group, sessions }) => (
                   <SessionGroupSection
diff --git a/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
index 395989f2d78..7cb5dbbf048 100644
--- a/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
+++ b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
@@ -67,6 +67,42 @@ describe('groupSessionsByChannelType', () => {
     ]);
   });
 
+  it('treats prototype-member sourceIds as missing instances instead of crashing', () => {
+    // Instance names are portable path components, so a deleted instance can
+    // leave orphaned sessions whose sourceId is 'constructor'/'__proto__'.
+    // A bare index read would resolve through Object.prototype and throw
+    // inside the sidebar render path; they must land in the fallback group.
+    const groups = groupSessionsByChannelType(
+      [
+        session('orphan-constructor', 'constructor'),
+        session('orphan-proto', '__proto__'),
+        session('d1', 'ding-one'),
+      ],
+      catalog,
+      { 'ding-one': instance('ding-one', 'dingtalk') },
+      'Other channels',
+    );
+
+    expect(
+      groups.map(({ id, label, sessions }) => ({
+        id,
+        label,
+        sessions: sessions.map((item) => item.sessionId),
+      })),
+    ).toEqual([
+      {
+        id: 'channel-type-fallback',
+        label: 'Other channels',
+        sessions: ['orphan-constructor', 'orphan-proto'],
+      },
+      {
+        id: 'channel-type:dingtalk',
+        label: 'DingTalk',
+        sessions: ['d1'],
+      },
+    ]);
+  });
+
   it('uses the raw type or fallback group when catalog metadata is incomplete', () => {
     const groups = groupSessionsByChannelType(
       [
diff --git a/packages/web-shell/client/components/sidebar/channelSessionGroups.ts b/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
index bf27b571d74..8da23c154ff 100644
--- a/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
+++ b/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
@@ -22,9 +22,14 @@ export function groupSessionsByChannelType(
   const groups = new Map<string, ChannelSessionGroup>();
 
   for (const session of sessions) {
-    const configuredType = session.sourceId
-      ? instances[session.sourceId]?.config['type']
-      : undefined;
+    // Object.hasOwn: a sourceId like 'constructor' resolves through
+    // Object.prototype on a plain record, so a bare index read would
+    // dereference `.config` on the Object function and throw.
+    const instance =
+      session.sourceId && Object.hasOwn(instances, session.sourceId)
+        ? instances[session.sourceId]
+        : undefined;
+    const configuredType = instance?.config['type'];
     const type =
       typeof configuredType === 'string'
         ? configuredType.trim() || undefined
diff --git a/packages/web-shell/client/e2e/web-shell.channels.spec.ts b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
index ff8fef8ac3a..88c233311e0 100644
--- a/packages/web-shell/client/e2e/web-shell.channels.spec.ts
+++ b/packages/web-shell/client/e2e/web-shell.channels.spec.ts
@@ -14,7 +14,12 @@ import {
 test('shows channel sessions in the sidebar channel catalog', async ({
   page,
 }, testInfo) => {
+  const workspaceCwd = '/tmp/qwen-web-shell-e2e';
+  // DaemonSessionSummary requires workspaceCwd; keep a shared base so every
+  // fixture matches the shape the real daemon returns.
+  const baseSession = { workspaceCwd };
   const scenario = createWebShellDaemonScenario({
+    workspaceCwd,
     capabilities: {
       features: [
         'session_events',
@@ -67,17 +72,20 @@ test('shows channel sessions in the sidebar channel catalog', async ({
     },
     sessions: [
       {
+        ...baseSession,
         sessionId: 'task-session',
         displayName: 'Web Shell task',
         sourceType: 'default',
       },
       {
+        ...baseSession,
         sessionId: 'dingtalk-session',
         displayName: 'DingTalk conversation',
         sourceType: 'channel',
         sourceId: 'release-bot',
       },
       {
+        ...baseSession,
         sessionId: 'dingtalk-ops-session',
         displayName: 'DingTalk ops conversation',
         sourceType: 'channel',
@@ -85,12 +93,14 @@ test('shows channel sessions in the sidebar channel catalog', async ({
         isPinned: true,
       },
       {
+        ...baseSession,
         sessionId: 'feishu-session',
         displayName: 'Feishu conversation',
         sourceType: 'channel',
         sourceId: 'feishu-main',
       },
       {
+        ...baseSession,
         sessionId: 'legacy-channel-session',
         displayName: 'Legacy channel conversation',
         sourceType: 'channel',
@@ -139,6 +149,7 @@ test('shows channel sessions in the sidebar channel catalog', async ({
   await expect(dingTalkToggle).toHaveAttribute('aria-expanded', 'true');
 
   scenario.sessions.push({
+    ...baseSession,
     sessionId: 'new-dingtalk-session',
     displayName: 'New DingTalk conversation',
     sourceType: 'channel',

From 3ebb5a388e2852980c51bb53dbc7a686d1fbce57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B8=81=E7=82=B3=E6=99=BA?=
 <dingbingzhi.dbz@alibaba-inc.com>
Date: Mon, 10 Aug 2026 00:04:57 +0800
Subject: [PATCH 09/16] fix(channels): address session review feedback

---
 packages/acp-bridge/src/bridge.test.ts        |  12 +-
 packages/acp-bridge/src/bridge.ts             |  13 +-
 .../channels/base/src/ChannelAgentBridge.ts   |   5 +-
 .../channels/base/src/ChannelBase.test.ts     |  17 +-
 packages/channels/base/src/ChannelBase.ts     |  11 +-
 .../base/src/DaemonChannelBridge.test.ts      |  28 +++-
 .../channels/base/src/DaemonChannelBridge.ts  |   8 +-
 .../channels/github/src/GithubAdapter.test.ts |   7 +
 packages/channels/github/src/GithubAdapter.ts |   5 +
 packages/channels/qqbot/src/QQChannel.ts      |  19 ++-
 packages/channels/qqbot/src/events.test.ts    |   3 +
 .../commands/channel/daemon-worker.test.ts    |  30 ++--
 .../cli/src/commands/channel/daemon-worker.ts |   4 +-
 .../cli/src/ui/commands/renameCommand.test.ts |  24 +++
 packages/cli/src/ui/commands/renameCommand.ts |  10 ++
 .../chatRecordingService.autoTitle.test.ts    | 105 ++++++++++++
 .../core/src/services/chatRecordingService.ts |  22 +++
 .../core/src/services/sessionService.test.ts  |  29 ++++
 packages/core/src/services/sessionService.ts  |  14 +-
 .../core/src/services/sessionTitle.test.ts    |  70 ++++++++
 packages/core/src/services/sessionTitle.ts    |  16 ++
 .../components/sidebar/WebShellSidebar.tsx    |  44 +++--
 ...WebShellSidebar.workspace-removal.test.tsx | 150 +++++++++++-------
 .../sidebar/WorkspaceSection.test.tsx         |  95 +++++++++++
 .../components/sidebar/WorkspaceSection.tsx   |   7 +-
 25 files changed, 626 insertions(+), 122 deletions(-)

diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts
index d180f4d6348..1cd163ab3d1 100644
--- a/packages/acp-bridge/src/bridge.test.ts
+++ b/packages/acp-bridge/src/bridge.test.ts
@@ -8267,9 +8267,10 @@ describe('createAcpSessionBridge', () => {
         {
           sessionId: session.sessionId,
           prompt: [
-            { type: 'text', text: 'hidden context\n\nqueued behind first' },
+            { type: 'image', data: 'aW1hZ2U=', mimeType: 'image/png' },
+            { type: 'text', text: 'hidden channel instructions' },
           ],
-          _meta: { 'qwen.daemon.promptDisplayText': 'queued behind first' },
+          _meta: { 'qwen.daemon.promptDisplayText': '' },
         },
         undefined,
         { promptId: 'prompt-second' },
@@ -8283,7 +8284,7 @@ describe('createAcpSessionBridge', () => {
       expect(addedEvents[0]?.promptId).toBe('prompt-second');
       expect(
         (addedEvents[0] as BridgeEvent & { data: { text: string } }).data.text,
-      ).toBe('queued behind first');
+      ).toBe('[image]');
 
       const pending = bridge.getPendingPrompts(session.sessionId);
       expect(pending).toHaveLength(2);
@@ -8314,9 +8315,10 @@ describe('createAcpSessionBridge', () => {
       expect(
         (startedEvents[0] as BridgeEvent & { data: { text: string } }).data
           .text,
-      ).toBe('queued behind first');
+      ).toBe('[image]');
       expect(handle.agent.promptCalls[1]?.prompt).toEqual([
-        { type: 'text', text: 'hidden context\n\nqueued behind first' },
+        { type: 'image', data: 'aW1hZ2U=', mimeType: 'image/png' },
+        { type: 'text', text: 'hidden channel instructions' },
       ]);
       const completedEvents = events.filter(
         (e) => e.type === 'pending_prompt_completed',
diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts
index 4c6bbd01b7f..93184da8a71 100644
--- a/packages/acp-bridge/src/bridge.ts
+++ b/packages/acp-bridge/src/bridge.ts
@@ -1013,6 +1013,7 @@ function echoPromptToSessionBus(
     if (displayText !== undefined && part.type === 'text') {
       if (displayTextPublished) continue;
       displayTextPublished = true;
+      if (!displayText) continue;
       displayPart = { ...part, text: displayText };
     }
     // Non-text blocks are published verbatim. Channel text uses the display
@@ -6037,13 +6038,19 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
           );
         }
       }
+      const channelDisplayText = getChannelPromptDisplayText(entry, req._meta);
+      const pendingText =
+        channelDisplayText === undefined
+          ? extractPromptText(req.prompt)
+          : channelDisplayText ||
+            (req.prompt.some((block) => block.type === 'image')
+              ? '[image]'
+              : '');
       const pendingEntry: PendingPromptEntry = {
         promptId,
         queuedAt,
         ...(originatorClientId !== undefined ? { originatorClientId } : {}),
-        text:
-          getChannelPromptDisplayText(entry, req._meta) ??
-          extractPromptText(req.prompt),
+        text: pendingText,
         abortController: pendingAbort,
         state: isQueued ? 'queued' : 'running',
       };
diff --git a/packages/channels/base/src/ChannelAgentBridge.ts b/packages/channels/base/src/ChannelAgentBridge.ts
index cb5876c5cc0..6d5a8a9fded 100644
--- a/packages/channels/base/src/ChannelAgentBridge.ts
+++ b/packages/channels/base/src/ChannelAgentBridge.ts
@@ -133,7 +133,10 @@ export interface ChannelAgentBridge {
     sessionId: string,
     expectedBindingToken?: object,
   ): Promise<void>;
-  /** Permanently remove an internal bridge session and its persisted data. */
+  /**
+   * Daemon-mode hook for permanently removing an internal session's data.
+   * Standalone bridges may omit it and fall back to discardSession.
+   */
   deleteSessionData?(sessionId: string): Promise<void>;
   respondToPermission?(
     requestId: string,
diff --git a/packages/channels/base/src/ChannelBase.test.ts b/packages/channels/base/src/ChannelBase.test.ts
index c7ee043ba5d..02e041afcd3 100644
--- a/packages/channels/base/src/ChannelBase.test.ts
+++ b/packages/channels/base/src/ChannelBase.test.ts
@@ -14406,7 +14406,10 @@ describe('ChannelBase', () => {
         return Promise.resolve('coalesced response');
       });
 
-      const ch = createChannel({ dispatchMode: 'collect' });
+      const ch = createChannel({
+        dispatchMode: 'collect',
+        groupPolicy: 'open',
+      });
 
       // Send first message — starts processing
       const p1 = ch.handleInbound(envelope({ text: 'first' }));
@@ -14418,6 +14421,9 @@ describe('ChannelBase', () => {
       const p2 = ch.handleInbound(
         envelope({
           text: 'second',
+          senderName: 'Alice',
+          isGroup: true,
+          isMentioned: true,
           messageId: 'msg-2',
           metadata: 'hidden policy second',
         }),
@@ -14425,6 +14431,9 @@ describe('ChannelBase', () => {
       const p3 = ch.handleInbound(
         envelope({
           text: 'third',
+          senderName: 'Bob',
+          isGroup: true,
+          isMentioned: true,
           messageId: 'msg-3',
           metadata: 'hidden policy third',
         }),
@@ -14470,7 +14479,7 @@ describe('ChannelBase', () => {
       expect(secondCallText).toContain('hidden policy third');
       expect(
         (bridge.prompt as ReturnType<typeof vi.fn>).mock.calls[1][2],
-      ).toMatchObject({ displayText: 'second\n\nthird' });
+      ).toMatchObject({ displayText: '[Alice] second\n\n[Bob] third' });
 
       // Both responses should have been sent
       expect(ch.sent).toEqual(
@@ -17093,7 +17102,9 @@ describe('ChannelBase', () => {
         expect(collectedPrompt).toContain('follow-up while webhook runs');
         expect(
           (bridge.prompt as ReturnType<typeof vi.fn>).mock.calls[1][2],
-        ).toMatchObject({ displayText: 'follow-up while webhook runs' });
+        ).toMatchObject({
+          displayText: '[Webhook] follow-up while webhook runs',
+        });
       });
 
       it('waits for bridge recovery before resolving a webhook session', async () => {
diff --git a/packages/channels/base/src/ChannelBase.ts b/packages/channels/base/src/ChannelBase.ts
index 2cf95bd8520..4bc6d843da7 100644
--- a/packages/channels/base/src/ChannelBase.ts
+++ b/packages/channels/base/src/ChannelBase.ts
@@ -5305,7 +5305,16 @@ export abstract class ChannelBase {
             buffer = [];
             this.collectBuffers.set(sessionId, buffer);
           }
-          buffer.push({ text: promptText, displayText, envelope });
+          const bufferedDisplayText =
+            (envelope.isGroup || this.config.sessionScope === 'single') &&
+            !recognizedSlashCommand
+              ? `[${sanitizeSenderName(envelope.senderName || envelope.senderId || 'unknown')}] ${sanitizePromptText(displayText)}`
+              : displayText;
+          buffer.push({
+            text: promptText,
+            displayText: bufferedDisplayText,
+            envelope,
+          });
           try {
             this.onPromptBuffered(
               envelope.chatId,
diff --git a/packages/channels/base/src/DaemonChannelBridge.test.ts b/packages/channels/base/src/DaemonChannelBridge.test.ts
index d3410beb4ae..9e444650a4f 100644
--- a/packages/channels/base/src/DaemonChannelBridge.test.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.test.ts
@@ -145,12 +145,38 @@ describe('DaemonChannelBridge', () => {
     await bridge.newSession('/repo');
     await bridge.deleteSessionData?.('session-1');
 
-    expect(deleteSessionData).toHaveBeenCalledWith('session-1', '/repo');
+    expect(deleteSessionData).toHaveBeenCalledWith('session-1');
     expect(bridge.listSessions()).toEqual([]);
     events.close();
     bridge.stop();
   });
 
+  it('deletes session data after the live binding has already died', async () => {
+    const events = new EventQueue();
+    const session = createFakeSession(events);
+    const deleteSessionData = vi.fn().mockResolvedValue(undefined);
+    const bridge = new DaemonChannelBridge({
+      cwd: '/repo',
+      sessionFactory: vi.fn().mockResolvedValue(session),
+      deleteSessionData,
+    });
+
+    await bridge.start();
+    await bridge.newSession('/repo');
+    events.push({
+      v: 1,
+      type: 'session_died',
+      data: { sessionId: 'session-1', reason: 'child_exit' },
+    });
+    await waitFor(() => expect(bridge.listSessions()).toEqual([]));
+
+    await bridge.deleteSessionData?.('session-1');
+
+    expect(deleteSessionData).toHaveBeenCalledWith('session-1');
+    events.close();
+    bridge.stop();
+  });
+
   it('registers the loop MCP server for the exact daemon session', async () => {
     const events = new EventQueue();
     const session = createFakeSession(events);
diff --git a/packages/channels/base/src/DaemonChannelBridge.ts b/packages/channels/base/src/DaemonChannelBridge.ts
index a82b0c66bdf..b7a06eb621d 100644
--- a/packages/channels/base/src/DaemonChannelBridge.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.ts
@@ -87,10 +87,7 @@ export interface DaemonChannelBridgeOptions {
   modelServiceId?: string;
   sessionScope?: SessionScope;
   channelLoopMcpHost?: DaemonChannelLoopMcpHost;
-  deleteSessionData?: (
-    sessionId: string,
-    workspaceCwd: string,
-  ) => Promise<void>;
+  deleteSessionData?: (sessionId: string) => Promise<void>;
 }
 
 export interface DaemonPermissionRequestEvent {
@@ -246,9 +243,8 @@ export class DaemonChannelBridge
     const deleteSessionData = options.deleteSessionData;
     if (deleteSessionData) {
       this.deleteSessionData = async (sessionId) => {
-        const session = this.ensureSession(sessionId);
         try {
-          await deleteSessionData(sessionId, session.workspaceCwd);
+          await deleteSessionData(sessionId);
         } finally {
           this.removeSessionBinding(sessionId);
         }
diff --git a/packages/channels/github/src/GithubAdapter.test.ts b/packages/channels/github/src/GithubAdapter.test.ts
index 4816a497404..3f8e41ac9ee 100644
--- a/packages/channels/github/src/GithubAdapter.test.ts
+++ b/packages/channels/github/src/GithubAdapter.test.ts
@@ -1519,6 +1519,9 @@ describe('GithubChannel', () => {
       expect(channel.inboundEnvelopes[0]!.text).toBe(
         'Return a formal review summary with verified actionable findings, or a concise no-blocker result.',
       );
+      expect(channel.inboundEnvelopes[0]!.displayText).toBe(
+        'Review requested: feat: divide',
+      );
       expect(channel.inboundEnvelopes[0]!.metadata).toContain(
         'For review_requested, return a formal review summary',
       );
@@ -1654,6 +1657,7 @@ describe('GithubChannel', () => {
         senderId: 'maintainer',
         isMentioned: true,
         text: 'Triage this issue and respond with the next action.',
+        displayText: 'Issue assigned: broken build',
       });
       expect(channel.inboundEnvelopes[1]).toMatchObject({
         senderId: 'bob',
@@ -1702,6 +1706,9 @@ describe('GithubChannel', () => {
         );
         expect(channel.inboundEnvelopes[0]!.text).toContain('@alice: first');
         expect(channel.inboundEnvelopes[0]!.text).toContain('@bob: second');
+        expect(channel.inboundEnvelopes[0]!.displayText).toBe(
+          '- @alice: first\n- @bob: second',
+        );
       },
     );
 
diff --git a/packages/channels/github/src/GithubAdapter.ts b/packages/channels/github/src/GithubAdapter.ts
index 869559dce63..03efa6ae40c 100644
--- a/packages/channels/github/src/GithubAdapter.ts
+++ b/packages/channels/github/src/GithubAdapter.ts
@@ -1401,6 +1401,10 @@ export class GithubChannel extends PollingChannelBase<GithubCursor> {
         reason === 'review_requested'
           ? 'Return a formal review summary with verified actionable findings, or a concise no-blocker result.'
           : 'Triage this issue and respond with the next action.',
+      displayText:
+        reason === 'review_requested'
+          ? `Review requested: ${title}`
+          : `Issue assigned: ${title}`,
       isGroup: true,
       isMentioned: true,
       isReplyToBot: false,
@@ -1450,6 +1454,7 @@ export class GithubChannel extends PollingChannelBase<GithubCursor> {
       threadId: ctx.threadId,
       messageId: String(first.id),
       text: `Review these new comments and output exactly ${NO_REPLY_SENTINEL} if no public reply is needed:\n${summary}`,
+      displayText: summary,
       isGroup: true,
       isMentioned: true,
       isReplyToBot: false,
diff --git a/packages/channels/qqbot/src/QQChannel.ts b/packages/channels/qqbot/src/QQChannel.ts
index bf3428a8cb5..c10e460f614 100644
--- a/packages/channels/qqbot/src/QQChannel.ts
+++ b/packages/channels/qqbot/src/QQChannel.ts
@@ -2292,6 +2292,7 @@ export class QQChannel extends ChannelBase {
     safeName: string;
     cleanText: string;
     text: string;
+    displayText: string;
     senderName: string;
   } | null {
     // Keep identity values out of the display-name position. In particular,
@@ -2397,6 +2398,7 @@ export class QQChannel extends ChannelBase {
     const text = isSlash
       ? sanitizePromptText(safeCleanText)
       : `[atMention=${effectiveIsAtBot}]${openIdSuffix} [${safeName}${senderTag}]: ${sanitizePromptText(this.qqConfig.allowMention !== false ? safeContent : safeCleanText)}${suffixFromBotOpenId}`;
+    const displayText = sanitizePromptText(safeCleanText);
 
     return {
       isAtBot: effectiveIsAtBot,
@@ -2404,6 +2406,7 @@ export class QQChannel extends ChannelBase {
       safeName,
       cleanText,
       text,
+      displayText,
       senderName,
     };
   }
@@ -2454,6 +2457,7 @@ export class QQChannel extends ChannelBase {
       senderName,
       chatId,
       text,
+      displayText: sanitizePromptText(safeContent),
       messageId: event.id,
       isGroup: false,
       isMentioned: true,
@@ -2506,7 +2510,8 @@ export class QQChannel extends ChannelBase {
       forceAtMention: true,
     });
     if (!result) return;
-    const { isSlash, text, senderName, safeName, cleanText } = result;
+    const { isSlash, text, displayText, senderName, safeName, cleanText } =
+      result;
 
     // Deduplicate before handleInbound — prepareGroupMessage already ran
     // so side effects (extractBotOpenId) are applied regardless of dedup.
@@ -2540,6 +2545,7 @@ export class QQChannel extends ChannelBase {
       senderName,
       chatId,
       text,
+      displayText,
       messageId: event.id,
       isGroup: true,
       isMentioned: true,
@@ -2585,7 +2591,15 @@ export class QQChannel extends ChannelBase {
 
     const result = this.prepareGroupMessage(event, chatId);
     if (!result) return;
-    const { isSlash, text, senderName, isAtBot, safeName, cleanText } = result;
+    const {
+      isSlash,
+      text,
+      displayText,
+      senderName,
+      isAtBot,
+      safeName,
+      cleanText,
+    } = result;
 
     // @-bot messages always pass through (passive reply).
     // Non-@-bot messages are subject to active-message and keyword policies.
@@ -2683,6 +2697,7 @@ export class QQChannel extends ChannelBase {
       channelName: this.name,
       chatId,
       text,
+      displayText,
       senderId,
       senderName,
       messageId: event.id,
diff --git a/packages/channels/qqbot/src/events.test.ts b/packages/channels/qqbot/src/events.test.ts
index e0ef472e860..f00a258113c 100644
--- a/packages/channels/qqbot/src/events.test.ts
+++ b/packages/channels/qqbot/src/events.test.ts
@@ -290,6 +290,7 @@ describe('handleC2C', () => {
     expect(env['senderId']).toBe('user-openid-1');
     expect(env['chatId']).toBe('user-openid-1');
     expect(env['text']).toBe('[atMention=true] [Alice]: 你好，帮我查一下天气');
+    expect(env['displayText']).toBe('你好，帮我查一下天气');
   });
 
   it('斜杠命令不包装 atMention', async () => {
@@ -414,6 +415,7 @@ describe('handleGroup', () => {
     expect(env['text']).toBe(
       '[atMention=true] [Bob(ABCDEF0123456789ABCDEF0123456789)]: <@OPENID_BOT> 你好',
     );
+    expect(env['displayText']).toBe('你好');
   });
 
   it('allowMention=false 时清理 <@OPENID> 标签', async () => {
@@ -1068,6 +1070,7 @@ describe('handleGroupAll', () => {
     const env = mockHandleInbound.mock.calls[0][0] as Record<string, unknown>;
     expect(env['isGroup']).toBe(true);
     expect(env['text']).toContain('[atMention=false]');
+    expect(env['displayText']).toBe('hello world');
   });
 
   it('policy=keyword 时只有匹配关键词才触发', async () => {
diff --git a/packages/cli/src/commands/channel/daemon-worker.test.ts b/packages/cli/src/commands/channel/daemon-worker.test.ts
index 9a957c503dd..ee8025cd0e9 100644
--- a/packages/cli/src/commands/channel/daemon-worker.test.ts
+++ b/packages/cli/src/commands/channel/daemon-worker.test.ts
@@ -743,7 +743,7 @@ describe('createDaemonChannelBridgeFacade', () => {
 });
 
 describe('runChannelDaemonWorker', () => {
-  it('wires permanent classifier-session deletion to the owning workspace', async () => {
+  it('wires permanent classifier-session deletion to the worker workspace', async () => {
     const sdk = createSdk();
     const handle = await runChannelDaemonWorker({
       daemonUrl: 'http://127.0.0.1:4170',
@@ -752,13 +752,10 @@ describe('runChannelDaemonWorker', () => {
       loadDaemonSdk: async () => sdk,
     });
     const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
-      deleteSessionData?: (
-        sessionId: string,
-        workspaceCwd: string,
-      ) => Promise<void>;
+      deleteSessionData?: (sessionId: string) => Promise<void>;
     };
 
-    await options.deleteSessionData?.('classifier-session', '/workspace');
+    await options.deleteSessionData?.('classifier-session');
 
     expect(sdk.client.workspaceByCwd).toHaveBeenCalledWith('/workspace');
     expect(sdk.deleteSessionsData).toHaveBeenCalledWith(['classifier-session']);
@@ -779,14 +776,11 @@ describe('runChannelDaemonWorker', () => {
       loadDaemonSdk: async () => sdk,
     });
     const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
-      deleteSessionData?: (
-        sessionId: string,
-        workspaceCwd: string,
-      ) => Promise<void>;
+      deleteSessionData?: (sessionId: string) => Promise<void>;
     };
 
     await expect(
-      options.deleteSessionData?.('classifier-session', '/workspace'),
+      options.deleteSessionData?.('classifier-session'),
     ).resolves.toBeUndefined();
     await handle.close();
   });
@@ -805,14 +799,11 @@ describe('runChannelDaemonWorker', () => {
       loadDaemonSdk: async () => sdk,
     });
     const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
-      deleteSessionData?: (
-        sessionId: string,
-        workspaceCwd: string,
-      ) => Promise<void>;
+      deleteSessionData?: (sessionId: string) => Promise<void>;
     };
 
     await expect(
-      options.deleteSessionData?.('classifier-session', '/workspace'),
+      options.deleteSessionData?.('classifier-session'),
     ).rejects.toThrow('storage locked');
     await handle.close();
   });
@@ -831,14 +822,11 @@ describe('runChannelDaemonWorker', () => {
       loadDaemonSdk: async () => sdk,
     });
     const options = mockDaemonChannelBridge.mock.calls.at(-1)?.[0] as {
-      deleteSessionData?: (
-        sessionId: string,
-        workspaceCwd: string,
-      ) => Promise<void>;
+      deleteSessionData?: (sessionId: string) => Promise<void>;
     };
 
     await expect(
-      options.deleteSessionData?.('classifier-session', '/workspace'),
+      options.deleteSessionData?.('classifier-session'),
     ).rejects.toThrow('Session classifier-session was not deleted.');
     await handle.close();
   });
diff --git a/packages/cli/src/commands/channel/daemon-worker.ts b/packages/cli/src/commands/channel/daemon-worker.ts
index 72d147e2d16..46b2d28478a 100644
--- a/packages/cli/src/commands/channel/daemon-worker.ts
+++ b/packages/cli/src/commands/channel/daemon-worker.ts
@@ -488,8 +488,8 @@ export async function runChannelDaemonWorker(
       DaemonSessionClient: sdk.DaemonSessionClient,
       clientId: `qwen-channel-worker:${process.pid}`,
     }),
-    deleteSessionData: async (sessionId, workspaceCwd) => {
-      const workspaceClient = client.workspaceByCwd?.(workspaceCwd);
+    deleteSessionData: async (sessionId) => {
+      const workspaceClient = client.workspaceByCwd?.(daemonWorkspace);
       if (!workspaceClient) {
         throw new Error('Daemon SDK does not support session data deletion.');
       }
diff --git a/packages/cli/src/ui/commands/renameCommand.test.ts b/packages/cli/src/ui/commands/renameCommand.test.ts
index 5b2699032ae..91a6a26291f 100644
--- a/packages/cli/src/ui/commands/renameCommand.test.ts
+++ b/packages/cli/src/ui/commands/renameCommand.test.ts
@@ -121,6 +121,30 @@ describe('renameCommand', () => {
     expect(tryGenerateSessionTitleMock).toHaveBeenCalledOnce();
   });
 
+  it('passes channel display projections to automatic title generation', async () => {
+    tryGenerateSessionTitleMock.mockResolvedValue({
+      ok: false,
+      reason: 'empty_history',
+    });
+    const displayTexts = ['你好', '/rename   --auto'];
+    const mockConfig = {
+      getChatRecordingService: vi.fn().mockReturnValue({
+        getUserDisplayTextsForTitle: vi.fn().mockReturnValue(displayTexts),
+      }),
+    };
+    mockContext = createMockCommandContext({
+      services: { config: mockConfig as never },
+    });
+
+    await renameCommand.action!(mockContext, '--auto');
+
+    expect(tryGenerateSessionTitleMock).toHaveBeenCalledWith(
+      mockConfig,
+      expect.any(AbortSignal),
+      ['你好'],
+    );
+  });
+
   it('should return error when only whitespace is provided and auto-generate fails', async () => {
     tryGenerateSessionTitleMock.mockResolvedValue({
       ok: false,
diff --git a/packages/cli/src/ui/commands/renameCommand.ts b/packages/cli/src/ui/commands/renameCommand.ts
index c26014920bc..8ccc02927b2 100644
--- a/packages/cli/src/ui/commands/renameCommand.ts
+++ b/packages/cli/src/ui/commands/renameCommand.ts
@@ -180,9 +180,19 @@ export const renameCommand: SlashCommand = {
       // future regressions don't leak an interval timer).
       let outcome: Awaited<ReturnType<typeof tryGenerateSessionTitle>>;
       try {
+        const userDisplayTexts =
+          config.getChatRecordingService()?.getUserDisplayTextsForTitle?.() ??
+          [];
+        const lastDisplayText = userDisplayTexts.at(-1)?.trim();
+        const titleDisplayTexts = lastDisplayText?.match(
+          /^\/rename(?:\s+--auto)?$/,
+        )
+          ? userDisplayTexts.slice(0, -1)
+          : userDisplayTexts;
         outcome = await tryGenerateSessionTitle(
           config,
           context.abortSignal ?? new AbortController().signal,
+          titleDisplayTexts,
         );
       } finally {
         clearInterval(timer);
diff --git a/packages/core/src/services/chatRecordingService.autoTitle.test.ts b/packages/core/src/services/chatRecordingService.autoTitle.test.ts
index 08c51889b08..d90931cbba8 100644
--- a/packages/core/src/services/chatRecordingService.autoTitle.test.ts
+++ b/packages/core/src/services/chatRecordingService.autoTitle.test.ts
@@ -373,6 +373,111 @@ describe('ChatRecordingService - auto-title trigger', () => {
     );
   });
 
+  it('passes the latest user display projection to auto-title generation', async () => {
+    mockOk('Answer greeting');
+    chatRecordingService.recordUserMessage(
+      [{ text: 'hidden channel instructions' }],
+      undefined,
+      { displayText: '你好', hookContext: '' },
+    );
+
+    chatRecordingService.recordAssistantTurn({
+      model: 'qwen-plus',
+      message: [{ text: 'reply' }],
+    });
+    await flushMicrotasks();
+
+    expect(tryGenerateSessionTitleMock).toHaveBeenCalledWith(
+      mockConfig,
+      expect.any(AbortSignal),
+      ['你好'],
+    );
+  });
+
+  it('restores channel display projections for automatic rename and retries', async () => {
+    const messages: ChatRecord[] = [
+      {
+        uuid: 'user-1',
+        parentUuid: null,
+        sessionId: 'test-session-id',
+        timestamp: '2026-01-01T00:00:00.000Z',
+        type: 'user',
+        provenance: 'real_user',
+        cwd: '/test/project/root',
+        version: '1.0.0',
+        message: { role: 'user', parts: [{ text: 'hidden first prompt' }] },
+        systemPayload: { displayText: '你好', hookContext: '' },
+      },
+      {
+        uuid: 'assistant-1',
+        parentUuid: 'user-1',
+        sessionId: 'test-session-id',
+        timestamp: '2026-01-01T00:00:01.000Z',
+        type: 'assistant',
+        provenance: 'assistant_output',
+        cwd: '/test/project/root',
+        version: '1.0.0',
+        message: { role: 'model', parts: [{ text: 'First reply' }] },
+      },
+      {
+        uuid: 'user-2',
+        parentUuid: 'assistant-1',
+        sessionId: 'test-session-id',
+        timestamp: '2026-01-01T00:00:02.000Z',
+        type: 'user',
+        provenance: 'real_user',
+        cwd: '/test/project/root',
+        version: '1.0.0',
+        message: { role: 'user', parts: [{ text: 'hidden second prompt' }] },
+        systemPayload: { displayText: '再见', hookContext: '' },
+      },
+    ];
+    const resumedConfig = {
+      ...mockConfig,
+      getResumedSessionData: vi.fn().mockReturnValue({
+        conversation: { messages },
+        lastCompletedUuid: 'user-2',
+      }),
+    } as unknown as Config;
+    const service = activateRecording(
+      new ChatRecordingService(resumedConfig, undefined, true),
+      resumedConfig,
+    );
+
+    expect(service.getUserDisplayTextsForTitle()).toEqual(['你好', '再见']);
+
+    mockOk('Answer greetings');
+    service.recordAssistantTurn({
+      model: 'qwen-plus',
+      message: [{ text: 'reply' }],
+    });
+    await flushMicrotasks();
+
+    expect(tryGenerateSessionTitleMock).toHaveBeenCalledWith(
+      resumedConfig,
+      expect.any(AbortSignal),
+      ['你好', '再见'],
+    );
+  });
+
+  it('retains only display projections relevant to recent title history', () => {
+    for (let index = 0; index < 21; index++) {
+      chatRecordingService.recordUserMessage(
+        [{ text: `hidden ${index}` }],
+        undefined,
+        {
+          displayText: `visible ${index}`,
+          hookContext: '',
+        },
+      );
+    }
+
+    expect(chatRecordingService.getUserDisplayTextsForTitle()).toHaveLength(20);
+    expect(chatRecordingService.getUserDisplayTextsForTitle()[0]).toBe(
+      'visible 1',
+    );
+  });
+
   it('does not trigger in headless CLI mode (non-interactive, non-ACP)', async () => {
     vi.mocked(mockConfig.isInteractive).mockReturnValue(false);
     vi.mocked(mockConfig.getExperimentalZedIntegration).mockReturnValue(false);
diff --git a/packages/core/src/services/chatRecordingService.ts b/packages/core/src/services/chatRecordingService.ts
index 24bb49550f8..ccc3fd22408 100644
--- a/packages/core/src/services/chatRecordingService.ts
+++ b/packages/core/src/services/chatRecordingService.ts
@@ -57,6 +57,7 @@ const debugLogger = createDebugLogger('CHAT_RECORDING');
  * retrying across turns.
  */
 const AUTO_TITLE_ATTEMPT_CAP = 3;
+const MAX_TITLE_USER_DISPLAY_TEXTS = 20;
 const SESSION_FILE_DIFF_AGGREGATE_CHAR_LIMIT = 100_000;
 const SESSION_FILE_DIFF_CHAR_LIMIT = 50_000;
 const SESSION_FILE_CONTENT_CHAR_LIMIT = 16_000;
@@ -643,6 +644,7 @@ export class ChatRecordingService {
   /** Immutable creator attribution once recorded. */
   private currentSourceType: string | undefined;
   private currentSourceId: string | undefined;
+  private readonly userDisplayTextsForTitle: Array<string | undefined> = [];
   /**
    * How many auto-title attempts have been made this process.
    *
@@ -809,9 +811,16 @@ export class ChatRecordingService {
     this.currentParentSessionId = undefined;
     this.currentSourceType = undefined;
     this.currentSourceId = undefined;
+    this.userDisplayTextsForTitle.length = 0;
     if (!sessionData) return;
     this.rebuildTurnBoundaries(sessionData.conversation.messages);
     for (const record of sessionData.conversation.messages) {
+      if (record.type === 'user' && record.subtype === undefined) {
+        this.trackUserDisplayTextForTitle(
+          (record.systemPayload as UserPromptRecordPayload | undefined)
+            ?.displayText,
+        );
+      }
       if (record.type !== 'system') continue;
       if (record.subtype === 'custom_title') {
         const payload = record.systemPayload as
@@ -840,6 +849,13 @@ export class ChatRecordingService {
     }
   }
 
+  private trackUserDisplayTextForTitle(displayText: string | undefined): void {
+    this.userDisplayTextsForTitle.push(displayText);
+    if (this.userDisplayTextsForTitle.length > MAX_TITLE_USER_DISPLAY_TEXTS) {
+      this.userDisplayTextsForTitle.shift();
+    }
+  }
+
   activate(
     lease: SessionWriterLease,
     sessionData?: {
@@ -1293,6 +1309,7 @@ export class ChatRecordingService {
     promptPayload?: UserPromptRecordPayload,
   ): void {
     try {
+      this.trackUserDisplayTextForTitle(promptPayload?.displayText);
       this.turnParentUuids.push(this.lastRecordUuid);
       const record: ChatRecord = {
         ...this.createBaseRecord('user'),
@@ -1306,6 +1323,10 @@ export class ChatRecordingService {
     }
   }
 
+  getUserDisplayTextsForTitle(): ReadonlyArray<string | undefined> {
+    return this.userDisplayTextsForTitle;
+  }
+
   recordGoalRuntimeMessage(
     message: PartListUnion,
     goalContext: GoalTurnPermit,
@@ -1565,6 +1586,7 @@ export class ChatRecordingService {
         const outcome = await tryGenerateSessionTitle(
           this.config,
           controller.signal,
+          this.userDisplayTextsForTitle,
         );
         if (!outcome.ok) return;
         if (controller.signal.aborted) return;
diff --git a/packages/core/src/services/sessionService.test.ts b/packages/core/src/services/sessionService.test.ts
index 406665298bc..56c293fce3b 100644
--- a/packages/core/src/services/sessionService.test.ts
+++ b/packages/core/src/services/sessionService.test.ts
@@ -412,6 +412,35 @@ describe('SessionService', () => {
       expect(result.items[0].prompt).toBe('');
     });
 
+    it('should use a later prompt after an empty display prompt', async () => {
+      readdirSyncSpy.mockReturnValue([
+        `${sessionIdA}.jsonl`,
+      ] as unknown as Array<fs.Dirent<Buffer>>);
+      statSyncSpy.mockReturnValue({
+        mtimeMs: Date.now(),
+        isFile: () => true,
+      } as fs.Stats);
+      vi.mocked(jsonl.readLines).mockResolvedValue([
+        {
+          ...recordA1,
+          message: {
+            role: 'user',
+            parts: [{ text: 'internal channel instructions' }],
+          },
+          systemPayload: { displayText: '', hookContext: '' },
+        },
+        {
+          ...recordA1,
+          uuid: 'later-user',
+          message: { role: 'user', parts: [{ text: 'later prompt' }] },
+        },
+      ]);
+
+      const result = await sessionService.listSessions();
+
+      expect(result.items[0].prompt).toBe('later prompt');
+    });
+
     it('should NOT populate messageCount during listing', async () => {
       // Listing must avoid the full-file readline that counting requires
       // — message counts are now lazy and provided by
diff --git a/packages/core/src/services/sessionService.ts b/packages/core/src/services/sessionService.ts
index 9877afe47f0..0e8417b0369 100644
--- a/packages/core/src/services/sessionService.ts
+++ b/packages/core/src/services/sessionService.ts
@@ -857,8 +857,7 @@ export class SessionService {
       if ('text' in part) {
         const textPart = part as { text: string };
         const text = textPart.text;
-        // Truncate long prompts for display
-        return text.length > 200 ? `${text.slice(0, 200)}...` : text;
+        return this.truncatePromptForDisplay(text);
       }
     }
     return '';
@@ -877,9 +876,7 @@ export class SessionService {
       if (payload?.displayText !== undefined) {
         const displayText = payload.displayText;
         if (displayText) {
-          return displayText.length > 200
-            ? `${displayText.slice(0, 200)}...`
-            : displayText;
+          return this.truncatePromptForDisplay(displayText);
         }
         continue;
       }
@@ -891,6 +888,13 @@ export class SessionService {
     return '';
   }
 
+  private truncatePromptForDisplay(text: string): string {
+    const codePoints = Array.from(text);
+    return codePoints.length > 200
+      ? `${codePoints.slice(0, 200).join('')}...`
+      : text;
+  }
+
   /**
    * Counts unique user/assistant message UUIDs in a session file by
    * streaming the JSONL line-by-line. Each physical line is routed
diff --git a/packages/core/src/services/sessionTitle.test.ts b/packages/core/src/services/sessionTitle.test.ts
index 393530d2835..5ee8a6eadf7 100644
--- a/packages/core/src/services/sessionTitle.test.ts
+++ b/packages/core/src/services/sessionTitle.test.ts
@@ -156,6 +156,76 @@ describe('tryGenerateSessionTitle', () => {
     expect(callOpts.maxAttempts).toBe(1);
   });
 
+  it('uses the user-facing projection instead of hidden prompt context', async () => {
+    const { config, generateJson } = makeConfig({
+      fastModel: 'qwen-turbo',
+      history: [
+        { role: 'user', parts: [{ text: 'hidden channel instructions' }] },
+        { role: 'model', parts: [{ text: 'Hello!' }] },
+      ],
+      generateJsonResult: { title: 'Answer greeting' },
+    });
+
+    await tryGenerateSessionTitle(config, new AbortController().signal, [
+      '你好',
+    ]);
+
+    const call = generateJson.mock.calls[0][0] as {
+      contents: Content[];
+    };
+    const prompt = call.contents[0]?.parts?.[0]?.text;
+    expect(prompt).toContain('你好');
+    expect(prompt).not.toContain('hidden channel instructions');
+  });
+
+  it('projects every recorded user turn when retrying title generation', async () => {
+    const { config, generateJson } = makeConfig({
+      fastModel: 'qwen-turbo',
+      history: [
+        { role: 'user', parts: [{ text: 'hidden first instructions' }] },
+        { role: 'model', parts: [{ text: 'First reply' }] },
+        { role: 'user', parts: [{ text: 'hidden second instructions' }] },
+        { role: 'model', parts: [{ text: 'Second reply' }] },
+      ],
+      generateJsonResult: { title: 'Answer greetings' },
+    });
+
+    await tryGenerateSessionTitle(config, new AbortController().signal, [
+      '你好',
+      '再见',
+    ]);
+
+    const call = generateJson.mock.calls[0][0] as { contents: Content[] };
+    const prompt = call.contents[0]?.parts?.[0]?.text;
+    expect(prompt).toContain('你好');
+    expect(prompt).toContain('再见');
+    expect(prompt).not.toContain('hidden first instructions');
+    expect(prompt).not.toContain('hidden second instructions');
+  });
+
+  it('omits unprojected older user turns from resumed channel history', async () => {
+    const { config, generateJson } = makeConfig({
+      fastModel: 'qwen-turbo',
+      history: [
+        { role: 'user', parts: [{ text: 'older hidden instructions' }] },
+        { role: 'model', parts: [{ text: 'Older reply' }] },
+        { role: 'user', parts: [{ text: 'current hidden instructions' }] },
+        { role: 'model', parts: [{ text: 'Current reply' }] },
+      ],
+      generateJsonResult: { title: 'Answer greeting' },
+    });
+
+    await tryGenerateSessionTitle(config, new AbortController().signal, [
+      '当前消息',
+    ]);
+
+    const call = generateJson.mock.calls[0][0] as { contents: Content[] };
+    const prompt = call.contents[0]?.parts?.[0]?.text;
+    expect(prompt).toContain('当前消息');
+    expect(prompt).not.toContain('older hidden instructions');
+    expect(prompt).not.toContain('current hidden instructions');
+  });
+
   it('sanitizes residual markdown and trailing punctuation from the model result', async () => {
     const { config } = makeConfig({
       fastModel: 'qwen-turbo',
diff --git a/packages/core/src/services/sessionTitle.ts b/packages/core/src/services/sessionTitle.ts
index db15bb2b506..4c5d341b7c2 100644
--- a/packages/core/src/services/sessionTitle.ts
+++ b/packages/core/src/services/sessionTitle.ts
@@ -108,6 +108,7 @@ export type SessionTitleOutcome =
 export async function tryGenerateSessionTitle(
   config: Config,
   abortSignal: AbortSignal,
+  userDisplayTexts: ReadonlyArray<string | undefined> = [],
 ): Promise<SessionTitleOutcome> {
   try {
     const model = config.getFastModel();
@@ -120,6 +121,21 @@ export async function tryGenerateSessionTitle(
     if (fullHistory.length < 2) return { ok: false, reason: 'empty_history' };
 
     const dialog = filterToDialog(fullHistory);
+    if (userDisplayTexts.some((displayText) => displayText !== undefined)) {
+      let displayTextIndex = userDisplayTexts.length - 1;
+      for (let index = dialog.length - 1; index >= 0; index--) {
+        if (dialog[index].role !== 'user') continue;
+        const hasRecordedDisplayText = displayTextIndex >= 0;
+        const displayText = hasRecordedDisplayText
+          ? userDisplayTexts[displayTextIndex--]
+          : '';
+        if (displayText === undefined) continue;
+        dialog[index] = {
+          ...dialog[index],
+          parts: displayText ? [{ text: displayText }] : [],
+        };
+      }
+    }
     const recentHistory = takeRecentDialog(dialog, RECENT_MESSAGE_WINDOW);
     if (recentHistory.length === 0) {
       return { ok: false, reason: 'empty_history' };
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index aabade0a51a..44aa0e3a119 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -804,7 +804,10 @@ export function WebShellSidebar({
   const sidebarRef = useRef<HTMLElement>(null);
   const groupMenuRef = useRef<HTMLDivElement>(null);
   const sessionMenuPointerDismissRef = useRef(false);
-  const previousRunningRef = useRef<Map<string, boolean> | null>(null);
+  const previousRunningBySourceRef = useRef<
+    Record<SidebarSessionSource, Map<string, boolean> | null>
+  >({ default: null, channel: null });
+  const lastTrackedSessionSourceRef = useRef(sessionSource);
   const autoOpenedContextRef = useRef<string | null>(null);
   const pollInFlightRef = useRef(false);
   const resizeTeardownRef = useRef<((updateState: boolean) => void) | null>(
@@ -1487,14 +1490,25 @@ export function WebShellSidebar({
   }, [sessionListReloadToken, reload]);
 
   useEffect(() => {
+    if (lastTrackedSessionSourceRef.current !== sessionSource) {
+      lastTrackedSessionSourceRef.current = sessionSource;
+      return;
+    }
+    if (loading || error) return;
+
     const runningBySessionId = new Map(
-      sessions.map((session) => [
-        getIdentityForSession(session),
-        Boolean(session.hasActivePrompt),
-      ]),
+      sessions
+        .filter((session) =>
+          matchesSessionSource(session, selectedSessionSource),
+        )
+        .map((session) => [
+          getIdentityForSession(session),
+          Boolean(session.hasActivePrompt),
+        ]),
     );
-    const previousRunningBySessionId = previousRunningRef.current;
-    previousRunningRef.current = runningBySessionId;
+    const previousRunningBySessionId =
+      previousRunningBySourceRef.current[sessionSource];
+    previousRunningBySourceRef.current[sessionSource] = runningBySessionId;
     if (previousRunningBySessionId === null) return;
 
     setCompletedUnreadIds((current) => {
@@ -1517,7 +1531,6 @@ export function WebShellSidebar({
       for (const sessionIdentity of next) {
         if (
           sessionIdentity === currentSessionIdentity ||
-          !runningBySessionId.has(sessionIdentity) ||
           runningBySessionId.get(sessionIdentity)
         ) {
           next.delete(sessionIdentity);
@@ -1527,7 +1540,15 @@ export function WebShellSidebar({
 
       return changed ? next : current;
     });
-  }, [currentSessionIdentity, getIdentityForSession, sessions]);
+  }, [
+    currentSessionIdentity,
+    error,
+    getIdentityForSession,
+    loading,
+    selectedSessionSource,
+    sessionSource,
+    sessions,
+  ]);
 
   const reconcileRemovedWorkspace = useCallback(
     async (removed: DaemonWorkspaceCapability) => {
@@ -2618,9 +2639,10 @@ export function WebShellSidebar({
     );
   }, [organizationEnabled, searchQuery, selectedSessionSource, sessions]);
 
+  const channelCatalogLoaded = channelCatalogData !== undefined;
   const channelSessionSections = useMemo(
     () =>
-      selectedSessionSource === 'channel' && channelCatalogData
+      selectedSessionSource === 'channel' && channelCatalogLoaded
         ? groupSessionsByChannelType(
             filteredSessions,
             channelTypeCatalog,
@@ -2629,7 +2651,7 @@ export function WebShellSidebar({
           )
         : null,
     [
-      channelCatalogData,
+      channelCatalogLoaded,
       channelInstances,
       channelTypeCatalog,
       filteredSessions,
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 6d843d3e84b..078bf32604b 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -347,6 +347,23 @@ async function expandArchived(): Promise<void> {
   });
 }
 
+async function switchSessionSource(
+  label: 'Tasks' | 'Channels',
+): Promise<HTMLButtonElement> {
+  const tab = Array.from(
+    container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
+  ).find((button) => button.textContent?.trim() === label);
+  expect(tab).toBeDefined();
+  await act(async () => {
+    tab!.dispatchEvent(
+      new MouseEvent('mousedown', { bubbles: true, button: 0 }),
+    );
+    tab!.click();
+    await Promise.resolve();
+  });
+  return tab!;
+}
+
 function sessionAction(label: string): HTMLButtonElement | undefined {
   return Array.from(
     container.querySelectorAll<HTMLButtonElement>(
@@ -514,6 +531,9 @@ beforeEach(() => {
   archived.reload.mockReset();
   archived.reload.mockResolvedValue(undefined);
   useSessions.mockClear();
+  useSessions.mockImplementation((options?: { archiveState?: string }) =>
+    options?.archiveState === 'archived' ? archived : active,
+  );
   useChannels.mockClear();
   active.sessions.length = 0;
   archived.sessions.length = 0;
@@ -2945,21 +2965,74 @@ describe('WebShellSidebar session source switch', () => {
     expect(container.textContent).toContain('Task session');
     expect(container.textContent).not.toContain('Channel session');
 
-    const channelsTab = Array.from(
-      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
-    ).find((button) => button.textContent?.trim() === 'Channels');
-    await act(async () => {
-      channelsTab!.dispatchEvent(
-        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
-      );
-      channelsTab!.click();
-      await Promise.resolve();
-    });
+    await switchSessionSource('Channels');
 
     expect(container.textContent).not.toContain('Task session');
     expect(container.textContent).toContain('Channel session');
   });
 
+  it('preserves channel completion state while the tasks source is active', async () => {
+    const channelSession: DaemonSessionSummary = {
+      sessionId: 'channel-session',
+      displayName: 'Channel session',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'channel',
+      hasActivePrompt: true,
+    };
+    const taskSession: DaemonSessionSummary = {
+      sessionId: 'task-session',
+      displayName: 'Task session',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'default',
+    };
+    let channelResult = {
+      ...active,
+      sessions: [channelSession],
+      loading: false,
+    };
+    const taskResult = {
+      ...active,
+      sessions: [taskSession],
+      loading: false,
+    };
+    useSessions.mockImplementation(
+      (options?: { archiveState?: string; sourceType?: string }) => {
+        if (options?.archiveState === 'archived') return archived;
+        return options?.sourceType === 'channel' ? channelResult : taskResult;
+      },
+    );
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    await switchSessionSource('Channels');
+    channelResult = { ...channelResult, loading: true };
+    renderSidebar();
+    channelResult = { ...channelResult, loading: false };
+    renderSidebar();
+    await switchSessionSource('Tasks');
+
+    channelResult = {
+      ...channelResult,
+      sessions: [taskSession],
+      loading: false,
+    };
+    await switchSessionSource('Channels');
+    channelResult = { ...channelResult, loading: true };
+    renderSidebar();
+    channelResult = {
+      ...channelResult,
+      sessions: [{ ...channelSession, hasActivePrompt: false }],
+      loading: false,
+    };
+    renderSidebar();
+
+    const row = Array.from(
+      container.querySelectorAll<HTMLElement>('[role="button"]'),
+    ).find((candidate) => candidate.textContent?.includes('Channel session'));
+    expect(row).toBeDefined();
+    expect(row!.querySelector('[class*="sessionStatusDot"]')).not.toBeNull();
+  });
+
   it('applies the source switch to the archived list', async () => {
     archived.sessions.push(
       {
@@ -2983,16 +3056,7 @@ describe('WebShellSidebar session source switch', () => {
     expect(container.textContent).toContain('Archived task session');
     expect(container.textContent).not.toContain('Archived channel session');
 
-    const channelsTab = Array.from(
-      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
-    ).find((button) => button.textContent?.trim() === 'Channels');
-    await act(async () => {
-      channelsTab!.dispatchEvent(
-        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
-      );
-      channelsTab!.click();
-      await Promise.resolve();
-    });
+    await switchSessionSource('Channels');
 
     // Both halves of the archived application: the request carries the
     // channel sourceType, and the client-side dedupe filter keeps archived
@@ -3027,13 +3091,7 @@ describe('WebShellSidebar session source switch', () => {
       )?.[0]?.sourceType,
     ).toBe('default');
 
-    await act(async () => {
-      channelsTab!.dispatchEvent(
-        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
-      );
-      channelsTab!.click();
-      await Promise.resolve();
-    });
+    await switchSessionSource('Channels');
 
     expect(channelsTab?.getAttribute('data-state')).toBe('active');
     expect(
@@ -3082,17 +3140,7 @@ describe('WebShellSidebar session source switch', () => {
     expect(
       setIntervalSpy.mock.calls.some(([, timeout]) => timeout === 2_000),
     ).toBe(false);
-    const channelsTab = Array.from(
-      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
-    ).find((button) => button.textContent?.trim() === 'Channels');
-
-    await act(async () => {
-      channelsTab!.dispatchEvent(
-        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
-      );
-      channelsTab!.click();
-      await Promise.resolve();
-    });
+    const channelsTab = await switchSessionSource('Channels');
     expect(channelsTab?.getAttribute('data-state')).toBe('active');
     const activePoll = setIntervalSpy.mock.calls.findLast(
       ([, timeout]) => timeout === 2_000,
@@ -3120,18 +3168,9 @@ describe('WebShellSidebar session source switch', () => {
     });
     renderSidebar();
     await ensureWorkspaceExpanded('project');
-    const channelsTab = Array.from(
-      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
-    ).find((button) => button.textContent?.trim() === 'Channels');
-    await act(async () => {
-      channelsTab!.dispatchEvent(
-        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
-      );
-      channelsTab!.click();
-      await Promise.resolve();
-    });
+    await switchSessionSource('Channels');
 
-    expect(useChannels).toHaveBeenCalledWith({
+    expect(useChannels).toHaveBeenLastCalledWith({
       autoLoad: false,
       enabled: false,
     });
@@ -3220,18 +3259,9 @@ describe('WebShellSidebar session source switch', () => {
 
     renderSidebar();
     await ensureWorkspaceExpanded('project');
-    const channelsTab = Array.from(
-      container.querySelectorAll<HTMLButtonElement>('[role="tab"]'),
-    ).find((button) => button.textContent?.trim() === 'Channels');
-    await act(async () => {
-      channelsTab!.dispatchEvent(
-        new MouseEvent('mousedown', { bubbles: true, button: 0 }),
-      );
-      channelsTab!.click();
-      await Promise.resolve();
-    });
+    await switchSessionSource('Channels');
 
-    expect(useChannels).toHaveBeenCalledWith({
+    expect(useChannels).toHaveBeenLastCalledWith({
       autoLoad: true,
       enabled: true,
     });
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index c900befc157..a9319e2edc5 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -454,6 +454,101 @@ describe('WorkspaceSection label', () => {
     warn.mockRestore();
   });
 
+  it('ignores a stale channel catalog response', async () => {
+    let resolveStale!: (value: {
+      revision: string;
+      instances: Record<string, unknown>;
+    }) => void;
+    const staleSnapshot = new Promise<{
+      revision: string;
+      instances: Record<string, unknown>;
+    }>((resolve) => {
+      resolveStale = resolve;
+    });
+    const workspaceChannelTypes = vi.fn().mockResolvedValue([
+      {
+        type: 'dingtalk',
+        displayName: 'DingTalk',
+        manageable: true,
+        fields: [],
+      },
+      {
+        type: 'feishu',
+        displayName: 'Feishu',
+        manageable: true,
+        fields: [],
+      },
+    ]);
+    const workspaceChannels = vi
+      .fn()
+      .mockReturnValueOnce(staleSnapshot)
+      .mockResolvedValue({
+        revision: 'new',
+        instances: {
+          instance: {
+            name: 'instance',
+            config: { type: 'feishu' },
+            secrets: {},
+            startsWithServe: false,
+          },
+        },
+      });
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessions: vi.fn().mockResolvedValue([
+          {
+            sessionId: 'channel-session',
+            displayName: 'Channel session',
+            sourceType: 'channel',
+            sourceId: 'instance',
+          },
+        ]),
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+        workspaceChannelTypes,
+        workspaceChannels,
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'channel',
+      channelGroupingEnabled: true,
+      reloadToken: 0,
+    });
+    await flush();
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'channel',
+      channelGroupingEnabled: true,
+      reloadToken: 1,
+    });
+    await flush();
+    expect(
+      container.querySelector('section[aria-label="Feishu"]'),
+    ).not.toBeNull();
+
+    resolveStale({
+      revision: 'old',
+      instances: {
+        instance: {
+          name: 'instance',
+          config: { type: 'dingtalk' },
+        },
+      },
+    });
+    await flush();
+
+    expect(
+      container.querySelector('section[aria-label="Feishu"]'),
+    ).not.toBeNull();
+    expect(
+      container.querySelector('section[aria-label="DingTalk"]'),
+    ).toBeNull();
+  });
+
   it('refreshes the channel catalog on the session poll tick', async () => {
     const workspaceChannelTypes = vi.fn().mockResolvedValue([
       {
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index 34c3ed26cfa..6ddad907a18 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -152,6 +152,7 @@ export function WorkspaceSection({
   const [gitStatus, setGitStatus] = useState<DaemonWorkspaceGitStatus>();
   const [branchPickerOpen, setBranchPickerOpen] = useState(false);
   const sessionLoadRequestId = useRef(0);
+  const channelCatalogLoadRequestId = useRef(0);
   const { t } = useI18n();
   const expanded = controlledExpanded ?? internalExpanded;
   const readOnly = !workspace.primary && !workspace.trusted;
@@ -233,13 +234,16 @@ export function WorkspaceSection({
 
   const loadChannelCatalog = useCallback(async () => {
     if (disabled || readOnly || !channelGroupingEnabled) return;
+    const requestId = ++channelCatalogLoadRequestId.current;
     try {
       const workspaceClient = client.workspaceByCwd(workspace.cwd);
       const [catalog, snapshot] = await Promise.all([
         workspaceClient.workspaceChannelTypes(),
         workspaceClient.workspaceChannels(),
       ]);
-      setChannelCatalog({ catalog, snapshot });
+      if (requestId === channelCatalogLoadRequestId.current) {
+        setChannelCatalog({ catalog, snapshot });
+      }
     } catch (err) {
       // Keep the last known catalog across a transient failure; the next
       // poll tick retries.
@@ -249,6 +253,7 @@ export function WorkspaceSection({
 
   useEffect(() => {
     if (!renderSessions || disabled || readOnly || !channelGroupingEnabled) {
+      channelCatalogLoadRequestId.current += 1;
       setChannelCatalog(undefined);
       return;
     }

From 022a8ee9f9d5b7427368b76d98a42a739eae2475 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B8=81=E7=82=B3=E6=99=BA?=
 <dingbingzhi@Edenmans-Office-Mac.local>
Date: Mon, 10 Aug 2026 13:13:58 +0800
Subject: [PATCH 10/16] fix(channels): address channel session review feedback

---
 packages/acp-bridge/src/bridge.test.ts        | 153 +++++++++++++++++-
 packages/acp-bridge/src/bridge.ts             |  43 +++--
 packages/acp-bridge/src/bridgeTypes.ts        |   2 +
 .../channels/base/src/ChannelAgentBridge.ts   |   5 +-
 packages/channels/base/src/ChannelBase.ts     |   1 +
 .../base/src/DaemonChannelBridge.test.ts      |  28 +++-
 .../channels/base/src/DaemonChannelBridge.ts  |  18 ++-
 packages/channels/github/src/GithubAdapter.ts |   7 +-
 packages/channels/qqbot/src/QQChannel.ts      |  15 +-
 packages/channels/qqbot/src/events.test.ts    |  18 +++
 .../commands/channel/channel-registry.test.ts |  52 ++++++
 .../src/commands/channel/channel-registry.ts  |  37 ++++-
 .../commands/channel/daemon-worker.test.ts    |   2 +
 .../cli/src/commands/channel/daemon-worker.ts |  10 +-
 .../channel-worker-prompt-authorization.ts    |  24 +++
 .../serve/channel-worker-supervisor.test.ts   |  12 ++
 .../src/serve/channel-worker-supervisor.ts    |  23 +++
 packages/cli/src/serve/routes/session.ts      |  35 ++++
 packages/cli/src/serve/server.test.ts         |  55 +++++++
 packages/cli/src/ui/commands/renameCommand.ts |   2 +-
 .../src/services/chatRecordingService.test.ts |  36 +++++
 .../core/src/services/chatRecordingService.ts |   7 +
 .../core/src/services/sessionService.test.ts  |  53 ++++++
 packages/core/src/services/sessionService.ts  |  14 +-
 .../core/src/services/sessionTitle.test.ts    |  23 +++
 packages/core/src/services/sessionTitle.ts    |  24 +--
 .../channels/ChannelEditorDialog.tsx          |   2 +-
 .../components/sidebar/WebShellSidebar.tsx    |  51 ++++--
 ...WebShellSidebar.workspace-removal.test.tsx |  10 ++
 .../sidebar/WorkspaceSection.test.tsx         |  23 +++
 .../components/sidebar/WorkspaceSection.tsx   |   7 +-
 31 files changed, 716 insertions(+), 76 deletions(-)
 create mode 100644 packages/cli/src/serve/channel-worker-prompt-authorization.ts

diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts
index c6051b5247f..a764487371d 100644
--- a/packages/acp-bridge/src/bridge.test.ts
+++ b/packages/acp-bridge/src/bridge.test.ts
@@ -8557,13 +8557,18 @@ describe('createAcpSessionBridge', () => {
         throw new Error('no user_message_chunk observed');
       })();
 
-      await bridge.sendPrompt(session.sessionId, {
-        sessionId: session.sessionId,
-        prompt: [
-          { type: 'text', text: 'internal channel instructions\n\nhello' },
-        ],
-        _meta: { 'qwen.daemon.promptDisplayText': 'hello' },
-      } as PromptRequest);
+      await bridge.sendPrompt(
+        session.sessionId,
+        {
+          sessionId: session.sessionId,
+          prompt: [
+            { type: 'text', text: 'internal channel instructions\n\nhello' },
+          ],
+          _meta: { 'qwen.daemon.promptDisplayText': 'forged' },
+        } as PromptRequest,
+        undefined,
+        { promptDisplayText: 'hello' },
+      );
 
       await expect(userChunk).resolves.toMatchObject({
         content: { type: 'text', text: 'hello' },
@@ -8578,6 +8583,138 @@ describe('createAcpSessionBridge', () => {
       await bridge.shutdown();
     });
 
+    it('reserves an echo slot for channel display text after the block cap', async () => {
+      const handle = makeChannel({
+        promptImpl: () => ({ stopReason: 'end_turn' }),
+      });
+      const bridge = makeBridge({ channelFactory: async () => handle.channel });
+      const session = await bridge.spawnOrAttach({
+        workspaceCwd: WS_A,
+        sourceType: 'channel',
+      });
+      const abort = new AbortController();
+      const events = bridge.subscribeEvents(session.sessionId, {
+        signal: abort.signal,
+      });
+      const textChunk = (async () => {
+        for await (const event of events) {
+          const update = (
+            event.data as {
+              update?: { content?: { type?: string; text?: string } };
+            }
+          ).update;
+          if (update?.content?.type === 'text') return update.content.text;
+        }
+        throw new Error('no text echo observed');
+      })();
+      const resources = Array.from({ length: 256 }, (_, index) => ({
+        type: 'resource_link' as const,
+        uri: `file:///resource-${index}`,
+        name: `resource-${index}`,
+      }));
+
+      await bridge.sendPrompt(
+        session.sessionId,
+        {
+          sessionId: session.sessionId,
+          prompt: [...resources, { type: 'text', text: 'hidden text' }],
+        },
+        undefined,
+        { promptDisplayText: 'visible text' },
+      );
+
+      await expect(textChunk).resolves.toBe('visible text');
+      abort.abort();
+      await bridge.shutdown();
+    });
+
+    it('hides every text block for an intentionally empty display projection', async () => {
+      const handle = makeChannel({
+        promptImpl: () => ({ stopReason: 'end_turn' }),
+      });
+      const bridge = makeBridge({ channelFactory: async () => handle.channel });
+      const session = await bridge.spawnOrAttach({
+        workspaceCwd: WS_A,
+        sourceType: 'channel',
+      });
+      const abort = new AbortController();
+      const events = bridge.subscribeEvents(session.sessionId, {
+        signal: abort.signal,
+      });
+      const userChunks: unknown[] = [];
+      const drain = (async () => {
+        for await (const event of events) {
+          if (event.type !== 'session_update') continue;
+          const update = (
+            event.data as {
+              update?: { sessionUpdate?: string; content?: unknown };
+            }
+          ).update;
+          if (update?.sessionUpdate !== 'user_message_chunk') continue;
+          userChunks.push(update.content);
+          if (
+            typeof update.content === 'object' &&
+            update.content !== null &&
+            (update.content as { type?: unknown }).type === 'resource_link'
+          ) {
+            break;
+          }
+        }
+      })();
+
+      await bridge.sendPrompt(
+        session.sessionId,
+        {
+          sessionId: session.sessionId,
+          prompt: [
+            { type: 'text', text: 'hidden first' },
+            { type: 'text', text: 'hidden second' },
+            { type: 'resource_link', uri: 'file:///visible', name: 'visible' },
+          ],
+        },
+        undefined,
+        { promptDisplayText: '' },
+      );
+
+      await drain;
+      expect(userChunks).toEqual([
+        { type: 'resource_link', uri: 'file:///visible', name: 'visible' },
+      ]);
+      abort.abort();
+      await bridge.shutdown();
+    });
+
+    it('does not leak a prompt slot for a malformed null block', async () => {
+      const handle = makeChannel({
+        promptImpl: () => ({ stopReason: 'end_turn' }),
+      });
+      const bridge = makeBridge({ channelFactory: async () => handle.channel });
+      const session = await bridge.spawnOrAttach({
+        workspaceCwd: WS_A,
+        sourceType: 'channel',
+      });
+
+      const malformedResult = await bridge
+        .sendPrompt(
+          session.sessionId,
+          {
+            sessionId: session.sessionId,
+            prompt: [null] as never,
+          },
+          undefined,
+          { promptDisplayText: '' },
+        )
+        .catch((error: unknown) => error);
+      expect(malformedResult).not.toBeInstanceOf(TypeError);
+      await expect(
+        bridge.sendPrompt(session.sessionId, {
+          sessionId: session.sessionId,
+          prompt: [{ type: 'text', text: 'next' }],
+        }),
+      ).resolves.toMatchObject({ stopReason: 'end_turn' });
+      await bridge.shutdown();
+    });
+
     it('echoes one user_message_chunk per content block (multi-modal)', async () => {
       const factory: ChannelFactory = async () =>
         makeChannel({ promptImpl: () => ({ stopReason: 'end_turn' }) }).channel;
@@ -9631,7 +9768,7 @@ describe('createAcpSessionBridge', () => {
           _meta: { 'qwen.daemon.promptDisplayText': '' },
         },
         undefined,
-        { promptId: 'prompt-second' },
+        { promptId: 'prompt-second', promptDisplayText: '' },
       );
 
       await new Promise((r) => setTimeout(r, 20));
diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts
index 477889c6aed..520236dbf2f 100644
--- a/packages/acp-bridge/src/bridge.ts
+++ b/packages/acp-bridge/src/bridge.ts
@@ -263,17 +263,15 @@ function sessionSourceRequestMeta(
 }
 
 /**
- * The daemon's channel adapter carries the user-facing display projection in
- * prompt meta; only channel sessions may use it — every other source echoes
- * its prompt content verbatim. Single source of truth for the echo, the
- * pending-entry text, and the re-arm strip so their `''`/missing-meta
- * semantics cannot drift apart.
+ * Only the daemon's authenticated channel-worker path can populate the
+ * user-facing display projection. Every other source echoes its prompt content
+ * verbatim. Single source of truth for the echo, pending-entry text, and child
+ * metadata so their `''`/undefined semantics cannot drift apart.
  */
 function getChannelPromptDisplayText(
   entry: Pick<SessionEntry, 'sourceType'>,
-  meta: Record<string, unknown> | null | undefined,
+  displayText: string | undefined,
 ): string | undefined {
-  const displayText = meta?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
   return entry.sourceType === 'channel' && typeof displayText === 'string'
     ? displayText
     : undefined;
@@ -1019,6 +1017,7 @@ function echoPromptToSessionBus(
   req: PromptRequest,
   promptId: string,
   originatorClientId: string | undefined,
+  displayText: string | undefined,
 ): void {
   // `PromptRequest.prompt` is a non-optional `ContentBlock[]` per the
   // ACP type contract — read it directly so a future SDK bump that
@@ -1030,12 +1029,21 @@ function echoPromptToSessionBus(
   // contract — cheaper than a thrown `TypeError` mid-echo.
   const prompt = req.prompt;
   if (!Array.isArray(prompt) || prompt.length === 0) return;
-  const displayText = getChannelPromptDisplayText(entry, req._meta);
   let displayTextPublished = false;
   const serverTimestamp = Date.now();
-  const blockCount = Math.min(prompt.length, MAX_ECHO_CONTENT_BLOCKS);
+  const echoPrompt = prompt.slice(0, MAX_ECHO_CONTENT_BLOCKS);
+  if (
+    displayText !== undefined &&
+    !echoPrompt.some((part) => isRecord(part) && part['type'] === 'text')
+  ) {
+    const textPart = prompt
+      .slice(MAX_ECHO_CONTENT_BLOCKS)
+      .find((part) => isRecord(part) && part['type'] === 'text');
+    if (textPart) echoPrompt[echoPrompt.length - 1] = textPart;
+  }
+  const blockCount = echoPrompt.length;
   for (let i = 0; i < blockCount; i += 1) {
-    const part = prompt[i];
+    const part = echoPrompt[i];
     if (!part || typeof part !== 'object' || Array.isArray(part)) continue;
     let displayPart = part;
     if (displayText !== undefined && part.type === 'text') {
@@ -6543,12 +6551,17 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
           );
         }
       }
-      const channelDisplayText = getChannelPromptDisplayText(entry, req._meta);
+      const channelDisplayText = getChannelPromptDisplayText(
+        entry,
+        context?.promptDisplayText,
+      );
       const pendingText =
         channelDisplayText === undefined
           ? extractPromptText(req.prompt)
           : channelDisplayText ||
-            (req.prompt.some((block) => block.type === 'image')
+            (req.prompt.some(
+              (block) => isRecord(block) && block['type'] === 'image',
+            )
               ? '[image]'
               : '');
       const pendingEntry: PendingPromptEntry = {
@@ -6747,10 +6760,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
                     copy._meta && typeof copy._meta === 'object'
                       ? { ...copy._meta }
                       : {};
-                  const promptDisplayText = getChannelPromptDisplayText(
-                    entry,
-                    meta,
-                  );
+                  const promptDisplayText = channelDisplayText;
                   delete meta[DAEMON_RETRY_META_KEY];
                   delete meta[INVOCATION_CONTEXT_META_KEY];
                   delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
@@ -6828,6 +6838,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
                       promptRequest,
                       pendingEntry.promptId,
                       originatorClientId,
+                      channelDisplayText,
                     );
                   }
                 } catch (echoErr) {
diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts
index 4d8b9cdb73d..832ee3c7ff6 100644
--- a/packages/acp-bridge/src/bridgeTypes.ts
+++ b/packages/acp-bridge/src/bridgeTypes.ts
@@ -677,6 +677,8 @@ export interface BridgeClientRequestContext {
    * unchanged. HTTP routes never populate this from request input.
    */
   modelPrompt?: string;
+  /** User-facing projection supplied by an authenticated channel worker. */
+  promptDisplayText?: string;
   /** Trusted Channel delivery correlation injected by the daemon prompt
    * route. Never populated from caller-controlled ACP metadata. */
   channelDelivery?: {
diff --git a/packages/channels/base/src/ChannelAgentBridge.ts b/packages/channels/base/src/ChannelAgentBridge.ts
index e9c6a5fe7a6..1641ddcca35 100644
--- a/packages/channels/base/src/ChannelAgentBridge.ts
+++ b/packages/channels/base/src/ChannelAgentBridge.ts
@@ -5,6 +5,8 @@ import type {
 
 export const CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY =
   'qwen.daemon.promptDisplayText';
+export const CHANNEL_PROMPT_AUTHORIZATION_META_KEY =
+  'qwen.daemon.channelPromptAuthorization';
 // Client-supplied routing hint only; never use it as an authorization boundary.
 export const CHANNEL_PROMPT_META_KEY = 'qwen.channel.prompt';
 
@@ -98,7 +100,8 @@ export interface ChannelAgentBridgeSessionOptions {
 export interface ChannelAgentBridgePromptOptions {
   imageBase64?: string;
   imageMimeType?: string;
-  /** User-authored text shown in transcripts when `text` includes hidden context. */
+  /** User-authored text shown in transcripts when `text` includes hidden context.
+   * `''` means no user-visible text and must not be treated as unset. */
   displayText?: string;
 }
 
diff --git a/packages/channels/base/src/ChannelBase.ts b/packages/channels/base/src/ChannelBase.ts
index 4bc6d843da7..9fd6d7454a3 100644
--- a/packages/channels/base/src/ChannelBase.ts
+++ b/packages/channels/base/src/ChannelBase.ts
@@ -5307,6 +5307,7 @@ export abstract class ChannelBase {
           }
           const bufferedDisplayText =
             (envelope.isGroup || this.config.sessionScope === 'single') &&
+            !envelope.alreadyPrefixed &&
             !recognizedSlashCommand
               ? `[${sanitizeSenderName(envelope.senderName || envelope.senderId || 'unknown')}] ${sanitizePromptText(displayText)}`
               : displayText;
diff --git a/packages/channels/base/src/DaemonChannelBridge.test.ts b/packages/channels/base/src/DaemonChannelBridge.test.ts
index 824f0f1f387..d32e4e89e26 100644
--- a/packages/channels/base/src/DaemonChannelBridge.test.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.test.ts
@@ -9,7 +9,10 @@ import {
   type DaemonChannelLoopMcpHost,
   type DaemonChannelSessionClient,
 } from './DaemonChannelBridge.js';
-import { CHANNEL_PROMPT_META_KEY } from './ChannelAgentBridge.js';
+import {
+  CHANNEL_PROMPT_AUTHORIZATION_META_KEY,
+  CHANNEL_PROMPT_META_KEY,
+} from './ChannelAgentBridge.js';
 
 class EventQueue implements AsyncGenerator<DaemonChannelEvent> {
   private events: DaemonChannelEvent[] = [];
@@ -178,6 +181,27 @@ describe('DaemonChannelBridge', () => {
     bridge.stop();
   });
 
+  it('keeps the live binding when permanent deletion fails', async () => {
+    const events = new EventQueue();
+    const session = createFakeSession(events);
+    const deleteSessionData = vi.fn().mockRejectedValue(new Error('locked'));
+    const bridge = new DaemonChannelBridge({
+      cwd: '/repo',
+      sessionFactory: vi.fn().mockResolvedValue(session),
+      deleteSessionData,
+    });
+
+    await bridge.start();
+    await bridge.newSession('/repo');
+    await expect(bridge.deleteSessionData?.('session-1')).rejects.toThrow(
+      'locked',
+    );
+
+    expect(bridge.listSessions()).toHaveLength(1);
+    events.close();
+    bridge.stop();
+  });
+
   it('registers the loop MCP server for the exact daemon session', async () => {
     const events = new EventQueue();
     const session = createFakeSession(events);
@@ -1920,6 +1944,7 @@ describe('DaemonChannelBridge', () => {
     const bridge = new DaemonChannelBridge({
       cwd: '/repo',
       sessionFactory: vi.fn().mockResolvedValue(session),
+      promptAuthorization: 'worker-token',
     });
 
     await bridge.start();
@@ -1938,6 +1963,7 @@ describe('DaemonChannelBridge', () => {
         prompt: [{ type: 'text', text: 'internal context\n\nhello' }],
         _meta: {
           [CHANNEL_PROMPT_META_KEY]: true,
+          [CHANNEL_PROMPT_AUTHORIZATION_META_KEY]: 'worker-token',
           'qwen.daemon.promptDisplayText': 'hello',
         },
       },
diff --git a/packages/channels/base/src/DaemonChannelBridge.ts b/packages/channels/base/src/DaemonChannelBridge.ts
index e288d50afa4..b036b533f10 100644
--- a/packages/channels/base/src/DaemonChannelBridge.ts
+++ b/packages/channels/base/src/DaemonChannelBridge.ts
@@ -4,6 +4,7 @@ import type {
   RequestPermissionResponse,
 } from '@agentclientprotocol/sdk';
 import {
+  CHANNEL_PROMPT_AUTHORIZATION_META_KEY,
   CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY,
   CHANNEL_PROMPT_META_KEY,
   type AvailableCommand,
@@ -89,6 +90,7 @@ export interface DaemonChannelBridgeOptions {
   sessionScope?: SessionScope;
   channelLoopMcpHost?: DaemonChannelLoopMcpHost;
   deleteSessionData?: (sessionId: string) => Promise<void>;
+  promptAuthorization?: string;
 }
 
 export interface DaemonPermissionRequestEvent {
@@ -244,11 +246,8 @@ export class DaemonChannelBridge
     const deleteSessionData = options.deleteSessionData;
     if (deleteSessionData) {
       this.deleteSessionData = async (sessionId) => {
-        try {
-          await deleteSessionData(sessionId);
-        } finally {
-          this.removeSessionBinding(sessionId);
-        }
+        await deleteSessionData(sessionId);
+        this.removeSessionBinding(sessionId);
       };
     }
     this.on('error', (error) => {
@@ -418,6 +417,10 @@ export class DaemonChannelBridge
       });
     }
     prompt.push({ type: 'text', text });
+    const promptAuthorization =
+      options?.displayText !== undefined
+        ? this.options.promptAuthorization
+        : undefined;
 
     try {
       const result = await session.prompt(
@@ -425,6 +428,11 @@ export class DaemonChannelBridge
           prompt,
           _meta: {
             [CHANNEL_PROMPT_META_KEY]: true,
+            ...(promptAuthorization
+              ? {
+                  [CHANNEL_PROMPT_AUTHORIZATION_META_KEY]: promptAuthorization,
+                }
+              : {}),
             ...(options?.displayText !== undefined
               ? {
                   [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: options.displayText,
diff --git a/packages/channels/github/src/GithubAdapter.ts b/packages/channels/github/src/GithubAdapter.ts
index 03efa6ae40c..46d1973b238 100644
--- a/packages/channels/github/src/GithubAdapter.ts
+++ b/packages/channels/github/src/GithubAdapter.ts
@@ -26,6 +26,8 @@ import {
   getWorkspaceScopeDirName,
   PollingChannelBase,
   sanitizeLogText,
+  sanitizePromptText,
+  truncateCodePoints,
 } from '@qwen-code/channel-base';
 import { testBotMention, stripBotMention } from './mention.js';
 
@@ -1384,6 +1386,7 @@ export class GithubChannel extends PollingChannelBase<GithubCursor> {
         ? await this.fetchPrMeta(ctx)
         : await this.fetchIssueMeta(ctx);
     const title = meta.title || ctx.subjectTitle;
+    const displayTitle = truncateCodePoints(sanitizePromptText(title), 500);
     const details =
       reason === 'review_requested'
         ? `Author: ${meta.user?.login || 'unknown'} | State: ${meta.state || 'unknown'} | Draft: ${meta.draft ? 'true' : 'false'} | Branch: ${meta.head?.ref || 'unknown'} → ${meta.base?.ref || 'unknown'}`
@@ -1403,8 +1406,8 @@ export class GithubChannel extends PollingChannelBase<GithubCursor> {
           : 'Triage this issue and respond with the next action.',
       displayText:
         reason === 'review_requested'
-          ? `Review requested: ${title}`
-          : `Issue assigned: ${title}`,
+          ? `Review requested: ${displayTitle}`
+          : `Issue assigned: ${displayTitle}`,
       isGroup: true,
       isMentioned: true,
       isReplyToBot: false,
diff --git a/packages/channels/qqbot/src/QQChannel.ts b/packages/channels/qqbot/src/QQChannel.ts
index c10e460f614..c8f75a0d0a5 100644
--- a/packages/channels/qqbot/src/QQChannel.ts
+++ b/packages/channels/qqbot/src/QQChannel.ts
@@ -2306,6 +2306,12 @@ export class QQChannel extends ChannelBase {
 
     const content = (event.content || '').trim();
     const cleanText = content.replace(/<@[^>]{1,64}>/g, '').trim();
+    let mentionIndex = 0;
+    const displayContent = content
+      .replace(/<@[^>]{1,64}>/g, (mention) =>
+        event.mentions?.[mentionIndex++]?.is_you ? '' : mention,
+      )
+      .trim();
     // Strip trusted tags that could be forged by users
     const safeContent = content
       .replace(/\[atMention=[^\]]*]/g, '')
@@ -2316,6 +2322,11 @@ export class QQChannel extends ChannelBase {
       .replace(/\[botOpenId:[^\]]*]/g, '')
       .replace(/\[bot]/g, '')
       .trim();
+    const safeDisplayText = displayContent
+      .replace(/\[atMention=[^\]]*]/g, '')
+      .replace(/\[botOpenId:[^\]]*]/g, '')
+      .replace(/\[bot]/g, '')
+      .trim();
     const isAtBot = event.mentions?.some((m) => m.is_you) ?? false;
 
     // Extract bot's own OPENID from mentions (per-group) — must come
@@ -2329,7 +2340,7 @@ export class QQChannel extends ChannelBase {
 
     const effectiveIsAtBot = forceAtMention ?? isAtBot;
 
-    const isSlash = effectiveIsAtBot && safeCleanText.startsWith('/');
+    const isSlash = effectiveIsAtBot && safeDisplayText.startsWith('/');
 
     // Deliberately NOT hard-blocking bot messages — QQ Bot API may deliver
     // self-echoes or other bot messages. Instead, tag with [bot] prefix so the
@@ -2398,7 +2409,7 @@ export class QQChannel extends ChannelBase {
     const text = isSlash
       ? sanitizePromptText(safeCleanText)
       : `[atMention=${effectiveIsAtBot}]${openIdSuffix} [${safeName}${senderTag}]: ${sanitizePromptText(this.qqConfig.allowMention !== false ? safeContent : safeCleanText)}${suffixFromBotOpenId}`;
-    const displayText = sanitizePromptText(safeCleanText);
+    const displayText = sanitizePromptText(safeDisplayText);
 
     return {
       isAtBot: effectiveIsAtBot,
diff --git a/packages/channels/qqbot/src/events.test.ts b/packages/channels/qqbot/src/events.test.ts
index f00a258113c..78e0e09dbc2 100644
--- a/packages/channels/qqbot/src/events.test.ts
+++ b/packages/channels/qqbot/src/events.test.ts
@@ -418,6 +418,24 @@ describe('handleGroup', () => {
     expect(env['displayText']).toBe('你好');
   });
 
+  it('可见文本只移除机器人 mention', async () => {
+    const ch = makeChannel();
+    const pvt = ch as unknown as QQChannelRaw;
+    pvt['handleGroup'](
+      makeGroupEvent({
+        content: '<@OPENID_BOT> ask <@OPENID_ALICE> now',
+        mentions: [
+          { member_openid: 'bot-openid', is_you: true },
+          { member_openid: 'alice-openid', is_you: false },
+        ],
+      }),
+    );
+    await vi.advanceTimersByTimeAsync(600);
+
+    const env = mockHandleInbound.mock.calls[0][0] as Record<string, unknown>;
+    expect(env['displayText']).toBe('ask <@OPENID_ALICE> now');
+  });
+
   it('allowMention=false 时清理 <@OPENID> 标签', async () => {
     const ch = makeChannel({ allowMention: false });
     const pvt = ch as unknown as QQChannelRaw;
diff --git a/packages/cli/src/commands/channel/channel-registry.test.ts b/packages/cli/src/commands/channel/channel-registry.test.ts
index f86d39edf8d..c625cfc13f2 100644
--- a/packages/cli/src/commands/channel/channel-registry.test.ts
+++ b/packages/cli/src/commands/channel/channel-registry.test.ts
@@ -21,6 +21,58 @@ function invalidPlugin(
 }
 
 describe('channel registry', () => {
+  it('publishes a plugin session-scope descriptor once with its runtime default', async () => {
+    registerPlugin({
+      channelType: 'valid-custom-session-scope',
+      displayName: 'Custom scope',
+      defaultSessionScope: 'thread',
+      management: {
+        fields: [
+          {
+            key: 'sessionScope',
+            label: 'Conversation scope',
+            kind: 'enum',
+            options: [
+              { value: 'user', label: 'User' },
+              { value: 'thread', label: 'Thread' },
+            ],
+          },
+        ],
+      },
+      createChannel() {
+        throw new Error('not used');
+      },
+    });
+
+    const descriptor = (await supportedChannelCatalog()).find(
+      (entry) => entry.type === 'valid-custom-session-scope',
+    );
+    const scopeFields = descriptor?.fields.filter(
+      (field) => field.key === 'sessionScope',
+    );
+    expect(scopeFields).toHaveLength(1);
+    expect(scopeFields?.[0]).toMatchObject({
+      label: 'Conversation scope',
+      default: 'thread',
+    });
+  });
+
+  it('strips management for an invalid runtime session-scope default', async () => {
+    registerPlugin({
+      channelType: 'invalid-session-scope-default',
+      displayName: 'Invalid scope',
+      defaultSessionScope: 'workspace' as never,
+      management: { fields: [] },
+      createChannel() {
+        throw new Error('not used');
+      },
+    });
+
+    await expect(getPlugin('invalid-session-scope-default')).resolves.toEqual(
+      expect.objectContaining({ management: undefined }),
+    );
+  });
+
   it.each([
     {
       type: 'invalid-nested-secret',
diff --git a/packages/cli/src/commands/channel/channel-registry.ts b/packages/cli/src/commands/channel/channel-registry.ts
index 8b0bf6c6583..302c7f3badd 100644
--- a/packages/cli/src/commands/channel/channel-registry.ts
+++ b/packages/cli/src/commands/channel/channel-registry.ts
@@ -165,6 +165,14 @@ function assertManagementField(
 function assertManagementDescriptor(plugin: ChannelPlugin): void {
   const management = plugin.management;
   if (management === undefined) return;
+  const defaultSessionScope: unknown = plugin.defaultSessionScope ?? 'user';
+  if (
+    !SESSION_SCOPE_OPTIONS.some(
+      (option) => option.value === defaultSessionScope,
+    )
+  ) {
+    throw new Error('Channel defaultSessionScope is invalid.');
+  }
   if (
     management.validateConfig !== undefined &&
     (typeof management.validateConfig !== 'function' ||
@@ -178,6 +186,23 @@ function assertManagementDescriptor(plugin: ChannelPlugin): void {
     throw new Error('Channel management metadata must declare a fields array.');
   }
   assertManagementFields(management.fields);
+  const sessionScopeField = management.fields.find(
+    (field) => field.key === 'sessionScope',
+  );
+  if (sessionScopeField) {
+    if (sessionScopeField.kind !== 'enum') {
+      throw new Error('Channel field "sessionScope" must be an enum.');
+    }
+    if (
+      !sessionScopeField.options?.some(
+        (option: { value: string }) => option.value === defaultSessionScope,
+      )
+    ) {
+      throw new Error(
+        'Channel field "sessionScope" must include the channel defaultSessionScope.',
+      );
+    }
+  }
 }
 
 const SESSION_SCOPE_OPTIONS: ReadonlyArray<{
@@ -286,6 +311,12 @@ export async function supportedChannelCatalog(): Promise<
   return [...registry.values()].map((plugin) => {
     const { channelType, displayName, management } = plugin;
     const fields = management?.fields ?? [];
+    const defaultSessionScope = plugin.defaultSessionScope ?? 'user';
+    const normalizedFields = fields.map((field) =>
+      field.key === 'sessionScope' && field.default === undefined
+        ? { ...field, default: defaultSessionScope }
+        : field,
+    );
     return {
       type: channelType,
       displayName,
@@ -293,19 +324,19 @@ export async function supportedChannelCatalog(): Promise<
       fields:
         management && !fields.some((field) => field.key === 'sessionScope')
           ? [
-              ...fields,
+              ...normalizedFields,
               {
                 key: 'sessionScope',
                 label: 'Session scope',
                 kind: 'enum',
                 required: true,
-                default: plugin.defaultSessionScope ?? 'user',
+                default: defaultSessionScope,
                 description:
                   'Controls which incoming conversations share one agent session.',
                 options: SESSION_SCOPE_OPTIONS,
               },
             ]
-          : fields,
+          : normalizedFields,
     };
   });
 }
diff --git a/packages/cli/src/commands/channel/daemon-worker.test.ts b/packages/cli/src/commands/channel/daemon-worker.test.ts
index ee8025cd0e9..199447a797a 100644
--- a/packages/cli/src/commands/channel/daemon-worker.test.ts
+++ b/packages/cli/src/commands/channel/daemon-worker.test.ts
@@ -870,6 +870,7 @@ describe('runChannelDaemonWorker', () => {
     const handle = await runChannelDaemonWorker({
       daemonUrl: 'http://127.0.0.1:4170',
       daemonToken: 'secret-token',
+      promptAuthorization: 'worker-prompt-token',
       workspace: '/workspace',
       selection: { mode: 'names', names: ['telegram'] },
       loadDaemonSdk: async () => sdk,
@@ -890,6 +891,7 @@ describe('runChannelDaemonWorker', () => {
       expect.objectContaining({
         cwd: '/workspace',
         modelServiceId: 'qwen-plus',
+        promptAuthorization: 'worker-prompt-token',
       }),
     );
     const bridgeFacade = mockSessionRouter.mock.calls[0]![0] as {
diff --git a/packages/cli/src/commands/channel/daemon-worker.ts b/packages/cli/src/commands/channel/daemon-worker.ts
index 46b2d28478a..d23a71cc4f8 100644
--- a/packages/cli/src/commands/channel/daemon-worker.ts
+++ b/packages/cli/src/commands/channel/daemon-worker.ts
@@ -185,6 +185,7 @@ export interface RunChannelDaemonWorkerOptions {
   reportStartup?: (message: ChannelStartupReportMessage) => Promise<void>;
   startupSignal?: AbortSignal;
   channelLoopMcpHost?: DaemonChannelLoopMcpHost;
+  promptAuthorization?: string;
 }
 
 export function createDaemonSessionFactory({
@@ -488,6 +489,9 @@ export async function runChannelDaemonWorker(
       DaemonSessionClient: sdk.DaemonSessionClient,
       clientId: `qwen-channel-worker:${process.pid}`,
     }),
+    ...(opts.promptAuthorization
+      ? { promptAuthorization: opts.promptAuthorization }
+      : {}),
     deleteSessionData: async (sessionId) => {
       const workspaceClient = client.workspaceByCwd?.(daemonWorkspace);
       if (!workspaceClient) {
@@ -794,6 +798,7 @@ function scrubDaemonWorkerEnv(): void {
 function readDaemonWorkerEnv(): {
   daemonToken: string | undefined;
   daemonUrl: string;
+  promptAuthorization: string;
   workspace: string;
 } {
   const daemonToken = process.env[QWEN_DAEMON_TOKEN_ENV];
@@ -801,6 +806,7 @@ function readDaemonWorkerEnv(): {
     return {
       daemonToken,
       daemonUrl: readRequiredEnv(QWEN_DAEMON_URL_ENV),
+      promptAuthorization: readRequiredEnv(CHANNEL_DAEMON_WORKER_SENTINEL),
       workspace: readRequiredEnv(QWEN_DAEMON_WORKSPACE_ENV),
     };
   } finally {
@@ -929,7 +935,8 @@ export const daemonWorkerCommand: CommandModule<unknown, DaemonWorkerArgs> = {
 
     try {
       assertInternalDaemonWorkerInvocation();
-      const { daemonToken, daemonUrl, workspace } = readDaemonWorkerEnv();
+      const { daemonToken, daemonUrl, promptAuthorization, workspace } =
+        readDaemonWorkerEnv();
       // Mirror the ACP-child self-scrub: in dev mode the supervisor spawns
       // this worker with the daemon's loader-carrying base env (the harness
       // tsx loader must reach this .ts entry), but nothing the worker spawns
@@ -958,6 +965,7 @@ export const daemonWorkerCommand: CommandModule<unknown, DaemonWorkerArgs> = {
       const handle = await runChannelDaemonWorker({
         daemonUrl,
         daemonToken,
+        promptAuthorization,
         workspace,
         selection,
         startupSignal: startupAbortController.signal,
diff --git a/packages/cli/src/serve/channel-worker-prompt-authorization.ts b/packages/cli/src/serve/channel-worker-prompt-authorization.ts
new file mode 100644
index 00000000000..c4eb8ba059f
--- /dev/null
+++ b/packages/cli/src/serve/channel-worker-prompt-authorization.ts
@@ -0,0 +1,24 @@
+const workspacesByToken = new Map<string, string>();
+
+export const CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY =
+  'qwen.daemon.channelPromptAuthorization';
+
+export function registerChannelWorkerPromptAuthorization(
+  token: string,
+  workspaceCwd: string,
+): void {
+  workspacesByToken.set(token, workspaceCwd);
+}
+
+export function revokeChannelWorkerPromptAuthorization(token: string): void {
+  workspacesByToken.delete(token);
+}
+
+export function isChannelWorkerPromptAuthorized(
+  token: unknown,
+  workspaceCwd: string,
+): boolean {
+  return (
+    typeof token === 'string' && workspacesByToken.get(token) === workspaceCwd
+  );
+}
diff --git a/packages/cli/src/serve/channel-worker-supervisor.test.ts b/packages/cli/src/serve/channel-worker-supervisor.test.ts
index 220576fd0d8..403d3cd2a92 100644
--- a/packages/cli/src/serve/channel-worker-supervisor.test.ts
+++ b/packages/cli/src/serve/channel-worker-supervisor.test.ts
@@ -6,6 +6,7 @@ import {
   createChannelWorkerSupervisor,
   type ChannelWorkerChild,
 } from './channel-worker-supervisor.js';
+import { isChannelWorkerPromptAuthorized } from './channel-worker-prompt-authorization.js';
 import { CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS } from './channel-worker-env.js';
 import { MAX_CHANNEL_STARTUP_FAILURES } from './channel-worker-startup-ipc.js';
 import {
@@ -254,6 +255,13 @@ describe('createChannelWorkerSupervisor', () => {
     expect(env).toHaveProperty('TELEGRAM_BOT_TOKEN', 'telegram-secret');
     expect(env).toHaveProperty('HTTPS_PROXY', 'http://proxy.example.com:8080');
     expect(env['QWEN_CHANNEL_DAEMON_WORKER']).not.toBe('1');
+    const promptAuthorization = env['QWEN_CHANNEL_DAEMON_WORKER']!;
+    expect(
+      isChannelWorkerPromptAuthorized(promptAuthorization, '/workspace'),
+    ).toBe(true);
+    expect(isChannelWorkerPromptAuthorized(promptAuthorization, '/other')).toBe(
+      false,
+    );
     const argv = spawnWorker.mock.calls[0]![1];
     expect(argv).not.toContain('secret-token');
     expect(supervisor.snapshot()).toMatchObject({
@@ -263,6 +271,10 @@ describe('createChannelWorkerSupervisor', () => {
       channels: ['telegram', 'feishu'],
       requestedChannels: ['telegram', 'feishu'],
     });
+    supervisor.killAllSync();
+    expect(
+      isChannelWorkerPromptAuthorized(promptAuthorization, '/workspace'),
+    ).toBe(false);
   });
 
   it('ignores non-ready IPC messages before the ready message', async () => {
diff --git a/packages/cli/src/serve/channel-worker-supervisor.ts b/packages/cli/src/serve/channel-worker-supervisor.ts
index f1432cddf4f..1de48a5a3c5 100644
--- a/packages/cli/src/serve/channel-worker-supervisor.ts
+++ b/packages/cli/src/serve/channel-worker-supervisor.ts
@@ -54,6 +54,10 @@ import {
   type ChannelAdapterSnapshot,
   type ChannelStartupFailure,
 } from './channel-worker-startup-ipc.js';
+import {
+  registerChannelWorkerPromptAuthorization,
+  revokeChannelWorkerPromptAuthorization,
+} from './channel-worker-prompt-authorization.js';
 import {
   CHANNEL_LOOP_MCP_IPC_TIMEOUT_MS,
   createChannelLoopMcpRequest,
@@ -492,6 +496,7 @@ export function createChannelWorkerSupervisor(
     );
   }
   let child: ChannelWorkerChild | undefined;
+  let activePromptAuthorization: string | undefined;
   let snapshot: ChannelWorkerSnapshot = {
     enabled: true,
     state: 'disabled',
@@ -787,6 +792,18 @@ export function createChannelWorkerSupervisor(
       ...(opts.daemonToken ? { daemonToken: opts.daemonToken } : {}),
       ...(opts.workerBaseEnv ? { baseEnv: opts.workerBaseEnv } : {}),
     });
+    const promptAuthorization = env[CHANNEL_DAEMON_WORKER_SENTINEL]!;
+    registerChannelWorkerPromptAuthorization(
+      promptAuthorization,
+      opts.workspace,
+    );
+    activePromptAuthorization = promptAuthorization;
+    const revokePromptAuthorization = () => {
+      revokeChannelWorkerPromptAuthorization(promptAuthorization);
+      if (activePromptAuthorization === promptAuthorization) {
+        activePromptAuthorization = undefined;
+      }
+    };
     const redaction = workerLogRedactionOptions(opts.daemonToken, env);
     const requestedChannels = requestedChannelNames(opts.selection);
     const startedAt = new Date().toISOString();
@@ -832,6 +849,7 @@ export function createChannelWorkerSupervisor(
         stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
       });
     } catch (err) {
+      revokePromptAuthorization();
       const message = err instanceof Error ? err.message : String(err);
       const error = sanitizeWorkerError(message, redaction);
       if (kind === 'initial') {
@@ -1247,6 +1265,7 @@ export function createChannelWorkerSupervisor(
       }
       function settleExit(code: number | null, signal: NodeJS.Signals | null) {
         if (child !== startedChild) return;
+        revokePromptAuthorization();
         exitObserved = true;
         cleanupLaunch();
         const state = ready ? 'exited' : 'failed';
@@ -1436,6 +1455,10 @@ export function createChannelWorkerSupervisor(
       clearRestartTimer();
       clearStaleHeartbeatTimer();
       stopping = true;
+      if (activePromptAuthorization) {
+        revokeChannelWorkerPromptAuthorization(activePromptAuthorization);
+        activePromptAuthorization = undefined;
+      }
       child.kill('SIGKILL');
       child = undefined;
       if (!preserveFailure) {
diff --git a/packages/cli/src/serve/routes/session.ts b/packages/cli/src/serve/routes/session.ts
index 29475279b97..6c0a6f230f9 100644
--- a/packages/cli/src/serve/routes/session.ts
+++ b/packages/cli/src/serve/routes/session.ts
@@ -31,6 +31,7 @@ import {
   type SessionArchiveState,
 } from '@qwen-code/qwen-code-core';
 import type { SessionArtifactInput } from '@qwen-code/acp-bridge/sessionArtifacts';
+import { DAEMON_PROMPT_DISPLAY_TEXT_META_KEY } from '@qwen-code/acp-bridge/bridgeTypes';
 import { parseSessionSource } from '@qwen-code/acp-bridge';
 import {
   isReservedLiveSessionSource,
@@ -125,6 +126,10 @@ import {
   runWithWorkspaceRuntimeStorage,
 } from '../workspace-runtime-storage.js';
 import type { ChannelDeliveryAuthorizationStore } from '../channel-delivery-authorization.js';
+import {
+  CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY,
+  isChannelWorkerPromptAuthorized,
+} from '../channel-worker-prompt-authorization.js';
 import {
   createRequestedSessionIdAdmission,
   RequestedSessionIdAdmissionError,
@@ -3311,6 +3316,33 @@ export function registerSessionRoutes(
         const forwardedBody = { ...body };
         delete forwardedBody['deadlineMs'];
         delete forwardedBody['delivery'];
+        const forwardedMeta =
+          typeof forwardedBody['_meta'] === 'object' &&
+          forwardedBody['_meta'] !== null &&
+          !Array.isArray(forwardedBody['_meta'])
+            ? { ...(forwardedBody['_meta'] as Record<string, unknown>) }
+            : undefined;
+        const promptAuthorization =
+          forwardedMeta?.[CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY];
+        const promptDisplayText =
+          forwardedMeta?.[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
+        if (forwardedMeta) {
+          delete forwardedMeta[CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY];
+          delete forwardedMeta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
+          if (Object.keys(forwardedMeta).length > 0) {
+            forwardedBody['_meta'] = forwardedMeta;
+          } else {
+            delete forwardedBody['_meta'];
+          }
+        }
+        const trustedPromptDisplayText =
+          typeof promptDisplayText === 'string' &&
+          isChannelWorkerPromptAuthorized(
+            promptAuthorization,
+            runtime.workspaceCwd,
+          )
+            ? promptDisplayText
+            : undefined;
 
         const lastEventId = ownerBridge.getSessionLastEventId(sessionId);
         // Epoch token paired with the cursor above: a client that seeds its
@@ -3357,6 +3389,9 @@ export function registerSessionRoutes(
               ...(effectiveDeadlineMs !== undefined
                 ? { deadlineMs: effectiveDeadlineMs }
                 : {}),
+              ...(trustedPromptDisplayText !== undefined
+                ? { promptDisplayText: trustedPromptDisplayText }
+                : {}),
               ...(delivery !== undefined
                 ? {
                     channelDelivery: {
diff --git a/packages/cli/src/serve/server.test.ts b/packages/cli/src/serve/server.test.ts
index 758593730cf..85d42582cc3 100644
--- a/packages/cli/src/serve/server.test.ts
+++ b/packages/cli/src/serve/server.test.ts
@@ -39,6 +39,12 @@ import {
 } from './channel-worker-manager.js';
 import { runQwenServe, type RunHandle } from './run-qwen-serve.js';
 import { ChannelDeliveryAuthorizationStore } from './channel-delivery-authorization.js';
+import {
+  CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY,
+  registerChannelWorkerPromptAuthorization,
+  revokeChannelWorkerPromptAuthorization,
+} from './channel-worker-prompt-authorization.js';
+import { CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY } from '@qwen-code/channel-base';
 import {
   resolveWebShellDir,
   isDocumentNavigation,
@@ -12165,6 +12171,55 @@ describe('createServeApp', () => {
       expect(bridge.promptCalls[0]?.context?.promptId).toBe(res.body.promptId);
     });
 
+    it('accepts channel display text only from the workspace worker', async () => {
+      const bridge = fakeBridge();
+      const app = createServeApp(baseOpts, undefined, { bridge });
+      const workspace = realpathSync(process.cwd());
+      const token = 'channel-worker-prompt-token';
+      registerChannelWorkerPromptAuthorization(token, workspace);
+      try {
+        const forged = await request(app)
+          .post('/session/session-A/prompt')
+          .set('Host', `127.0.0.1:${baseOpts.port}`)
+          .send({
+            prompt: [{ type: 'text', text: 'model text' }],
+            _meta: {
+              [CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY]: 'forged',
+              [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: 'forged display',
+            },
+          });
+        const trusted = await request(app)
+          .post('/session/session-A/prompt')
+          .set('Host', `127.0.0.1:${baseOpts.port}`)
+          .send({
+            prompt: [{ type: 'text', text: 'model text' }],
+            _meta: {
+              [CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY]: token,
+              [CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY]: 'visible text',
+            },
+          });
+
+        expect(forged.status).toBe(202);
+        expect(trusted.status).toBe(202);
+        expect(
+          bridge.promptCalls[0]?.context?.promptDisplayText,
+        ).toBeUndefined();
+        expect(bridge.promptCalls[1]?.context?.promptDisplayText).toBe(
+          'visible text',
+        );
+        for (const call of bridge.promptCalls) {
+          expect(call.req._meta ?? {}).not.toHaveProperty(
+            CHANNEL_WORKER_PROMPT_AUTHORIZATION_META_KEY,
+          );
+          expect(call.req._meta ?? {}).not.toHaveProperty(
+            CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY,
+          );
+        }
+      } finally {
+        revokeChannelWorkerPromptAuthorization(token);
+      }
+    });
+
     it('validates delivery and forwards it only through trusted prompt context', async () => {
       const bridge = fakeBridge();
       const channelDeliveryAuthorizations =
diff --git a/packages/cli/src/ui/commands/renameCommand.ts b/packages/cli/src/ui/commands/renameCommand.ts
index 8ccc02927b2..eb7bb841f79 100644
--- a/packages/cli/src/ui/commands/renameCommand.ts
+++ b/packages/cli/src/ui/commands/renameCommand.ts
@@ -185,7 +185,7 @@ export const renameCommand: SlashCommand = {
           [];
         const lastDisplayText = userDisplayTexts.at(-1)?.trim();
         const titleDisplayTexts = lastDisplayText?.match(
-          /^\/rename(?:\s+--auto)?$/,
+          /^\/(?:rename|tag)(?:\s+--auto)?$/i,
         )
           ? userDisplayTexts.slice(0, -1)
           : userDisplayTexts;
diff --git a/packages/core/src/services/chatRecordingService.test.ts b/packages/core/src/services/chatRecordingService.test.ts
index 0d03f83e5c3..3d24e6973bc 100644
--- a/packages/core/src/services/chatRecordingService.test.ts
+++ b/packages/core/src/services/chatRecordingService.test.ts
@@ -647,6 +647,42 @@ describe('ChatRecordingService', () => {
   });
 
   describe('rewindRecording', () => {
+    it('drops display projections from rewound user turns', async () => {
+      chatRecordingService.recordUserMessage(
+        [{ text: 'hidden A' }],
+        undefined,
+        {
+          displayText: 'A',
+          hookContext: '',
+        },
+      );
+      chatRecordingService.recordUserMessage(
+        [{ text: 'hidden B' }],
+        undefined,
+        {
+          displayText: 'B',
+          hookContext: '',
+        },
+      );
+
+      chatRecordingService.rewindRecording(1, { truncatedCount: 1 });
+      chatRecordingService.recordUserMessage(
+        [{ text: 'hidden C' }],
+        undefined,
+        {
+          displayText: 'C',
+          hookContext: '',
+        },
+      );
+
+      expect(chatRecordingService.getUserDisplayTextsForTitle()).toEqual([
+        'A',
+        'C',
+      ]);
+      await chatRecordingService.flush();
+      vi.mocked(jsonl.writeLine).mockClear();
+    });
+
     it('preserves a resumed user turn parent when rebuilding rewind boundaries', async () => {
       vi.mocked(mockConfig.getResumedSessionData).mockReturnValue({
         lastCompletedUuid: 'assistant-1',
diff --git a/packages/core/src/services/chatRecordingService.ts b/packages/core/src/services/chatRecordingService.ts
index ccc3fd22408..5a7ae16efb1 100644
--- a/packages/core/src/services/chatRecordingService.ts
+++ b/packages/core/src/services/chatRecordingService.ts
@@ -1770,6 +1770,13 @@ export class ChatRecordingService {
     try {
       // Re-root: point back to the record just before the target user turn.
       this.lastRecordUuid = this.turnParentUuids[targetTurnIndex] ?? null;
+      const projectionStart = Math.max(
+        0,
+        this.turnParentUuids.length - this.userDisplayTextsForTitle.length,
+      );
+      this.userDisplayTextsForTitle.splice(
+        Math.max(0, targetTurnIndex - projectionStart),
+      );
       // Trim future boundaries — they no longer exist in the active branch.
       this.turnParentUuids = this.turnParentUuids.slice(0, targetTurnIndex);
       // The previous attribution snapshot now sits on the abandoned
diff --git a/packages/core/src/services/sessionService.test.ts b/packages/core/src/services/sessionService.test.ts
index 56c293fce3b..dad061db6c9 100644
--- a/packages/core/src/services/sessionService.test.ts
+++ b/packages/core/src/services/sessionService.test.ts
@@ -441,6 +441,37 @@ describe('SessionService', () => {
       expect(result.items[0].prompt).toBe('later prompt');
     });
 
+    it('should skip internal user-subtype records after an empty projection', async () => {
+      readdirSyncSpy.mockReturnValue([
+        `${sessionIdA}.jsonl`,
+      ] as unknown as Array<fs.Dirent<Buffer>>);
+      statSyncSpy.mockReturnValue({
+        mtimeMs: Date.now(),
+        isFile: () => true,
+      } as fs.Stats);
+      vi.mocked(jsonl.readLines).mockResolvedValue([
+        {
+          ...recordA1,
+          systemPayload: { displayText: '', hookContext: '' },
+        },
+        {
+          ...recordA1,
+          uuid: 'cron',
+          subtype: 'cron',
+          message: { role: 'user', parts: [{ text: 'internal cron prompt' }] },
+        },
+        {
+          ...recordA1,
+          uuid: 'later-user',
+          message: { role: 'user', parts: [{ text: 'later prompt' }] },
+        },
+      ]);
+
+      const result = await sessionService.listSessions();
+
+      expect(result.items[0].prompt).toBe('later prompt');
+    });
+
     it('should NOT populate messageCount during listing', async () => {
       // Listing must avoid the full-file readline that counting requires
       // — message counts are now lazy and provided by
@@ -485,6 +516,28 @@ describe('SessionService', () => {
       expect(result.items[0].prompt.endsWith('...')).toBe(true);
     });
 
+    it('should truncate long prompts on code-point boundaries', async () => {
+      const longPrompt = '😀'.repeat(300);
+      readdirSyncSpy.mockReturnValue([
+        `${sessionIdA}.jsonl`,
+      ] as unknown as Array<fs.Dirent<Buffer>>);
+      statSyncSpy.mockReturnValue({
+        mtimeMs: Date.now(),
+        isFile: () => true,
+      } as fs.Stats);
+      vi.mocked(jsonl.readLines).mockResolvedValue([
+        {
+          ...recordA1,
+          message: { role: 'user', parts: [{ text: longPrompt }] },
+        },
+      ]);
+
+      const result = await sessionService.listSessions();
+
+      expect(Array.from(result.items[0].prompt)).toHaveLength(203);
+      expect(result.items[0].prompt).toBe(`${'😀'.repeat(200)}...`);
+    });
+
     it('should paginate with size parameter', async () => {
       const now = Date.now();
 
diff --git a/packages/core/src/services/sessionService.ts b/packages/core/src/services/sessionService.ts
index 0e8417b0369..404598c78c4 100644
--- a/packages/core/src/services/sessionService.ts
+++ b/packages/core/src/services/sessionService.ts
@@ -869,7 +869,7 @@ export class SessionService {
    */
   private extractFirstPromptFromRecords(records: ChatRecord[]): string {
     for (const record of records) {
-      if (record.type !== 'user') continue;
+      if (record.type !== 'user' || record.subtype !== undefined) continue;
       const payload = record.systemPayload as
         | UserPromptRecordPayload
         | undefined;
@@ -889,10 +889,14 @@ export class SessionService {
   }
 
   private truncatePromptForDisplay(text: string): string {
-    const codePoints = Array.from(text);
-    return codePoints.length > 200
-      ? `${codePoints.slice(0, 200).join('')}...`
-      : text;
+    const codePoints: string[] = [];
+    for (const codePoint of text) {
+      if (codePoints.length === 200) {
+        return `${codePoints.join('')}...`;
+      }
+      codePoints.push(codePoint);
+    }
+    return text;
   }
 
   /**
diff --git a/packages/core/src/services/sessionTitle.test.ts b/packages/core/src/services/sessionTitle.test.ts
index 5ee8a6eadf7..7a9f0dfe95f 100644
--- a/packages/core/src/services/sessionTitle.test.ts
+++ b/packages/core/src/services/sessionTitle.test.ts
@@ -203,6 +203,29 @@ describe('tryGenerateSessionTitle', () => {
     expect(prompt).not.toContain('hidden second instructions');
   });
 
+  it('does not align a display projection onto an intervening system turn', async () => {
+    const { config, generateJson } = makeConfig({
+      fastModel: 'qwen-turbo',
+      history: [
+        { role: 'user', parts: [{ text: 'hidden channel instructions' }] },
+        { role: 'model', parts: [{ text: 'First reply' }] },
+        { role: 'user', parts: [{ text: 'internal cron prompt' }] },
+        { role: 'model', parts: [{ text: 'Cron reply' }] },
+      ],
+      generateJsonResult: { title: 'Answer greeting' },
+    });
+
+    await tryGenerateSessionTitle(config, new AbortController().signal, [
+      'visible channel message',
+    ]);
+
+    const call = generateJson.mock.calls[0][0] as { contents: Content[] };
+    const prompt = call.contents[0]?.parts?.[0]?.text;
+    expect(prompt).toContain('visible channel message');
+    expect(prompt).not.toContain('hidden channel instructions');
+    expect(prompt).not.toContain('internal cron prompt');
+  });
+
   it('omits unprojected older user turns from resumed channel history', async () => {
     const { config, generateJson } = makeConfig({
       fastModel: 'qwen-turbo',
diff --git a/packages/core/src/services/sessionTitle.ts b/packages/core/src/services/sessionTitle.ts
index 4c5d341b7c2..e64ac5d6d67 100644
--- a/packages/core/src/services/sessionTitle.ts
+++ b/packages/core/src/services/sessionTitle.ts
@@ -120,22 +120,14 @@ export async function tryGenerateSessionTitle(
     const fullHistory = geminiClient.getHistoryShallow();
     if (fullHistory.length < 2) return { ok: false, reason: 'empty_history' };
 
-    const dialog = filterToDialog(fullHistory);
-    if (userDisplayTexts.some((displayText) => displayText !== undefined)) {
-      let displayTextIndex = userDisplayTexts.length - 1;
-      for (let index = dialog.length - 1; index >= 0; index--) {
-        if (dialog[index].role !== 'user') continue;
-        const hasRecordedDisplayText = displayTextIndex >= 0;
-        const displayText = hasRecordedDisplayText
-          ? userDisplayTexts[displayTextIndex--]
-          : '';
-        if (displayText === undefined) continue;
-        dialog[index] = {
-          ...dialog[index],
-          parts: displayText ? [{ text: displayText }] : [],
-        };
-      }
-    }
+    const hasDisplayProjection = userDisplayTexts.some(
+      (displayText) => displayText !== undefined,
+    );
+    const dialog = hasDisplayProjection
+      ? userDisplayTexts.flatMap((displayText): Content[] =>
+          displayText ? [{ role: 'user', parts: [{ text: displayText }] }] : [],
+        )
+      : filterToDialog(fullHistory);
     const recentHistory = takeRecentDialog(dialog, RECENT_MESSAGE_WINDOW);
     if (recentHistory.length === 0) {
       return { ok: false, reason: 'empty_history' };
diff --git a/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx b/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx
index 1dc29584e6b..10961af8c3f 100644
--- a/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx
+++ b/packages/web-shell/client/components/channels/ChannelEditorDialog.tsx
@@ -555,7 +555,7 @@ export function ChannelEditorDialog({
     (field) => field.key === 'sessionScope',
   );
   const platformFields = descriptor.fields.filter(
-    (field) => field.key !== 'sessionScope',
+    (field) => field.key !== 'sessionScope' && field.kind !== 'object',
   );
 
   return (
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 44aa0e3a119..52bc1dd4b17 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -595,6 +595,7 @@ export function WebShellSidebar({
     data: channelCatalogData,
     catalog: channelTypeCatalog,
     channels: channelInstances,
+    reload: reloadChannelCatalog,
   } = useChannels({
     autoLoad: channelGroupingEnabled,
     enabled: channelGroupingEnabled,
@@ -1452,7 +1453,13 @@ export function WebShellSidebar({
   );
 
   useEffect(() => {
-    if (!projectExpanded && !hasRunningSession) return;
+    if (
+      !projectExpanded &&
+      !hasRunningSession &&
+      selectedSessionSource !== 'channel'
+    ) {
+      return;
+    }
     const pollInterval =
       (hasRunningSession || selectedSessionSource === 'channel') && !error
         ? ACTIVE_SESSION_POLL_INTERVAL_MS
@@ -1460,16 +1467,22 @@ export function WebShellSidebar({
     const intervalId = window.setInterval(() => {
       if (document.hidden || pollInFlightRef.current) return;
       pollInFlightRef.current = true;
-      void reload().finally(() => {
+      const reloadSessions = reload();
+      const reloadCatalog = channelGroupingEnabled
+        ? reloadChannelCatalog()
+        : Promise.resolve(undefined);
+      void Promise.allSettled([reloadSessions, reloadCatalog]).finally(() => {
         pollInFlightRef.current = false;
       });
     }, pollInterval);
     return () => window.clearInterval(intervalId);
   }, [
     error,
+    channelGroupingEnabled,
     hasRunningSession,
     projectExpanded,
     reload,
+    reloadChannelCatalog,
     selectedSessionSource,
   ]);
 
@@ -1531,7 +1544,9 @@ export function WebShellSidebar({
       for (const sessionIdentity of next) {
         if (
           sessionIdentity === currentSessionIdentity ||
-          runningBySessionId.get(sessionIdentity)
+          (previousRunningBySessionId.has(sessionIdentity) &&
+            (!runningBySessionId.has(sessionIdentity) ||
+              runningBySessionId.get(sessionIdentity)))
         ) {
           next.delete(sessionIdentity);
           changed = true;
@@ -2734,14 +2749,18 @@ export function WebShellSidebar({
   }, [filteredSessions, groups, organizationEnabled, searchQuery, t]);
 
   useEffect(() => {
-    if (!organizationEnabled) return;
+    const activeSections = channelSessionSections ?? sessionSections;
+    if (selectedSessionSource === 'channel') {
+      if (!channelCatalogLoaded || sessionsPage === undefined) return;
+    } else {
+      if (!organizationEnabled) return;
+      if (!groupsCatalogReady || !sessionsCatalogReady) return;
+    }
     // Wait for both independent catalog sources. Flipping the latch on the
     // first non-empty derived sections would treat later initial recent/color
     // ids as brand-new and auto-collapse them; leaving the latch set when the
     // first ready catalog is empty would leave the first real section expanded.
-    if (!groupsCatalogReady || !sessionsCatalogReady) return;
-
-    const unseenIds = sessionSections
+    const unseenIds = activeSections
       .map((section) => section.id)
       .filter((id) => !knownSessionSectionIdsRef.current.has(id));
     const isInitialCatalog = awaitingInitialSessionCatalogRef.current;
@@ -2760,9 +2779,13 @@ export function WebShellSidebar({
     });
   }, [
     groupsCatalogReady,
+    channelCatalogLoaded,
+    channelSessionSections,
     organizationEnabled,
+    selectedSessionSource,
     sessionSections,
     sessionsCatalogReady,
+    sessionsPage,
   ]);
 
   useEffect(() => {
@@ -3503,12 +3526,12 @@ export function WebShellSidebar({
   );
 
   const body = useMemo(() => {
-    if (loading && sessions.length === 0) {
+    if (loading && filteredSessions.length === 0) {
       return (
         <div className={styles.notice}>{t('sidebar.loadingSessions')}</div>
       );
     }
-    if (error && sessions.length === 0) {
+    if (error && filteredSessions.length === 0) {
       return (
         <button className={styles.retry} type="button" onClick={reload}>
           {t('sidebar.loadFailed')}
@@ -3517,7 +3540,8 @@ export function WebShellSidebar({
     }
     if (
       filteredSessions.length === 0 &&
-      (channelSessionSections !== null ||
+      (selectedSessionSource === 'channel' ||
+        channelSessionSections !== null ||
         searchQuery.trim() ||
         !organizationEnabled ||
         sessionSections.length === 0)
@@ -3538,6 +3562,9 @@ export function WebShellSidebar({
         </SessionGroupSection>
       ));
     }
+    if (selectedSessionSource === 'channel') {
+      return filteredSessions.map((session) => renderSessionRow(session));
+    }
     if (!organizationEnabled) {
       return filteredSessions.map((session) => renderSessionRow(session));
     }
@@ -3589,8 +3616,8 @@ export function WebShellSidebar({
     reload,
     renderSessionRow,
     searchQuery,
+    selectedSessionSource,
     sessionSections,
-    sessions.length,
     t,
     toggleSessionSection,
   ]);
@@ -4272,6 +4299,8 @@ export function WebShellSidebar({
                   noSessionsLabel={t('sidebar.noSessions')}
                   loadErrorLabel={t('sidebar.loadFailed')}
                   organizationEnabled={false}
+                  sourceType={selectedSessionSource}
+                  channelGroupingEnabled={channelGroupingEnabled}
                   ungroupedLabel={t('sidebar.groupUngrouped')}
                   formatTime={(iso) => formatRelativeTime(iso, t)}
                   autoExpandKey={
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 078bf32604b..a0936415368 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -87,6 +87,7 @@ const {
       fields: [];
     }>,
     channels: {} as Record<string, unknown>,
+    reload: vi.fn().mockResolvedValue(undefined),
   };
   const useChannels = vi.fn(() => channelState);
   return {
@@ -540,6 +541,7 @@ beforeEach(() => {
   channelState.data = undefined;
   channelState.catalog = [];
   channelState.channels = {};
+  channelState.reload.mockClear();
 });
 
 afterEach(() => {
@@ -3134,6 +3136,12 @@ describe('WebShellSidebar session source switch', () => {
   });
 
   it('polls channel sessions on the active-session interval', async () => {
+    const channelCapabilities = {
+      ...capabilities,
+      features: [...capabilities.features, 'channel_management'],
+    };
+    connection.capabilities = channelCapabilities;
+    workspace.capabilities = channelCapabilities;
     const setIntervalSpy = vi.spyOn(window, 'setInterval');
     renderSidebar();
     await ensureWorkspaceExpanded('project');
@@ -3147,6 +3155,7 @@ describe('WebShellSidebar session source switch', () => {
     );
     expect(activePoll).toBeDefined();
     active.reload.mockClear();
+    channelState.reload.mockClear();
 
     await act(async () => {
       const callback = activePoll![0];
@@ -3156,6 +3165,7 @@ describe('WebShellSidebar session source switch', () => {
     });
 
     expect(active.reload).toHaveBeenCalledOnce();
+    expect(channelState.reload).toHaveBeenCalledOnce();
   });
 
   it('keeps a flat channel list when channel metadata is unavailable', async () => {
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index a9319e2edc5..70668733f49 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -313,6 +313,29 @@ describe('WorkspaceSection label', () => {
     expect(container.textContent).not.toContain('Stale task session');
   });
 
+  it('does not carry a load error across a source switch', async () => {
+    const listWorkspaceSessions = vi.fn((options?: { sourceType?: string }) =>
+      options?.sourceType === 'channel'
+        ? new Promise<DaemonSessionSummary[]>(() => {})
+        : Promise.reject(new Error('tasks unavailable')),
+    );
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessions,
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({ client, expanded: true, sourceType: 'default' });
+    await flush();
+    expect(container.textContent).toContain('Load failed');
+
+    renderSection({ client, expanded: true, sourceType: 'channel' });
+    await flush();
+    expect(container.textContent).not.toContain('Load failed');
+  });
+
   it('groups a secondary workspace with its own channel catalog', async () => {
     const client = {
       workspaceByCwd: vi.fn(() => ({
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index 6ddad907a18..642ffdc2455 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -143,7 +143,7 @@ export function WorkspaceSection({
     catalog: DaemonChannelTypeCatalog;
     snapshot: DaemonChannelsSnapshot;
   }>();
-  const [loadError, setLoadError] = useState(false);
+  const [loadErrorSourceType, setLoadErrorSourceType] = useState<string>();
   const [internalExpanded, setInternalExpanded] = useState(false);
   const [collapsedGroupIds, setCollapsedGroupIds] = useState<Set<string>>(() =>
     readWorkspaceCollapsedGroupIds(workspace.id),
@@ -193,14 +193,14 @@ export function WorkspaceSection({
       if (requestId === sessionLoadRequestId.current) {
         setSessions(result);
         setSessionsSourceType(sourceType ?? '');
-        setLoadError(false);
+        setLoadErrorSourceType(undefined);
       }
     } catch (err) {
       // Surface connectivity failures so users can distinguish a broken
       // daemon from genuinely zero sessions.
       console.warn('[WorkspaceSection] session poll failed:', err);
       if (requestId === sessionLoadRequestId.current) {
-        setLoadError(true);
+        setLoadErrorSourceType(sourceType ?? '');
       }
     }
   }, [client, disabled, organizationEnabled, sourceType, workspace.cwd]);
@@ -362,6 +362,7 @@ export function WorkspaceSection({
       );
     });
   }, [excludePinned, searchQuery, sessions, sessionsSourceType, sourceType]);
+  const loadError = loadErrorSourceType === (sourceType ?? '');
 
   const groupedSessions = useMemo(() => {
     if (!organizationEnabled || groups.length === 0) return null;

From ad7884423bc550811ed3e3288bbb76aab62d0b93 Mon Sep 17 00:00:00 2001
From: "qwen-code-autofix[bot]"
 <qwen-code-autofix[bot]@users.noreply.github.com>
Date: Tue, 11 Aug 2026 08:57:03 +0000
Subject: [PATCH 11/16] fix(channels): harden channel session review round-7
 criticals (#8457)

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
---
 packages/channels/base/src/AcpBridge.test.ts  |  23 ++++
 packages/channels/base/src/AcpBridge.ts       |  17 ++-
 .../channels/base/src/ChannelAgentBridge.ts   |   8 ++
 packages/channels/base/src/index.ts           |   7 +-
 packages/channels/base/src/sanitize.test.ts   |  22 ++++
 packages/channels/base/src/sanitize.ts        |  18 ++++
 .../channels/github/src/GithubAdapter.test.ts |  54 ++++++++++
 packages/channels/github/src/GithubAdapter.ts |   3 +-
 .../cli/src/acp-integration/acpAgent.test.ts  |   7 +-
 packages/cli/src/acp-integration/acpAgent.ts  |  12 +++
 .../channel/channel-registry-builtins.test.ts |  17 +++
 ...private-parent-capability-wire-key.test.ts |  22 ++++
 .../components/sidebar/WebShellSidebar.tsx    |  40 +++++--
 ...WebShellSidebar.workspace-removal.test.tsx | 101 ++++++++++++++++++
 14 files changed, 337 insertions(+), 14 deletions(-)
 create mode 100644 packages/cli/src/commands/channel/private-parent-capability-wire-key.test.ts

diff --git a/packages/channels/base/src/AcpBridge.test.ts b/packages/channels/base/src/AcpBridge.test.ts
index c5ce14c0521..4387a551a84 100644
--- a/packages/channels/base/src/AcpBridge.test.ts
+++ b/packages/channels/base/src/AcpBridge.test.ts
@@ -8,6 +8,8 @@ import {
 } from './AcpBridge.js';
 import { CHANNEL_LOOP_MCP_SERVER_NAME } from './ChannelLoopTools.js';
 import {
+  ACP_PRIVATE_PARENT_CAPABILITY_ENV,
+  ACP_PRIVATE_PARENT_CAPABILITY_META_KEY,
   CHANNEL_PROMPT_META_KEY,
   type ChannelLoopToolHandler,
 } from './ChannelAgentBridge.js';
@@ -168,6 +170,27 @@ describe('AcpBridge', () => {
     }
   });
 
+  it('performs the private-parent capability handshake with the spawned child', async () => {
+    const bridge = new AcpBridge({
+      cliEntryPath: '/tmp/qwen',
+      cwd: '/tmp',
+    });
+
+    await bridge.start();
+
+    const spawnOptions = child.spawn.mock.calls[0]![2] as {
+      env?: Record<string, string | undefined>;
+    };
+    const capability = spawnOptions.env?.[ACP_PRIVATE_PARENT_CAPABILITY_ENV];
+    expect(typeof capability).toBe('string');
+    expect(capability!.length).toBeGreaterThan(0);
+    const initializeParams = child.connections[0]!.initialize.mock
+      .calls[0]![0] as { _meta?: Record<string, unknown> };
+    expect(
+      initializeParams._meta?.[ACP_PRIVATE_PARENT_CAPABILITY_META_KEY],
+    ).toBe(capability);
+  });
+
   it('registers the channel loop MCP server once across concurrent calls', async () => {
     const pending: Array<() => void> = [];
     const extMethod = vi.fn(
diff --git a/packages/channels/base/src/AcpBridge.ts b/packages/channels/base/src/AcpBridge.ts
index ead67346c0f..3eccc018f20 100644
--- a/packages/channels/base/src/AcpBridge.ts
+++ b/packages/channels/base/src/AcpBridge.ts
@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import type { ChildProcess } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
+import { randomBytes, randomUUID } from 'node:crypto';
 import { Readable, Writable } from 'node:stream';
 import { EventEmitter } from 'node:events';
 import {
@@ -15,6 +15,8 @@ import type {
   RequestPermissionResponse,
 } from '@agentclientprotocol/sdk';
 import {
+  ACP_PRIVATE_PARENT_CAPABILITY_ENV,
+  ACP_PRIVATE_PARENT_CAPABILITY_META_KEY,
   CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY,
   CHANNEL_PROMPT_META_KEY,
   type AvailableCommand,
@@ -108,6 +110,10 @@ export class AcpBridge extends EventEmitter implements ChannelAgentBridge {
 
   async start(): Promise<void> {
     const { cliEntryPath, cwd } = this.options;
+    // Private-parent capability: marks this bridge as a trusted ACP parent of
+    // the spawned child so trusted prompt metadata (e.g. the classifier's
+    // display projection) survives the child's untrusted-caller strip.
+    const privateParentCapability = randomBytes(32).toString('base64url');
 
     const args = [
       ...process.execArgv.filter((a) => !/^--inspect(-brk)?($|=)/.test(a)),
@@ -121,7 +127,11 @@ export class AcpBridge extends EventEmitter implements ChannelAgentBridge {
     this.child = spawn(process.execPath, args, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, QWEN_CODE_DISABLE_CRON: '1' },
+      env: {
+        ...process.env,
+        QWEN_CODE_DISABLE_CRON: '1',
+        [ACP_PRIVATE_PARENT_CAPABILITY_ENV]: privateParentCapability,
+      },
       shell: false,
     });
 
@@ -187,6 +197,9 @@ export class AcpBridge extends EventEmitter implements ChannelAgentBridge {
         this.connection.initialize({
           protocolVersion: PROTOCOL_VERSION,
           clientCapabilities: {},
+          _meta: {
+            [ACP_PRIVATE_PARENT_CAPABILITY_META_KEY]: privateParentCapability,
+          },
         }),
         ACP_START_TIMEOUT_MS,
         `ACP initialization timed out after ${ACP_START_TIMEOUT_MS}ms`,
diff --git a/packages/channels/base/src/ChannelAgentBridge.ts b/packages/channels/base/src/ChannelAgentBridge.ts
index 1641ddcca35..dfa33635cd4 100644
--- a/packages/channels/base/src/ChannelAgentBridge.ts
+++ b/packages/channels/base/src/ChannelAgentBridge.ts
@@ -9,6 +9,14 @@ export const CHANNEL_PROMPT_AUTHORIZATION_META_KEY =
   'qwen.daemon.channelPromptAuthorization';
 // Client-supplied routing hint only; never use it as an authorization boundary.
 export const CHANNEL_PROMPT_META_KEY = 'qwen.channel.prompt';
+// Private-parent capability handshake with the spawned `qwen --acp` child
+// (packages/core/src/utils/invocation-context.ts owns the same constants).
+// channel-base keeps a minimal dependency footprint, so the wire contract is
+// pinned by value in a cross-package test instead of imported.
+export const ACP_PRIVATE_PARENT_CAPABILITY_META_KEY =
+  'qwen-code/private-parent-capability';
+export const ACP_PRIVATE_PARENT_CAPABILITY_ENV =
+  'QWEN_CODE_PRIVATE_ACP_CAPABILITY';
 
 export interface AvailableCommand {
   name: string;
diff --git a/packages/channels/base/src/index.ts b/packages/channels/base/src/index.ts
index 636f9a7b03c..8bdf47f9bd5 100644
--- a/packages/channels/base/src/index.ts
+++ b/packages/channels/base/src/index.ts
@@ -5,7 +5,11 @@ export {
 } from './paths.js';
 export { PollingChannelBase } from './PollingChannelBase.js';
 export { ACP_EVENT_LOOP_STALL_RESTART_MS, AcpBridge } from './AcpBridge.js';
-export { CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY } from './ChannelAgentBridge.js';
+export {
+  ACP_PRIVATE_PARENT_CAPABILITY_ENV,
+  ACP_PRIVATE_PARENT_CAPABILITY_META_KEY,
+  CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY,
+} from './ChannelAgentBridge.js';
 export type {
   AvailableCommand,
   BridgeSessionInfo,
@@ -89,6 +93,7 @@ export { SessionRouter } from './SessionRouter.js';
 export {
   sanitizeSenderName,
   sanitizePromptText,
+  sanitizeDisplayText,
   sanitizeLogText,
   truncateCodePoints,
 } from './sanitize.js';
diff --git a/packages/channels/base/src/sanitize.test.ts b/packages/channels/base/src/sanitize.test.ts
index bbd35ed2277..d230f98ec68 100644
--- a/packages/channels/base/src/sanitize.test.ts
+++ b/packages/channels/base/src/sanitize.test.ts
@@ -2,6 +2,7 @@ import { describe, it, expect } from 'vitest';
 import {
   sanitizeSenderName,
   sanitizePromptText,
+  sanitizeDisplayText,
   sanitizeQuotedText,
   sanitizePromptPath,
   sanitizeLogText,
@@ -295,3 +296,24 @@ describe('sanitizeLogText', () => {
     expect(isHighSurrogate(out.charCodeAt(out.length - 1))).toBe(false);
   });
 });
+
+describe('sanitizeDisplayText', () => {
+  it('neutralizes bidi, zero-width, and C0 controls but keeps newlines', () => {
+    const out = sanitizeDisplayText(
+      `a${RLO}b${ZWSP}c${NEL}d\u0007e\rf\ng[h]`,
+      100,
+    );
+    expect(out).toBe('a b c d e f\ng[h]');
+  });
+
+  it('keeps brackets and multi-line structure that sanitizePromptText folds', () => {
+    const out = sanitizeDisplayText('[BUG] title:\n- one\n- two', 100);
+    expect(out).toBe('[BUG] title:\n- one\n- two');
+  });
+
+  it('caps to maxLen code points without splitting a surrogate pair', () => {
+    const out = sanitizeDisplayText('a'.repeat(399) + EMOJI + 'tail', 400);
+    expect(out).toBe('a'.repeat(399) + EMOJI);
+    expect(isHighSurrogate(out.charCodeAt(out.length - 1))).toBe(false);
+  });
+});
diff --git a/packages/channels/base/src/sanitize.ts b/packages/channels/base/src/sanitize.ts
index 3bd82b780c7..c8512b544e7 100644
--- a/packages/channels/base/src/sanitize.ts
+++ b/packages/channels/base/src/sanitize.ts
@@ -80,6 +80,24 @@ export function sanitizePromptText(text: string): string {
   );
 }
 
+/**
+ * Neutralize attacker-controlled text that is surfaced VERBATIM to users
+ * (session-bus display projections, transcripts, session-list previews):
+ * strip the Unicode line/bidi/zero-width controls that can reorder or hide
+ * rendered text, plus C0/DEL controls EXCEPT newline — multi-line user text
+ * keeps its line structure in the transcript. Capped by CODE POINT so a cap
+ * landing mid-surrogate-pair cannot leave a lone surrogate. Unlike
+ * sanitizePromptText it preserves newlines and brackets: display text is
+ * rendered to a human, not parsed as prompt structure.
+ */
+export function sanitizeDisplayText(text: string, maxLen: number): string {
+  const cleaned = text
+    .replace(PROMPT_UNSAFE_INVISIBLES, ' ')
+    // eslint-disable-next-line no-control-regex
+    .replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, ' ');
+  return truncateCodePoints(cleaned, maxLen);
+}
+
 /**
  * Neutralize an attacker-influenced filesystem path before rendering it on
  * its own line in a prompt (`... saved to: <path>`). Unlike
diff --git a/packages/channels/github/src/GithubAdapter.test.ts b/packages/channels/github/src/GithubAdapter.test.ts
index 3f8e41ac9ee..2033daeec93 100644
--- a/packages/channels/github/src/GithubAdapter.test.ts
+++ b/packages/channels/github/src/GithubAdapter.test.ts
@@ -2056,6 +2056,60 @@ describe('GithubChannel', () => {
       expect(channel.inboundEnvelopes[0]!.text).toContain('latest');
     });
 
+    it('sanitizes crafted comment bodies in the aggregate display projection', async () => {
+      await initWithoutLoop();
+      mockOctokit.paginate
+        .mockResolvedValueOnce([
+          makeNotification({
+            reason: 'comment',
+            last_read_at: '2026-07-01T12:00:00.000Z',
+          }),
+        ])
+        .mockResolvedValueOnce([
+          makeComment({
+            body: 'line one\u202e hidden\u200b\u0007\r\nline two [BUG] kept',
+          }),
+        ]);
+
+      await pollOnce();
+
+      const displayText = channel.inboundEnvelopes[0]!.displayText!;
+      // eslint-disable-next-line no-control-regex
+      const craftedChars = /[\u202a-\u202e\u2066-\u2069\u200b\u0007\r]/;
+      expect(displayText).not.toMatch(craftedChars);
+      // Newlines and brackets are display content and must survive.
+      expect(displayText).toContain('line one');
+      expect(displayText).toContain('\nline two [BUG] kept');
+      expect(channel.inboundEnvelopes[0]!.text).toContain(
+        displayText.slice('- @alice: '.length),
+      );
+    });
+
+    it('truncates aggregated comments on code-point boundaries', async () => {
+      await initWithoutLoop();
+      mockOctokit.paginate
+        .mockResolvedValueOnce([
+          makeNotification({
+            reason: 'comment',
+            last_read_at: '2026-07-01T12:00:00.000Z',
+          }),
+        ])
+        .mockResolvedValueOnce([
+          // 399 ASCII + one 2-unit emoji + tail: a UTF-16 slice(0, 400) would
+          // land mid-surrogate-pair and leave a lone surrogate behind.
+          makeComment({ body: 'a'.repeat(399) + '\ud83c\udf89' + 'tail' }),
+        ]);
+
+      await pollOnce();
+
+      const displayText = channel.inboundEnvelopes[0]!.displayText!;
+      expect(displayText).toContain('a'.repeat(399) + '\ud83c\udf89');
+      expect(displayText).not.toContain('tail');
+      expect(displayText).not.toMatch(
+        /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/,
+      );
+    });
+
     it('records aggregated comments that exceed the summary cap', async () => {
       await initWithoutLoop();
       const comments = Array.from({ length: 25 }, (_, index) =>
diff --git a/packages/channels/github/src/GithubAdapter.ts b/packages/channels/github/src/GithubAdapter.ts
index 46d1973b238..f9a9c817c4a 100644
--- a/packages/channels/github/src/GithubAdapter.ts
+++ b/packages/channels/github/src/GithubAdapter.ts
@@ -25,6 +25,7 @@ import {
   getGlobalQwenDir,
   getWorkspaceScopeDirName,
   PollingChannelBase,
+  sanitizeDisplayText,
   sanitizeLogText,
   sanitizePromptText,
   truncateCodePoints,
@@ -1446,7 +1447,7 @@ export class GithubChannel extends PollingChannelBase<GithubCursor> {
     const summary = comments
       .map(
         (comment) =>
-          `- @${comment.user?.login || 'unknown'}: ${(comment.body || '').trim().slice(0, MAX_AGGREGATE_COMMENT_CHARS)}`,
+          `- @${comment.user?.login || 'unknown'}: ${sanitizeDisplayText((comment.body || '').trim(), MAX_AGGREGATE_COMMENT_CHARS)}`,
       )
       .join('\n');
     const envelope: Envelope = {
diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts
index 7d41d9da52c..5fed87d8830 100644
--- a/packages/cli/src/acp-integration/acpAgent.test.ts
+++ b/packages/cli/src/acp-integration/acpAgent.test.ts
@@ -2099,6 +2099,7 @@ describe('QwenAgent MCP SSE/HTTP support', () => {
         'qwen-code/invocation': invocation,
         'qwen-code/private-parent-capability': 'must-not-propagate',
         'qwen.daemon.modelPrompt': 'trusted model-only prompt',
+        'qwen.daemon.promptDisplayText': 'trusted display text',
       },
     });
 
@@ -2106,7 +2107,10 @@ describe('QwenAgent MCP SSE/HTTP support', () => {
       {
         sessionId: 'trusted-session',
         prompt: [{ type: 'text', text: 'hello' }],
-        _meta: { keep: true },
+        _meta: {
+          keep: true,
+          'qwen.daemon.promptDisplayText': 'trusted display text',
+        },
       },
       invocation,
       expect.any(AbortSignal),
@@ -2461,6 +2465,7 @@ describe('QwenAgent MCP SSE/HTTP support', () => {
         },
         'qwen-code/private-parent-capability': 'forged-capability',
         'qwen.daemon.modelPrompt': 'forged model-only prompt',
+        'qwen.daemon.promptDisplayText': 'forged display text',
       },
     });
 
diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts
index f11d8f9341d..277a5bdbcf7 100644
--- a/packages/cli/src/acp-integration/acpAgent.ts
+++ b/packages/cli/src/acp-integration/acpAgent.ts
@@ -327,6 +327,7 @@ import {
   CHANNEL_STARTUP_PROFILE_VERSION,
   CLIENT_MCP_OVER_WS_CONFIG_FLAG,
   DAEMON_MODEL_PROMPT_META_KEY,
+  DAEMON_PROMPT_DISPLAY_TEXT_META_KEY,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_HIDE_INHERITED_META_KEY,
   LOAD_REPLAY_META_KEY,
@@ -5451,9 +5452,20 @@ class QwenAgent implements Agent {
         : {};
     const suppliedContext = meta[INVOCATION_CONTEXT_META_KEY];
     const suppliedModelPrompt = meta[DAEMON_MODEL_PROMPT_META_KEY];
+    const suppliedPromptDisplayText = meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
     delete meta[INVOCATION_CONTEXT_META_KEY];
     delete meta[DAEMON_MODEL_PROMPT_META_KEY];
     delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
+    delete meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY];
+    // The user-facing display projection is caller-controlled metadata; honor
+    // it only for trusted parents (the daemon bridge re-injects the trusted
+    // channel-worker value here). A plain delete would drop that re-injection.
+    if (
+      this.privateParentState === 'trusted' &&
+      typeof suppliedPromptDisplayText === 'string'
+    ) {
+      meta[DAEMON_PROMPT_DISPLAY_TEXT_META_KEY] = suppliedPromptDisplayText;
+    }
     if (Object.keys(meta).length > 0) {
       sanitizedParams._meta = meta;
     } else {
diff --git a/packages/cli/src/commands/channel/channel-registry-builtins.test.ts b/packages/cli/src/commands/channel/channel-registry-builtins.test.ts
index 4417c960287..4a1678fc951 100644
--- a/packages/cli/src/commands/channel/channel-registry-builtins.test.ts
+++ b/packages/cli/src/commands/channel/channel-registry-builtins.test.ts
@@ -119,6 +119,23 @@ describe('built-in channel registry', () => {
           kind: 'object',
           properties: [{ key: 'type', label: 'Type', kind: 'string' }],
         },
+        // supportedChannelCatalog() injects the session-scope descriptor into
+        // every manageable entry that does not declare its own.
+        {
+          key: 'sessionScope',
+          label: 'Session scope',
+          kind: 'enum',
+          required: true,
+          default: 'user',
+          description:
+            'Controls which incoming conversations share one agent session.',
+          options: [
+            { value: 'user', label: 'Per user and chat' },
+            { value: 'thread', label: 'Per thread' },
+            { value: 'chat_thread', label: 'Per chat and thread' },
+            { value: 'single', label: 'One shared session' },
+          ],
+        },
       ],
     });
   });
diff --git a/packages/cli/src/commands/channel/private-parent-capability-wire-key.test.ts b/packages/cli/src/commands/channel/private-parent-capability-wire-key.test.ts
new file mode 100644
index 00000000000..395a37e610e
--- /dev/null
+++ b/packages/cli/src/commands/channel/private-parent-capability-wire-key.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import {
+  ACP_PRIVATE_PARENT_CAPABILITY_ENV,
+  ACP_PRIVATE_PARENT_CAPABILITY_META_KEY,
+} from '@qwen-code/channel-base';
+import {
+  PRIVATE_ACP_CAPABILITY_ENV,
+  PRIVATE_PARENT_CAPABILITY_META_KEY,
+} from '@qwen-code/qwen-code-core';
+
+// The standalone channel bridge performs the private-parent capability
+// handshake under the channel-base constants and the ACP child validates it
+// under the core constants; the packages have no dependency path between
+// them, so pin the wire contract here where both packages are importable.
+describe('private parent capability wire keys', () => {
+  it('are identical across channel-base and core', () => {
+    expect(ACP_PRIVATE_PARENT_CAPABILITY_META_KEY).toBe(
+      PRIVATE_PARENT_CAPABILITY_META_KEY,
+    );
+    expect(ACP_PRIVATE_PARENT_CAPABILITY_ENV).toBe(PRIVATE_ACP_CAPABILITY_ENV);
+  });
+});
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 52bc1dd4b17..1f1e262cfeb 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -656,6 +656,19 @@ export function WebShellSidebar({
     !organizationEnabled ||
     !includePrimaryWorkspaceSessions ||
     sessionsPage !== undefined;
+  // Which source the settled sessions page belongs to. The resource retains
+  // the previous source's page while a source-switch refetch is in flight, so
+  // section reconciliation must not run against a stale page of the other
+  // source (its sections would be consumed as the wrong source's initial
+  // catalog). A page identity change marks a successful fetch settling.
+  const lastSettledSessionsPageRef = useRef(sessionsPage);
+  const settledSessionsSourceRef = useRef<SidebarSessionSource>(sessionSource);
+  useEffect(() => {
+    if (lastSettledSessionsPageRef.current !== sessionsPage) {
+      lastSettledSessionsPageRef.current = sessionsPage;
+      settledSessionsSourceRef.current = sessionSource;
+    }
+  }, [sessionsPage, sessionSource]);
   const loadPinnedSessions =
     organizationEnabled && selectedSessionSource !== 'channel';
   const { sessions: primaryPinnedSessions, reload: reloadPinnedSessions } =
@@ -744,11 +757,16 @@ export function WebShellSidebar({
       ),
   );
   const knownSessionSectionIdsRef = useRef<Set<string>>(new Set());
-  // Dedicated first-sync latch. Cleared only after both groups catalog and
-  // sessions list have settled (including empty responses). Do not infer this
-  // from knownSessionSectionIdsRef.size — seeding that set early would make the
-  // first real sync look mid-session and auto-collapse restored expansions.
-  const awaitingInitialSessionCatalogRef = useRef(true);
+  // Dedicated first-sync latch, keyed by session source: each source's first
+  // settled catalog only registers section ids. Without per-source latches the
+  // Tasks settle consumes the shared latch and the first Channels visit treats
+  // every platform section as brand-new, auto-collapsing and persisting them.
+  // Do not infer this from knownSessionSectionIdsRef.size — seeding that set
+  // early would make the first real sync look mid-session and auto-collapse
+  // restored expansions.
+  const awaitingInitialSessionCatalogBySourceRef = useRef<
+    Record<SidebarSessionSource, boolean>
+  >({ default: true, channel: true });
   const [groupsCatalogReady, setGroupsCatalogReady] =
     useState(!organizationEnabled);
   // organizationEnabled can flip true mid-session (capabilities can land after
@@ -2751,7 +2769,10 @@ export function WebShellSidebar({
   useEffect(() => {
     const activeSections = channelSessionSections ?? sessionSections;
     if (selectedSessionSource === 'channel') {
-      if (!channelCatalogLoaded || sessionsPage === undefined) return;
+      if (!channelCatalogLoaded) return;
+      // The refetch for the new source retains the previous source's page
+      // until it settles; wait for a page fetched for the channel source.
+      if (settledSessionsSourceRef.current !== 'channel') return;
     } else {
       if (!organizationEnabled) return;
       if (!groupsCatalogReady || !sessionsCatalogReady) return;
@@ -2763,9 +2784,10 @@ export function WebShellSidebar({
     const unseenIds = activeSections
       .map((section) => section.id)
       .filter((id) => !knownSessionSectionIdsRef.current.has(id));
-    const isInitialCatalog = awaitingInitialSessionCatalogRef.current;
+    const isInitialCatalog =
+      awaitingInitialSessionCatalogBySourceRef.current[sessionSource];
     if (isInitialCatalog) {
-      awaitingInitialSessionCatalogRef.current = false;
+      awaitingInitialSessionCatalogBySourceRef.current[sessionSource] = false;
       for (const id of unseenIds) knownSessionSectionIdsRef.current.add(id);
       return;
     }
@@ -2784,8 +2806,8 @@ export function WebShellSidebar({
     organizationEnabled,
     selectedSessionSource,
     sessionSections,
+    sessionSource,
     sessionsCatalogReady,
-    sessionsPage,
   ]);
 
   useEffect(() => {
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index a0936415368..65a5f7bd77c 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -156,6 +156,9 @@ vi.mock('@qwen-code/webui/daemon-react-sdk', () => ({
 
 const { I18nProvider } = await import('../../i18n');
 const { WebShellSidebar } = await import('./WebShellSidebar');
+const { COLLAPSED_SESSION_SECTIONS_STORAGE_KEY } = await import(
+  './collapsedSessionSections'
+);
 
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
 if (!globalThis.PointerEvent) {
@@ -3301,6 +3304,104 @@ describe('WebShellSidebar session source switch', () => {
     expect(toggle?.getAttribute('aria-expanded')).toBe('true');
     expect(dingTalkGroup?.textContent).toContain('DingTalk one');
   });
+
+  it('starts channel sections expanded on the first Channels visit with organization enabled', async () => {
+    const channelCapabilities = {
+      ...capabilities,
+      features: [
+        ...capabilities.features,
+        'channel_management',
+        'session_organization',
+      ],
+    };
+    connection.capabilities = channelCapabilities;
+    workspace.capabilities = channelCapabilities;
+    workspaceActions.listSessionGroups.mockResolvedValue({
+      groups: [],
+      colorOptions: [],
+    });
+    channelState.catalog = [
+      {
+        type: 'dingtalk',
+        displayName: 'DingTalk',
+        manageable: true,
+        fields: [],
+      },
+    ];
+    channelState.channels = {
+      'ding-one': {
+        name: 'ding-one',
+        config: { type: 'dingtalk' },
+        secrets: {},
+        startsWithServe: false,
+        runtime: { state: 'connected' },
+      },
+    };
+    channelState.data = {
+      catalog: channelState.catalog,
+      snapshot: { revision: '1', instances: channelState.channels },
+    };
+    const taskSessions: DaemonSessionSummary[] = [
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+      },
+    ];
+    const channelSessions: DaemonSessionSummary[] = [
+      {
+        sessionId: 'ding-one-session',
+        displayName: 'DingTalk one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'ding-one',
+      },
+    ];
+    // Serve a distinct settled page per source (distinct identities), as the
+    // real resource does when the source-switch refetch resolves.
+    useSessions.mockImplementation(
+      (options?: { archiveState?: string; sourceType?: string }) => {
+        if (options?.archiveState === 'archived') {
+          return { ...archived, data: archived.sessions };
+        }
+        if (options?.sourceType === 'channel') {
+          return {
+            ...active,
+            sessions: channelSessions,
+            data: channelSessions,
+          };
+        }
+        return { ...active, sessions: taskSessions, data: taskSessions };
+      },
+    );
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    // Settle the groups catalog so the Tasks source consumes its own
+    // first-sync latch before the Channels visit.
+    await act(async () => {
+      await workspaceActions.listSessionGroups.mock.results.at(-1)?.value;
+      await Promise.resolve();
+    });
+    expect(container.textContent).toContain('Task session');
+
+    await switchSessionSource('Channels');
+
+    const dingTalkGroup = container.querySelector<HTMLElement>(
+      'section[aria-label="DingTalk"]',
+    );
+    expect(dingTalkGroup).not.toBeNull();
+    expect(dingTalkGroup!.textContent).toContain('DingTalk one');
+    // The first Channels visit consumes the channel-source latch without
+    // treating the platform sections as brand-new mid-session additions.
+    expect(
+      dingTalkGroup!.querySelector('button[aria-expanded="true"]'),
+    ).not.toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('channel-type:');
+  });
 });
 
 describe('WebShellSidebar Live group', () => {

From 7745971a7330b9c115244031edad2b53919046af Mon Sep 17 00:00:00 2001
From: "qwen-code-autofix[bot]"
 <qwen-code-autofix[bot]@users.noreply.github.com>
Date: Tue, 11 Aug 2026 15:32:48 +0000
Subject: [PATCH 12/16] fix(web-shell): harden first-visit session section
 latches (#8457)

---
 .../components/sidebar/WebShellSidebar.tsx    |  32 +-
 ...WebShellSidebar.workspace-removal.test.tsx | 362 +++++++++++++++++-
 2 files changed, 381 insertions(+), 13 deletions(-)

diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 98f139ae820..09826b0041c 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -670,14 +670,16 @@ export function WebShellSidebar({
     !organizationEnabled ||
     !includePrimaryWorkspaceSessions ||
     sessionsPage !== undefined;
-  // Which source the settled sessions page belongs to. The resource retains
-  // the previous source's page while a source-switch refetch is in flight, so
-  // section reconciliation must not run against a stale page of the other
-  // source (its sections would be consumed as the wrong source's initial
-  // catalog). A page identity change marks a successful fetch settling.
+  // Which source the settled sessions page belongs to. Switching the source
+  // changes the catalog query key, whose entry starts without a page
+  // (undefined), so reconciliation must not run until a page fetched for the
+  // new source settles — otherwise the other source's sections would be
+  // consumed as the new source's initial catalog.
   const lastSettledSessionsPageRef = useRef(sessionsPage);
   const settledSessionsSourceRef = useRef<SidebarSessionSource>(sessionSource);
   useEffect(() => {
+    // An undefined page is the empty pre-settle snapshot, not a settled fetch.
+    if (sessionsPage === undefined) return;
     if (lastSettledSessionsPageRef.current !== sessionsPage) {
       lastSettledSessionsPageRef.current = sessionsPage;
       settledSessionsSourceRef.current = sessionSource;
@@ -2789,16 +2791,19 @@ export function WebShellSidebar({
       if (!organizationEnabled) return;
       if (!groupsCatalogReady || !sessionsCatalogReady) return;
     }
-    // Wait for both independent catalog sources. Flipping the latch on the
-    // first non-empty derived sections would treat later initial recent/color
-    // ids as brand-new and auto-collapse them; leaving the latch set when the
-    // first ready catalog is empty would leave the first real section expanded.
     const unseenIds = activeSections
       .map((section) => section.id)
       .filter((id) => !knownSessionSectionIdsRef.current.has(id));
     const isInitialCatalog =
       awaitingInitialSessionCatalogBySourceRef.current[sessionSource];
     if (isInitialCatalog) {
+      // First-sync registration must reflect the full unfiltered catalog:
+      // sections hidden by an active search would never register and would
+      // later auto-collapse as mid-session additions. An empty first catalog
+      // keeps the latch so the first real sections still register as initial
+      // — channel sessions are externally driven and can arrive while the
+      // tab is open on an empty settle.
+      if (searchQuery.trim() || activeSections.length === 0) return;
       awaitingInitialSessionCatalogBySourceRef.current[sessionSource] = false;
       for (const id of unseenIds) knownSessionSectionIdsRef.current.add(id);
       return;
@@ -2816,6 +2821,7 @@ export function WebShellSidebar({
     channelCatalogLoaded,
     channelSessionSections,
     organizationEnabled,
+    searchQuery,
     selectedSessionSource,
     sessionSections,
     sessionSource,
@@ -3560,12 +3566,15 @@ export function WebShellSidebar({
   );
 
   const body = useMemo(() => {
-    if (loading && filteredSessions.length === 0) {
+    // Gate notices on the resource, not the filtered view: background
+    // refreshes set loading/error while retaining the settled page, so a
+    // filter-empty or empty-but-settled view must not flash or swap to retry.
+    if (loading && sessionsPage === undefined) {
       return (
         <div className={styles.notice}>{t('sidebar.loadingSessions')}</div>
       );
     }
-    if (error && filteredSessions.length === 0) {
+    if (error && sessionsPage === undefined) {
       return (
         <button className={styles.retry} type="button" onClick={reload}>
           {t('sidebar.loadFailed')}
@@ -3652,6 +3661,7 @@ export function WebShellSidebar({
     searchQuery,
     selectedSessionSource,
     sessionSections,
+    sessionsPage,
     t,
     toggleSessionSection,
   ]);
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index fec81de7551..9c7b01a2e78 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -35,7 +35,7 @@ const {
   const makeSessions = () => ({
     sessions: [] as DaemonSessionSummary[],
     loading: false,
-    error: null,
+    error: null as Error | null,
     reload: vi.fn().mockResolvedValue(undefined),
     deleteSession: vi.fn().mockResolvedValue(true),
     archiveSession: vi.fn().mockResolvedValue(true),
@@ -184,9 +184,15 @@ vi.mock('../../session-catalog/session-catalog-hooks', () => {
       if (options?.enabled === false) {
         return { ...state, sessions: [], data: undefined, catalogQuery };
       }
+      // A useSessions implementation may model an unsettled catalog page with
+      // an explicit `data` key (undefined until the fetch settles), matching
+      // the real store's empty snapshot on a query-key change.
       return {
         ...state,
-        data: state.sessions,
+        data:
+          'data' in state
+            ? (state as { data?: DaemonSessionSummary[] }).data
+            : state.sessions,
         catalogQuery,
       };
     },
@@ -512,6 +518,81 @@ async function switchSessionSource(
   return tab!;
 }
 
+function enableChannelOrganization(): void {
+  const channelCapabilities = {
+    ...capabilities,
+    features: [
+      ...capabilities.features,
+      'channel_management',
+      'session_organization',
+    ],
+  };
+  connection.capabilities = channelCapabilities;
+  workspace.capabilities = channelCapabilities;
+  workspaceActions.listSessionGroups.mockResolvedValue({
+    groups: [],
+    colorOptions: [],
+  });
+}
+
+function setChannelCatalog(): void {
+  channelState.catalog = [
+    {
+      type: 'dingtalk',
+      displayName: 'DingTalk',
+      manageable: true,
+      fields: [],
+    },
+    {
+      type: 'feishu',
+      displayName: 'Feishu',
+      manageable: true,
+      fields: [],
+    },
+  ];
+  channelState.channels = {
+    'ding-one': {
+      name: 'ding-one',
+      config: { type: 'dingtalk' },
+      secrets: {},
+      startsWithServe: false,
+      runtime: { state: 'connected' },
+    },
+    'feishu-one': {
+      name: 'feishu-one',
+      config: { type: 'feishu' },
+      secrets: {},
+      startsWithServe: false,
+      runtime: { state: 'connected' },
+    },
+  };
+  channelState.data = {
+    catalog: channelState.catalog,
+    snapshot: { revision: '1', instances: channelState.channels },
+  };
+}
+
+async function settleGroupsCatalog(): Promise<void> {
+  await act(async () => {
+    await workspaceActions.listSessionGroups.mock.results.at(-1)?.value;
+    await Promise.resolve();
+  });
+}
+
+async function openSessionSearch(): Promise<HTMLInputElement> {
+  const searchButton = Array.from(
+    container.querySelectorAll<HTMLButtonElement>('button'),
+  ).find((button) => button.getAttribute('aria-label') === 'Search sessions');
+  expect(searchButton).toBeDefined();
+  await act(async () => {
+    click(searchButton!);
+    await Promise.resolve();
+  });
+  const input = container.querySelector<HTMLInputElement>('input');
+  expect(input).not.toBeNull();
+  return input!;
+}
+
 function sessionAction(label: string): HTMLButtonElement | undefined {
   return Array.from(
     container.querySelectorAll<HTMLButtonElement>(
@@ -615,6 +696,7 @@ function dialogButton(label: string): HTMLButtonElement {
 }
 
 beforeEach(() => {
+  window.localStorage.clear();
   container = document.createElement('div');
   document.body.appendChild(container);
   root = createRoot(container);
@@ -688,6 +770,8 @@ beforeEach(() => {
   );
   useChannels.mockClear();
   active.sessions.length = 0;
+  active.loading = false;
+  active.error = null;
   archived.sessions.length = 0;
   channelState.data = undefined;
   channelState.catalog = [];
@@ -3583,6 +3667,280 @@ describe('WebShellSidebar session source switch', () => {
       window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
     ).not.toContain('channel-type:');
   });
+
+  it('keeps channel sections expanded when the catalog settles before the sessions page', async () => {
+    enableChannelOrganization();
+    setChannelCatalog();
+    const taskSessions: DaemonSessionSummary[] = [
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+      },
+    ];
+    let channelPage: DaemonSessionSummary[] | undefined = undefined;
+    useSessions.mockImplementation(
+      (options?: { archiveState?: string; sourceType?: string }) => {
+        if (options?.archiveState === 'archived') {
+          return { ...archived, data: archived.sessions };
+        }
+        if (options?.sourceType === 'channel') {
+          // The new source's catalog entry starts unsettled: no page until
+          // its fetch resolves, while the channel catalog is already loaded.
+          return {
+            ...active,
+            sessions: channelPage ?? [],
+            data: channelPage,
+          };
+        }
+        return { ...active, sessions: taskSessions, data: taskSessions };
+      },
+    );
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    await settleGroupsCatalog();
+    await switchSessionSource('Channels');
+
+    // The channel catalog settled before the channel sessions page; no
+    // section may be registered or persisted yet.
+    expect(
+      container.querySelector('section[aria-label="DingTalk"]'),
+    ).toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('channel-type:');
+
+    channelPage = [
+      {
+        sessionId: 'ding-one-session',
+        displayName: 'DingTalk one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'ding-one',
+      },
+    ];
+    renderSidebar();
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    const dingTalkGroup = container.querySelector<HTMLElement>(
+      'section[aria-label="DingTalk"]',
+    );
+    expect(dingTalkGroup).not.toBeNull();
+    expect(dingTalkGroup!.textContent).toContain('DingTalk one');
+    expect(
+      dingTalkGroup!.querySelector('button[aria-expanded="true"]'),
+    ).not.toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('channel-type:');
+  });
+
+  it('starts the first channel section expanded when it arrives after an empty settle', async () => {
+    enableChannelOrganization();
+    setChannelCatalog();
+    const taskSessions: DaemonSessionSummary[] = [
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+      },
+    ];
+    let channelSessions: DaemonSessionSummary[] = [];
+    useSessions.mockImplementation(
+      (options?: { archiveState?: string; sourceType?: string }) => {
+        if (options?.archiveState === 'archived') {
+          return { ...archived, data: archived.sessions };
+        }
+        if (options?.sourceType === 'channel') {
+          return {
+            ...active,
+            sessions: channelSessions,
+            data: channelSessions,
+          };
+        }
+        return { ...active, sessions: taskSessions, data: taskSessions };
+      },
+    );
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    await settleGroupsCatalog();
+    await switchSessionSource('Channels');
+
+    // The first Channels visit settles a defined empty catalog; the latch
+    // must stay set because channel sessions are externally driven.
+    expect(
+      container.querySelector('section[aria-label="DingTalk"]'),
+    ).toBeNull();
+
+    // The first incoming message creates the first channel session while the
+    // tab is open (the 2s poll picks it up).
+    channelSessions = [
+      {
+        sessionId: 'ding-one-session',
+        displayName: 'DingTalk one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'ding-one',
+      },
+    ];
+    renderSidebar();
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    const dingTalkGroup = container.querySelector<HTMLElement>(
+      'section[aria-label="DingTalk"]',
+    );
+    expect(dingTalkGroup).not.toBeNull();
+    expect(
+      dingTalkGroup!.querySelector('button[aria-expanded="true"]'),
+    ).not.toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('channel-type:');
+  });
+
+  it('does not register the first channel catalog against a search filter', async () => {
+    enableChannelOrganization();
+    setChannelCatalog();
+    const taskSessions: DaemonSessionSummary[] = [
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+      },
+    ];
+    const channelSessions: DaemonSessionSummary[] = [
+      {
+        sessionId: 'ding-one-session',
+        displayName: 'DingTalk one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'ding-one',
+      },
+      {
+        sessionId: 'feishu-one-session',
+        displayName: 'Feishu one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'feishu-one',
+      },
+    ];
+    useSessions.mockImplementation(
+      (options?: { archiveState?: string; sourceType?: string }) => {
+        if (options?.archiveState === 'archived') {
+          return { ...archived, data: archived.sessions };
+        }
+        if (options?.sourceType === 'channel') {
+          return {
+            ...active,
+            sessions: channelSessions,
+            data: channelSessions,
+          };
+        }
+        return { ...active, sessions: taskSessions, data: taskSessions };
+      },
+    );
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    await settleGroupsCatalog();
+    expect(container.textContent).toContain('Task session');
+
+    const searchInput = await openSessionSearch();
+    await act(async () => {
+      setInputValue(searchInput, 'ding');
+      await Promise.resolve();
+    });
+    await switchSessionSource('Channels');
+
+    // Only the DingTalk section matches the search; the first-catalog latch
+    // must wait for an unfiltered settle instead of registering only it.
+    await act(async () => {
+      setInputValue(searchInput, '');
+      await Promise.resolve();
+    });
+
+    const feishuGroup = container.querySelector<HTMLElement>(
+      'section[aria-label="Feishu"]',
+    );
+    expect(feishuGroup).not.toBeNull();
+    expect(
+      feishuGroup!.querySelector('button[aria-expanded="true"]'),
+    ).not.toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('channel-type:');
+  });
+});
+
+describe('WebShellSidebar session list notices', () => {
+  it('keeps a settled filtered-empty view while a refresh is in flight', async () => {
+    active.sessions = [
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+      },
+    ];
+    active.loading = true;
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    const searchInput = await openSessionSearch();
+    await act(async () => {
+      setInputValue(searchInput, 'no-match');
+      await Promise.resolve();
+    });
+
+    expect(container.textContent).toContain('No matching sessions.');
+    expect(container.textContent).not.toContain('Loading sessions...');
+  });
+
+  it('keeps a settled filtered-empty view when a refresh failed', async () => {
+    active.sessions = [
+      {
+        sessionId: 'task-session',
+        displayName: 'Task session',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'default',
+      },
+    ];
+    active.error = new Error('daemon restarted');
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    const searchInput = await openSessionSearch();
+    await act(async () => {
+      setInputValue(searchInput, 'no-match');
+      await Promise.resolve();
+    });
+
+    expect(container.textContent).toContain('No matching sessions.');
+    expect(container.textContent).not.toContain('Failed to load sessions');
+  });
+
+  it('shows the loading notice until the first page settles', async () => {
+    active.sessions = [];
+    active.loading = true;
+    useSessions.mockImplementation((options?: { archiveState?: string }) => {
+      const state = options?.archiveState === 'archived' ? archived : active;
+      return { ...state, data: undefined };
+    });
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    expect(container.textContent).toContain('Loading sessions...');
+  });
 });
 
 describe('WebShellSidebar Live group', () => {

From 92c02d2d9591244cef7e3deb239405455ea57c88 Mon Sep 17 00:00:00 2001
From: "qwen-code-autofix[bot]"
 <qwen-code-autofix[bot]@users.noreply.github.com>
Date: Tue, 11 Aug 2026 21:35:04 +0000
Subject: [PATCH 13/16] fix(channels): address review round-8 findings (#8457)

---
 packages/acp-bridge/src/bridge.test.ts        | 106 +++++++++++
 packages/acp-bridge/src/bridge.ts             |   2 +-
 .../serve/channel-worker-supervisor.test.ts   |  55 ++++++
 .../src/services/chatRecordingService.test.ts |  28 +++
 .../core/src/services/sessionTitle.test.ts    |  30 +++
 .../components/sidebar/WebShellSidebar.tsx    |  17 +-
 ...WebShellSidebar.workspace-removal.test.tsx | 177 +++++++++++++++++-
 .../sidebar/WorkspaceSection.test.tsx         |  30 +++
 .../components/sidebar/WorkspaceSection.tsx   |  23 ++-
 .../web-shell/client/e2e/utils/mockDaemon.ts  |  54 ++++--
 10 files changed, 492 insertions(+), 30 deletions(-)

diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts
index 99768d563a0..a2665b18843 100644
--- a/packages/acp-bridge/src/bridge.test.ts
+++ b/packages/acp-bridge/src/bridge.test.ts
@@ -8806,6 +8806,111 @@ describe('createAcpSessionBridge', () => {
       await bridge.shutdown();
     });
 
+    it('does not sacrifice an echo block for an empty display projection after the cap', async () => {
+      const handle = makeChannel({
+        promptImpl: () => ({ stopReason: 'end_turn' }),
+      });
+      const bridge = makeBridge({ channelFactory: async () => handle.channel });
+      const session = await bridge.spawnOrAttach({
+        workspaceCwd: WS_A,
+        sourceType: 'channel',
+      });
+      const abort = new AbortController();
+      const events = bridge.subscribeEvents(session.sessionId, {
+        signal: abort.signal,
+      });
+      const userChunks: unknown[] = [];
+      const drain = (async () => {
+        for await (const event of events) {
+          if (event.type !== 'session_update') continue;
+          const update = (
+            event.data as {
+              update?: { sessionUpdate?: string; content?: unknown };
+            }
+          ).update;
+          if (update?.sessionUpdate !== 'user_message_chunk') continue;
+          userChunks.push(update.content);
+          if (userChunks.length === 256) break;
+        }
+      })();
+      const resources = Array.from({ length: 256 }, (_, index) => ({
+        type: 'resource_link' as const,
+        uri: `file:///resource-${index}`,
+        name: `resource-${index}`,
+      }));
+
+      await bridge.sendPrompt(
+        session.sessionId,
+        {
+          sessionId: session.sessionId,
+          prompt: [...resources, { type: 'text', text: 'hidden text' }],
+        },
+        undefined,
+        { promptDisplayText: '' },
+      );
+
+      // An empty projection publishes no visible slot, so reserving one would
+      // only overwrite a resource block that the echo must keep.
+      await vi.waitFor(() => expect(userChunks).toHaveLength(256));
+      expect(userChunks).toEqual(resources);
+      abort.abort();
+      await drain.catch(() => {});
+      await bridge.shutdown();
+    });
+
+    it('ignores promptDisplayText for non-channel sessions', async () => {
+      const promptGate = deferred<PromptResponse>();
+      const handle = makeChannel({
+        promptImpl: () => promptGate.promise,
+      });
+      const bridge = makeBridge({ channelFactory: async () => handle.channel });
+      const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
+      const abort = new AbortController();
+      const events = bridge.subscribeEvents(session.sessionId, {
+        signal: abort.signal,
+      });
+      const userChunk = (async () => {
+        for await (const event of events) {
+          if (event.type !== 'session_update') continue;
+          const update = (
+            event.data as {
+              update?: { sessionUpdate?: string; content?: unknown };
+            }
+          ).update;
+          if (update?.sessionUpdate === 'user_message_chunk') return update;
+        }
+        throw new Error('no user_message_chunk observed');
+      })();
+
+      const promptPromise = bridge.sendPrompt(
+        session.sessionId,
+        {
+          sessionId: session.sessionId,
+          prompt: [{ type: 'text', text: 'verbatim user text' }],
+        },
+        undefined,
+        { promptDisplayText: 'hidden' },
+      );
+
+      await vi.waitFor(() => {
+        expect(bridge.getPendingPrompts(session.sessionId)).toMatchObject([
+          { text: 'verbatim user text', state: 'running' },
+        ]);
+      });
+      await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1));
+      await expect(userChunk).resolves.toMatchObject({
+        content: { type: 'text', text: 'verbatim user text' },
+      });
+      expect(handle.agent.promptCalls[0]?._meta).not.toHaveProperty(
+        'qwen.daemon.promptDisplayText',
+      );
+
+      promptGate.resolve({ stopReason: 'end_turn' });
+      await promptPromise;
+      abort.abort();
+      await bridge.shutdown();
+    });
+
     it('hides every text block for an intentionally empty display projection', async () => {
       const handle = makeChannel({
         promptImpl: () => ({ stopReason: 'end_turn' }),
@@ -8884,6 +8989,7 @@ describe('createAcpSessionBridge', () => {
         )
         .catch((error: unknown) => error);
       expect(malformedResult).not.toBeInstanceOf(TypeError);
+      expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(0);
       await expect(
         bridge.sendPrompt(session.sessionId, {
           sessionId: session.sessionId,
diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts
index cafd99366fc..40b2042bf37 100644
--- a/packages/acp-bridge/src/bridge.ts
+++ b/packages/acp-bridge/src/bridge.ts
@@ -1038,7 +1038,7 @@ function echoPromptToSessionBus(
   const serverTimestamp = Date.now();
   const echoPrompt = prompt.slice(0, MAX_ECHO_CONTENT_BLOCKS);
   if (
-    displayText !== undefined &&
+    displayText &&
     !echoPrompt.some((part) => isRecord(part) && part['type'] === 'text')
   ) {
     const textPart = prompt
diff --git a/packages/cli/src/serve/channel-worker-supervisor.test.ts b/packages/cli/src/serve/channel-worker-supervisor.test.ts
index 403d3cd2a92..918660ed58d 100644
--- a/packages/cli/src/serve/channel-worker-supervisor.test.ts
+++ b/packages/cli/src/serve/channel-worker-supervisor.test.ts
@@ -957,6 +957,61 @@ describe('createChannelWorkerSupervisor', () => {
     );
   });
 
+  it('revokes the worker prompt authorization when the worker exits naturally', async () => {
+    const child = new FakeChild();
+    const spawnWorker = vi.fn(
+      (_execPath: string, _argv: string[], _options: unknown) => child,
+    );
+    const supervisor = createChannelWorkerSupervisor({
+      cliEntryPath: '/repo/dist/index.js',
+      daemonUrl: 'http://127.0.0.1:4170',
+      workspace: '/workspace',
+      selection: { mode: 'names', names: ['telegram'] },
+      spawnWorker,
+    });
+
+    const started = supervisor.start();
+    child.emit('message', { type: 'ready', channels: ['telegram'] });
+    await started;
+
+    const env = (spawnWorker.mock.calls[0]![2] as { env: NodeJS.ProcessEnv })
+      .env;
+    const promptAuthorization = env['QWEN_CHANNEL_DAEMON_WORKER']!;
+    expect(
+      isChannelWorkerPromptAuthorized(promptAuthorization, '/workspace'),
+    ).toBe(true);
+
+    child.emit('exit', 1, null);
+
+    expect(
+      isChannelWorkerPromptAuthorized(promptAuthorization, '/workspace'),
+    ).toBe(false);
+  });
+
+  it('revokes the worker prompt authorization when spawn throws', async () => {
+    let capturedEnv: NodeJS.ProcessEnv | undefined;
+    const supervisor = createChannelWorkerSupervisor({
+      cliEntryPath: '/repo/dist/index.js',
+      daemonUrl: 'http://127.0.0.1:4170',
+      workspace: '/workspace',
+      selection: { mode: 'names', names: ['telegram'] },
+      spawnWorker: vi.fn(
+        (_execPath: string, _argv: string[], options: unknown) => {
+          capturedEnv = (options as { env: NodeJS.ProcessEnv }).env;
+          throw new Error('spawn ENOENT');
+        },
+      ),
+    });
+
+    await expect(supervisor.start()).rejects.toThrow('spawn ENOENT');
+
+    const promptAuthorization = capturedEnv?.['QWEN_CHANNEL_DAEMON_WORKER'];
+    expect(promptAuthorization).toBeDefined();
+    expect(
+      isChannelWorkerPromptAuthorized(promptAuthorization!, '/workspace'),
+    ).toBe(false);
+  });
+
   it('restarts a ready worker after unexpected exit within budget', async () => {
     vi.useFakeTimers();
     const firstChild = new FakeChild(false);
diff --git a/packages/core/src/services/chatRecordingService.test.ts b/packages/core/src/services/chatRecordingService.test.ts
index 3d24e6973bc..26f8d7d63ec 100644
--- a/packages/core/src/services/chatRecordingService.test.ts
+++ b/packages/core/src/services/chatRecordingService.test.ts
@@ -683,6 +683,34 @@ describe('ChatRecordingService', () => {
       vi.mocked(jsonl.writeLine).mockClear();
     });
 
+    it('compensates the rewind splice for the display-text cap window', async () => {
+      // 25 turns, but the projection buffer retains only the last 20, so the
+      // rewind splice must offset by the 5 turns that fell out of the window.
+      for (let index = 0; index < 25; index += 1) {
+        chatRecordingService.recordUserMessage(
+          [{ text: `hidden ${index}` }],
+          undefined,
+          {
+            displayText: `visible ${index}`,
+            hookContext: '',
+          },
+        );
+      }
+      expect(chatRecordingService.getUserDisplayTextsForTitle()).toHaveLength(
+        20,
+      );
+
+      // Rewind to turn 22 keeps turns 0..21; the retained window covers turns
+      // 5..24, so projections for turns 5..21 (entries 0..16) must survive.
+      chatRecordingService.rewindRecording(22, { truncatedCount: 3 });
+
+      expect(chatRecordingService.getUserDisplayTextsForTitle()).toEqual(
+        Array.from({ length: 17 }, (_, index) => `visible ${index + 5}`),
+      );
+      await chatRecordingService.flush();
+      vi.mocked(jsonl.writeLine).mockClear();
+    });
+
     it('preserves a resumed user turn parent when rebuilding rewind boundaries', async () => {
       vi.mocked(mockConfig.getResumedSessionData).mockReturnValue({
         lastCompletedUuid: 'assistant-1',
diff --git a/packages/core/src/services/sessionTitle.test.ts b/packages/core/src/services/sessionTitle.test.ts
index 7a9f0dfe95f..430c7f1c134 100644
--- a/packages/core/src/services/sessionTitle.test.ts
+++ b/packages/core/src/services/sessionTitle.test.ts
@@ -203,6 +203,29 @@ describe('tryGenerateSessionTitle', () => {
     expect(prompt).not.toContain('hidden second instructions');
   });
 
+  it('treats an all-empty display projection as intentionally empty', async () => {
+    const { config, generateJson } = makeConfig({
+      fastModel: 'qwen-turbo',
+      history: [
+        { role: 'user', parts: [{ text: 'hidden channel instructions' }] },
+        { role: 'model', parts: [{ text: 'Hello!' }] },
+      ],
+      generateJsonResult: { title: 'Should never be used' },
+    });
+
+    const outcome = await tryGenerateSessionTitle(
+      config,
+      new AbortController().signal,
+      ['', ''],
+    );
+
+    // `''` entries mean "projection recorded, user-authored text empty" —
+    // stay in projection mode (`empty_history`) instead of falling back to
+    // the raw history, which carries the hidden model context.
+    expect(outcome).toEqual({ ok: false, reason: 'empty_history' });
+    expect(generateJson).not.toHaveBeenCalled();
+  });
+
   it('does not align a display projection onto an intervening system turn', async () => {
     const { config, generateJson } = makeConfig({
       fastModel: 'qwen-turbo',
@@ -230,6 +253,8 @@ describe('tryGenerateSessionTitle', () => {
     const { config, generateJson } = makeConfig({
       fastModel: 'qwen-turbo',
       history: [
+        { role: 'user', parts: [{ text: 'oldest hidden instructions' }] },
+        { role: 'model', parts: [{ text: 'Oldest reply' }] },
         { role: 'user', parts: [{ text: 'older hidden instructions' }] },
         { role: 'model', parts: [{ text: 'Older reply' }] },
         { role: 'user', parts: [{ text: 'current hidden instructions' }] },
@@ -238,13 +263,18 @@ describe('tryGenerateSessionTitle', () => {
       generateJsonResult: { title: 'Answer greeting' },
     });
 
+    // Resumed sessions replay `undefined` for every user turn recorded before
+    // display-projection tracking existed; only the newest turn projects.
     await tryGenerateSessionTitle(config, new AbortController().signal, [
+      undefined,
+      undefined,
       '当前消息',
     ]);
 
     const call = generateJson.mock.calls[0][0] as { contents: Content[] };
     const prompt = call.contents[0]?.parts?.[0]?.text;
     expect(prompt).toContain('当前消息');
+    expect(prompt).not.toContain('undefined');
     expect(prompt).not.toContain('older hidden instructions');
     expect(prompt).not.toContain('current hidden instructions');
   });
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 09826b0041c..78c006c374a 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -609,6 +609,7 @@ export function WebShellSidebar({
     catalog: channelTypeCatalog,
     channels: channelInstances,
     reload: reloadChannelCatalog,
+    error: channelCatalogError,
   } = useChannels({
     autoLoad: channelGroupingEnabled,
     enabled: channelGroupingEnabled,
@@ -1470,9 +1471,12 @@ export function WebShellSidebar({
   const channelCatalogPollInFlightRef = useRef(false);
   useEffect(() => {
     if (!channelGroupingEnabled) return;
-    const pollInterval = !error
-      ? ACTIVE_SESSION_POLL_INTERVAL_MS
-      : IDLE_SESSION_POLL_INTERVAL_MS;
+    // Back off on the channels hook's OWN failures too — a persistently
+    // failing channels endpoint must not be re-requested every 2s.
+    const pollInterval =
+      !error && !channelCatalogError
+        ? ACTIVE_SESSION_POLL_INTERVAL_MS
+        : IDLE_SESSION_POLL_INTERVAL_MS;
     const intervalId = window.setInterval(() => {
       if (document.hidden || channelCatalogPollInFlightRef.current) return;
       channelCatalogPollInFlightRef.current = true;
@@ -1481,7 +1485,12 @@ export function WebShellSidebar({
       });
     }, pollInterval);
     return () => window.clearInterval(intervalId);
-  }, [channelGroupingEnabled, error, reloadChannelCatalog]);
+  }, [
+    channelCatalogError,
+    channelGroupingEnabled,
+    error,
+    reloadChannelCatalog,
+  ]);
 
   useEffect(() => {
     if (lastTrackedSessionSourceRef.current !== sessionSource) {
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index 9c7b01a2e78..c90debcf99d 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -126,6 +126,10 @@ const {
         workspaceByCwd: vi.fn(() => ({
           listWorkspaceSessions,
           listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+          workspaceChannelTypes: vi.fn().mockResolvedValue([]),
+          workspaceChannels: vi
+            .fn()
+            .mockResolvedValue({ revision: '0', instances: {} }),
           archiveSessionsData,
           unarchiveSessionsData,
           exportArchivedSession,
@@ -738,6 +742,10 @@ beforeEach(() => {
   workspace.client.workspaceByCwd.mockImplementation(() => ({
     listWorkspaceSessions,
     listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+    workspaceChannelTypes: vi.fn().mockResolvedValue([]),
+    workspaceChannels: vi
+      .fn()
+      .mockResolvedValue({ revision: '0', instances: {} }),
     archiveSessionsData,
     unarchiveSessionsData,
     deleteSessionsData,
@@ -3249,7 +3257,7 @@ describe('WebShellSidebar session source switch', () => {
       sessions: [channelSession],
       loading: false,
     };
-    const taskResult = {
+    let taskResult = {
       ...active,
       sessions: [taskSession],
       loading: false,
@@ -3290,6 +3298,41 @@ describe('WebShellSidebar session source switch', () => {
     ).find((candidate) => candidate.textContent?.includes('Channel session'));
     expect(row).toBeDefined();
     expect(row!.querySelector('[class*="sessionStatusDot"]')).not.toBeNull();
+
+    // A Tasks-source reconcile while the channel marker exists must not wipe
+    // it: the marker belongs to the inactive source and must survive.
+    await switchSessionSource('Tasks');
+    taskResult = {
+      ...taskResult,
+      sessions: [
+        taskSession,
+        {
+          sessionId: 'second-task-session',
+          displayName: 'Second task session',
+          workspaceCwd: '/tmp/project',
+          sourceType: 'default',
+        },
+      ],
+    };
+    renderSidebar();
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    await switchSessionSource('Channels');
+    channelResult = { ...channelResult, sessions: [...channelResult.sessions] };
+    renderSidebar();
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    const restoredRow = Array.from(
+      container.querySelectorAll<HTMLElement>('[role="button"]'),
+    ).find((candidate) => candidate.textContent?.includes('Channel session'));
+    expect(restoredRow).toBeDefined();
+    expect(
+      restoredRow!.querySelector('[class*="sessionStatusDot"]'),
+    ).not.toBeNull();
   });
 
   it('applies the source switch to the archived list', async () => {
@@ -3400,6 +3443,7 @@ describe('WebShellSidebar session source switch', () => {
     connection.capabilities = channelCapabilities;
     workspace.capabilities = channelCapabilities;
     const setIntervalSpy = vi.spyOn(window, 'setInterval');
+    const clearIntervalSpy = vi.spyOn(window, 'clearInterval');
     renderSidebar();
     await ensureWorkspaceExpanded('project');
     expect(useSessionCatalogPollingSpy).not.toHaveBeenCalledWith(
@@ -3424,6 +3468,10 @@ describe('WebShellSidebar session source switch', () => {
       ([, timeout]) => timeout === 2_000,
     );
     expect(activePoll).toBeDefined();
+    const activePollIndex = setIntervalSpy.mock.calls
+      .map(([, timeout]) => timeout)
+      .lastIndexOf(2_000);
+    const activePollId = setIntervalSpy.mock.results[activePollIndex]?.value;
     channelState.reload.mockClear();
 
     await act(async () => {
@@ -3434,6 +3482,12 @@ describe('WebShellSidebar session source switch', () => {
     });
 
     expect(channelState.reload).toHaveBeenCalledOnce();
+
+    // Leaving the Channels tab tears the interval down; otherwise the sidebar
+    // keeps reloading the channel catalog while the Tasks tab is active.
+    channelState.reload.mockClear();
+    await switchSessionSource('Tasks');
+    expect(clearIntervalSpy).toHaveBeenCalledWith(activePollId);
   });
 
   it('keeps a flat channel list when channel metadata is unavailable', async () => {
@@ -3879,6 +3933,82 @@ describe('WebShellSidebar session source switch', () => {
       window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
     ).not.toContain('channel-type:');
   });
+  it('does not reconcile channel sections against the previous source page', async () => {
+    enableChannelOrganization();
+    setChannelCatalog();
+    const taskSession: DaemonSessionSummary = {
+      sessionId: 'task-session',
+      displayName: 'Task session',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'default',
+    };
+    const dingSession: DaemonSessionSummary = {
+      sessionId: 'ding-one-session',
+      displayName: 'DingTalk one',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'channel',
+      sourceId: 'ding-one',
+    };
+    const feishuSession: DaemonSessionSummary = {
+      sessionId: 'feishu-one-session',
+      displayName: 'Feishu one',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'channel',
+      sourceId: 'feishu-one',
+    };
+    // The source switch retains the previous page (identity unchanged) until
+    // the channel fetch settles, and that page still carries a channel row.
+    const retainedPage = [taskSession, dingSession];
+    let channelPage: DaemonSessionSummary[] | undefined = undefined;
+    useSessions.mockImplementation(
+      (options?: { archiveState?: string; sourceType?: string }) => {
+        if (options?.archiveState === 'archived') {
+          return { ...archived, data: archived.sessions };
+        }
+        if (options?.sourceType === 'channel') {
+          return channelPage
+            ? { ...active, sessions: channelPage, data: channelPage }
+            : { ...active, sessions: retainedPage, data: retainedPage };
+        }
+        return { ...active, sessions: retainedPage, data: retainedPage };
+      },
+    );
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    await settleGroupsCatalog();
+    expect(container.textContent).toContain('Task session');
+
+    await switchSessionSource('Channels');
+
+    // The settled page still belongs to the tasks source, so its DingTalk
+    // section must not consume the channel initial-catalog latch.
+    expect(container.querySelector('section[aria-label="Feishu"]')).toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('channel-type:');
+
+    channelPage = [dingSession, feishuSession];
+    renderSidebar();
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    // Both sections register against the true channel-source page: expanded,
+    // and not persisted as mid-session auto-collapses.
+    for (const label of ['DingTalk', 'Feishu']) {
+      const group = container.querySelector<HTMLElement>(
+        `section[aria-label="${label}"]`,
+      );
+      expect(group).not.toBeNull();
+      expect(
+        group!.querySelector('button[aria-expanded="true"]'),
+      ).not.toBeNull();
+    }
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('channel-type:');
+  });
 });
 
 describe('WebShellSidebar session list notices', () => {
@@ -3941,6 +4071,51 @@ describe('WebShellSidebar session list notices', () => {
 
     expect(container.textContent).toContain('Loading sessions...');
   });
+
+  it('keeps the settled empty notice while a background refresh is in flight', async () => {
+    active.sessions = [];
+    active.loading = true;
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    expect(container.textContent).toContain('No matching sessions.');
+    expect(container.textContent).not.toContain('Loading sessions...');
+  });
+
+  it('keeps the settled empty notice when a background refresh failed', async () => {
+    active.sessions = [];
+    active.error = new Error('daemon restarted');
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    expect(container.textContent).toContain('No matching sessions.');
+    expect(container.textContent).not.toContain('Failed to load sessions');
+  });
+
+  it('offers a retry when the first page load failed', async () => {
+    active.sessions = [];
+    active.error = new Error('daemon restarted');
+    useSessions.mockImplementation((options?: { archiveState?: string }) => {
+      const state = options?.archiveState === 'archived' ? archived : active;
+      return { ...state, data: undefined };
+    });
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    expect(container.textContent).toContain('Failed to load sessions');
+    const retry = Array.from(
+      container.querySelectorAll<HTMLButtonElement>('button'),
+    ).find((button) => button.textContent?.includes('Failed to load sessions'));
+    expect(retry).toBeDefined();
+    await act(async () => {
+      click(retry!);
+      await Promise.resolve();
+    });
+    expect(active.reload).toHaveBeenCalled();
+  });
 });
 
 describe('WebShellSidebar Live group', () => {
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index fa12268af18..c7847f32eec 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -322,6 +322,18 @@ describe('WorkspaceSection label', () => {
     renderSection({ client, expanded: true, sourceType: 'channel' });
     await flush();
     expect(container.textContent).not.toContain('Load failed');
+    // The switch must actually initiate the new source's fetch, not leave the
+    // section stuck on the failed tasks load.
+    expect(listWorkspaceSessionsPage).toHaveBeenCalledWith(
+      expect.objectContaining({ sourceType: 'channel' }),
+    );
+    expect(
+      listWorkspaceSessionsPage.mock.calls.filter(
+        ([options]) =>
+          (options as { sourceType?: string } | undefined)?.sourceType ===
+          'channel',
+      ),
+    ).toHaveLength(1);
   });
 
   it('groups a secondary workspace with its own channel catalog', async () => {
@@ -612,6 +624,24 @@ describe('WorkspaceSection label', () => {
     await flush();
 
     expect(workspaceChannelTypes).toHaveBeenCalledTimes(2);
+
+    // Background tabs skip the tick entirely, matching the sibling pollers.
+    const originalVisibility = document.visibilityState;
+    Object.defineProperty(document, 'visibilityState', {
+      value: 'hidden',
+      configurable: true,
+    });
+    await act(async () => {
+      const callback = poll![0];
+      if (typeof callback === 'function') callback();
+      await Promise.resolve();
+    });
+    await flush();
+    expect(workspaceChannelTypes).toHaveBeenCalledTimes(2);
+    Object.defineProperty(document, 'visibilityState', {
+      value: originalVisibility,
+      configurable: true,
+    });
     setIntervalSpy.mockRestore();
   });
 });
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index 9503e4b586c..cd55e3a27e1 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -198,6 +198,7 @@ export function WorkspaceSection({
     page: sessionsPage,
     reload: reloadSessions,
     stale: sessionsStale,
+    loading: sessionsLoading,
   } = sessionsResult;
   const sessionsActive = sessionsEnabled && sessionsVisible;
   const previousSessionsActiveRef = useRef(sessionsActive);
@@ -228,7 +229,12 @@ export function WorkspaceSection({
   }, [sessionsResult.error, workspace.cwd]);
 
   useEffect(() => {
-    if (!renderSessions || disabled || !organizationEnabled) {
+    if (
+      !renderSessions ||
+      disabled ||
+      !organizationEnabled ||
+      channelGroupingEnabled
+    ) {
       setGroups([]);
       return;
     }
@@ -246,6 +252,7 @@ export function WorkspaceSection({
       cancelled = true;
     };
   }, [
+    channelGroupingEnabled,
     client,
     disabled,
     organizationEnabled,
@@ -284,7 +291,7 @@ export function WorkspaceSection({
     // The catalog rides its own tick so instances added or removed while a
     // section is expanded reach the grouping logic without a collapse cycle.
     const timer = setInterval(() => {
-      void loadChannelCatalog();
+      if (document.visibilityState === 'visible') void loadChannelCatalog();
     }, 10_000);
     return () => clearInterval(timer);
   }, [
@@ -369,7 +376,8 @@ export function WorkspaceSection({
   }, [excludePinned, searchQuery, sessions]);
 
   const groupedSessions = useMemo(() => {
-    if (!organizationEnabled || groups.length === 0) return null;
+    if (!organizationEnabled || channelGroupingEnabled || groups.length === 0)
+      return null;
     const assigned = new Set<string>();
     const sections = groups.map((group) => {
       const items = visibleSessions.filter(
@@ -384,7 +392,7 @@ export function WorkspaceSection({
         (session) => !assigned.has(session.sessionId),
       ),
     };
-  }, [groups, organizationEnabled, visibleSessions]);
+  }, [channelGroupingEnabled, groups, organizationEnabled, visibleSessions]);
 
   const channelSessionGroups = useMemo(
     () =>
@@ -479,7 +487,12 @@ export function WorkspaceSection({
                 {loadErrorLabel}
               </div>
             ) : visibleSessions.length === 0 ? (
-              <div className={styles.empty}>{noSessionsLabel}</div>
+              // A source switch swaps the query key; until the new source's
+              // page settles there is no data yet, so the "no sessions" notice
+              // would flash for a whole fetch round-trip.
+              sessionsLoading && sessionsPage === undefined ? null : (
+                <div className={styles.empty}>{noSessionsLabel}</div>
+              )
             ) : channelSessionGroups ? (
               <>
                 {channelSessionGroups.map((group) => (
diff --git a/packages/web-shell/client/e2e/utils/mockDaemon.ts b/packages/web-shell/client/e2e/utils/mockDaemon.ts
index 9e351489825..6db21aed4b8 100644
--- a/packages/web-shell/client/e2e/utils/mockDaemon.ts
+++ b/packages/web-shell/client/e2e/utils/mockDaemon.ts
@@ -541,6 +541,27 @@ function readRequestBody(raw: string | null): unknown {
   }
 }
 
+// Mirror production query modes: `group=pinned` is the pinned bucket;
+// `group=all` (and missing group) returns the full active list. The UI
+// excludes pinned rows from organized sections via `excludePinned`.
+function filterScenarioSessions(
+  scenario: WebShellDaemonScenario,
+  searchParams: URLSearchParams,
+): DaemonSessionSummary[] {
+  const group = searchParams.get('group');
+  const sourceType = searchParams.get('sourceType');
+  const sourceSessions = sourceType
+    ? scenario.sessions.filter(
+        (session) =>
+          session.sourceType === sourceType ||
+          (sourceType === 'default' && session.sourceType === undefined),
+      )
+    : scenario.sessions;
+  return group === 'pinned'
+    ? sourceSessions.filter((session) => Boolean(session.isPinned))
+    : sourceSessions;
+}
+
 function isDaemonPath(path: string): boolean {
   return (
     path === '/health' ||
@@ -565,6 +586,7 @@ function isDaemonPath(path: string): boolean {
     /^\/workspaces\/[^/]+\/channels\/[^/]+\/pairing-approvals\/?$/.test(path) ||
     /^\/workspaces\/[^/]+\/channels\/[^/]+\/?$/.test(path) ||
     /^\/workspace\/.+\/sessions\/?$/.test(path) ||
+    /^\/workspaces\/[^/]+\/sessions\/?$/.test(path) ||
     /^\/workspace\/.+\/session-groups\/?$/.test(path) ||
     /^\/workspaces\/.+\/git\/?$/.test(path) ||
     /^\/workspaces\/.+\/git\/(branches|checkout|branch|push|pull|commit|diff|log)\/?$/.test(
@@ -636,7 +658,11 @@ function isDaemonRoute(method: string, path: string): boolean {
   ) {
     return true;
   }
-  if (method === 'GET' && /^\/workspace\/.+\/sessions\/?$/.test(path)) {
+  if (
+    method === 'GET' &&
+    (/^\/workspace\/.+\/sessions\/?$/.test(path) ||
+      /^\/workspaces\/[^/]+\/sessions\/?$/.test(path))
+  ) {
     return true;
   }
   if (method === 'GET' && /^\/workspace\/.+\/session-groups\/?$/.test(path)) {
@@ -847,24 +873,14 @@ async function handleDaemonRoute(
     await json(route, workspaceMcpResources(scenario, serverName));
     return;
   }
-  if (method === 'GET' && /^\/workspace\/.+\/sessions\/?$/.test(path)) {
-    // Mirror production query modes: `group=pinned` is the pinned bucket;
-    // `group=all` (and missing group) returns the full active list. The UI
-    // excludes pinned rows from organized sections via `excludePinned`.
-    const group = searchParams.get('group');
-    const sourceType = searchParams.get('sourceType');
-    const sourceSessions = sourceType
-      ? scenario.sessions.filter(
-          (session) =>
-            session.sourceType === sourceType ||
-            (sourceType === 'default' && session.sourceType === undefined),
-        )
-      : scenario.sessions;
-    const sessions =
-      group === 'pinned'
-        ? sourceSessions.filter((session) => Boolean(session.isPinned))
-        : sourceSessions;
-    await json(route, { sessions });
+  if (
+    method === 'GET' &&
+    (/^\/workspace\/.+\/sessions\/?$/.test(path) ||
+      /^\/workspaces\/[^/]+\/sessions\/?$/.test(path))
+  ) {
+    await json(route, {
+      sessions: filterScenarioSessions(scenario, searchParams),
+    });
     return;
   }
   if (method === 'GET' && /^\/workspace\/.+\/session-groups\/?$/.test(path)) {

From 84db931ed67e8ead281620ad7adcbe08c5805bce Mon Sep 17 00:00:00 2001
From: "qwen-code-autofix[bot]"
 <qwen-code-autofix[bot]@users.noreply.github.com>
Date: Tue, 11 Aug 2026 21:40:51 +0000
Subject: [PATCH 14/16] test(web-shell): pin round-8 sidebar behavior fixes
 (#8457)

---
 ...WebShellSidebar.workspace-removal.test.tsx | 26 ++++++++++
 .../sidebar/WorkspaceSection.test.tsx         | 48 ++++++++++++++-----
 2 files changed, 62 insertions(+), 12 deletions(-)

diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
index c90debcf99d..50c2329a32f 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.workspace-removal.test.tsx
@@ -74,6 +74,7 @@ const {
   const exportArchivedSession = vi.fn();
   const sessionActions = { renameSession: vi.fn() };
   const channelState = {
+    error: undefined as Error | undefined,
     data: undefined as
       | {
           catalog: Array<{
@@ -781,6 +782,7 @@ beforeEach(() => {
   active.loading = false;
   active.error = null;
   archived.sessions.length = 0;
+  channelState.error = undefined;
   channelState.data = undefined;
   channelState.catalog = [];
   channelState.channels = {};
@@ -3490,6 +3492,30 @@ describe('WebShellSidebar session source switch', () => {
     expect(clearIntervalSpy).toHaveBeenCalledWith(activePollId);
   });
 
+  it('backs off the channel catalog poll while the channels hook errors', async () => {
+    const channelCapabilities = {
+      ...capabilities,
+      features: [...capabilities.features, 'channel_management'],
+    };
+    connection.capabilities = channelCapabilities;
+    workspace.capabilities = channelCapabilities;
+    channelState.error = new Error('channels endpoint down');
+    const setIntervalSpy = vi.spyOn(window, 'setInterval');
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+    await switchSessionSource('Channels');
+
+    // A persistently failing channels endpoint must not be re-requested on
+    // the 2s active cadence; the poll downshifts like the sibling pollers.
+    expect(
+      setIntervalSpy.mock.calls.some(([, timeout]) => timeout === 2_000),
+    ).toBe(false);
+    expect(
+      setIntervalSpy.mock.calls.some(([, timeout]) => timeout === 30_000),
+    ).toBe(true);
+  });
+
   it('keeps a flat channel list when channel metadata is unavailable', async () => {
     active.sessions.push({
       sessionId: 'legacy-channel-session',
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index c7847f32eec..75d3915025b 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -336,7 +336,39 @@ describe('WorkspaceSection label', () => {
     ).toHaveLength(1);
   });
 
+  it('does not flash the empty notice while a fresh source settles', async () => {
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessionsPage: vi.fn(
+          () => new Promise<{ sessions: DaemonSessionSummary[] }>(() => {}),
+        ),
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({ client, expanded: true, sourceType: 'channel' });
+    await flush();
+
+    // The new query key's fetch is in flight with no settled page yet, so
+    // the section renders nothing instead of "No sessions" for the
+    // round-trip.
+    expect(container.textContent).not.toContain('No sessions');
+  });
+
   it('groups a secondary workspace with its own channel catalog', async () => {
+    const listSessionGroups = vi.fn().mockResolvedValue({
+      groups: [
+        {
+          id: 'organization-group',
+          name: 'Organization group',
+          color: 'blue',
+          order: 0,
+          createdAt: '2026-01-01T00:00:00.000Z',
+          updatedAt: '2026-01-01T00:00:00.000Z',
+        },
+      ],
+    });
     const client = {
       workspaceByCwd: vi.fn(() => ({
         workspaceGit,
@@ -360,18 +392,7 @@ describe('WorkspaceSection label', () => {
             },
           ],
         }),
-        listSessionGroups: vi.fn().mockResolvedValue({
-          groups: [
-            {
-              id: 'organization-group',
-              name: 'Organization group',
-              color: 'blue',
-              order: 0,
-              createdAt: '2026-01-01T00:00:00.000Z',
-              updatedAt: '2026-01-01T00:00:00.000Z',
-            },
-          ],
-        }),
+        listSessionGroups,
         workspaceChannelTypes: vi.fn().mockResolvedValue([
           {
             type: 'dingtalk',
@@ -427,6 +448,9 @@ describe('WorkspaceSection label', () => {
     expect(
       container.querySelector('section[aria-label="Organization group"]'),
     ).toBeNull();
+    // Channel mode discards the organization sections, so the catalog fetch
+    // must be skipped too, mirroring the sidebar's own org prefetch gates.
+    expect(listSessionGroups).not.toHaveBeenCalled();
   });
 
   it('renders channel sessions flat while the channel catalog failed to load', async () => {

From 13b771d7e315299d361041fd72c4636472a3398c Mon Sep 17 00:00:00 2001
From: "qwen-code-autofix[bot]"
 <qwen-code-autofix[bot]@users.noreply.github.com>
Date: Wed, 12 Aug 2026 06:31:02 +0000
Subject: [PATCH 15/16] fix(channels): address review round-9 findings (#8457)

---
 packages/acp-bridge/src/bridge.test.ts        |  1 +
 .../channels/base/src/ChannelBase.test.ts     | 21 +++++++++++++++++++
 packages/channels/base/src/ChannelBase.ts     | 11 +++++++++-
 packages/channels/qqbot/src/QQChannel.ts      |  2 +-
 packages/channels/qqbot/src/events.test.ts    | 18 ++++++++++++++++
 5 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts
index 6e59dc85f36..edb4133e789 100644
--- a/packages/acp-bridge/src/bridge.test.ts
+++ b/packages/acp-bridge/src/bridge.test.ts
@@ -8432,6 +8432,7 @@ describe('createAcpSessionBridge', () => {
     const replayAttach = bridge.loadSession({
       sessionId: first.sessionId,
       workspaceCwd: WS_A,
+      historyReplay: 'response',
       historyPageSize: 10,
       clientId: 'rejected-load-client',
     });
diff --git a/packages/channels/base/src/ChannelBase.test.ts b/packages/channels/base/src/ChannelBase.test.ts
index 02e041afcd3..e2c3e829266 100644
--- a/packages/channels/base/src/ChannelBase.test.ts
+++ b/packages/channels/base/src/ChannelBase.test.ts
@@ -10273,6 +10273,27 @@ describe('ChannelBase', () => {
       expect(options).toMatchObject({ displayText: 'hello' });
     });
 
+    it('neutralizes display-unsafe controls in the raw-text display fallback', async () => {
+      const ch = createChannel();
+      const rlo = String.fromCharCode(0x202e); // bidi override (trojan-source)
+      const bel = String.fromCharCode(0x07); // C0 control
+      // Adapters that never set displayText fall back to the raw text; the
+      // projection must neutralize it before it reaches the session bus,
+      // transcript, and session previews.
+      await ch.handleInbound(
+        envelope({ text: `line1${rlo}${bel}\nline2${'A'.repeat(9000)}` }),
+      );
+
+      const [, , options] = (bridge.prompt as ReturnType<typeof vi.fn>).mock
+        .calls[0]!;
+      const displayText = (options as { displayText: string }).displayText;
+      // Controls are replaced, the real newline survives, and the projection
+      // is capped by code point.
+      expect(displayText.startsWith('line1  \nline2')).toBe(true);
+      expect(displayText).not.toContain(rlo);
+      expect(Array.from(displayText)).toHaveLength(8000);
+    });
+
     it('prepends channel boundary metadata after custom instructions once per session', async () => {
       const ch = createChannel({
         instructions: 'Be concise.',
diff --git a/packages/channels/base/src/ChannelBase.ts b/packages/channels/base/src/ChannelBase.ts
index 9fd6d7454a3..c47dc5b0a75 100644
--- a/packages/channels/base/src/ChannelBase.ts
+++ b/packages/channels/base/src/ChannelBase.ts
@@ -47,6 +47,7 @@ import {
   sanitizePromptText,
   sanitizePromptPath,
   sanitizeLogText,
+  sanitizeDisplayText,
   truncateCodePoints,
   PROMPT_UNSAFE_INVISIBLES,
 } from './sanitize.js';
@@ -331,6 +332,7 @@ const COMMAND_TOKEN_RE = new RegExp(`^[${COMMAND_TOKEN_CHARS}]+(?:@\\S+)?$`);
 const LOOP_ADD_RE = /^"([^"]+)"\s+(.+)$/su;
 const MAX_LOOP_JOBS_PER_TARGET = 10;
 const MAX_LOOP_PROMPT_CHARS = 4000;
+const MAX_DISPLAY_PROJECTION_CHARS = 8000;
 
 /**
  * The command-providing surface of a bridge. AcpBridge runs a single agent and
@@ -5039,7 +5041,14 @@ export abstract class ChannelBase {
       await this.recordObservedContact(envelope);
       this.onObservedContact(envelope);
     }
-    const displayText = envelope.displayText ?? envelope.text;
+    // Adapters that never set `displayText` fall back to the raw message
+    // text; sanitize at this boundary so attacker-controlled bidi/zero-width/
+    // control chars cannot reach the session-bus echo, recorded transcript,
+    // or session previews.
+    const displayText = sanitizeDisplayText(
+      envelope.displayText ?? envelope.text,
+      MAX_DISPLAY_PROJECTION_CHARS,
+    );
 
     let memoryIntent: ResolvedChannelMemoryIntent | null =
       parseChannelMemoryIntent(envelope.text);
diff --git a/packages/channels/qqbot/src/QQChannel.ts b/packages/channels/qqbot/src/QQChannel.ts
index c8f75a0d0a5..d7f896ea676 100644
--- a/packages/channels/qqbot/src/QQChannel.ts
+++ b/packages/channels/qqbot/src/QQChannel.ts
@@ -2340,7 +2340,7 @@ export class QQChannel extends ChannelBase {
 
     const effectiveIsAtBot = forceAtMention ?? isAtBot;
 
-    const isSlash = effectiveIsAtBot && safeDisplayText.startsWith('/');
+    const isSlash = effectiveIsAtBot && safeCleanText.startsWith('/');
 
     // Deliberately NOT hard-blocking bot messages — QQ Bot API may deliver
     // self-echoes or other bot messages. Instead, tag with [bot] prefix so the
diff --git a/packages/channels/qqbot/src/events.test.ts b/packages/channels/qqbot/src/events.test.ts
index 78e0e09dbc2..2cd103f8e65 100644
--- a/packages/channels/qqbot/src/events.test.ts
+++ b/packages/channels/qqbot/src/events.test.ts
@@ -524,6 +524,24 @@ describe('handleGroup', () => {
     expect(env['text']).toBe('/status');
   });
 
+  it('其他成员 mention 后的斜杠命令仍被识别', async () => {
+    const ch = makeChannel();
+    const pvt = ch as unknown as QQChannelRaw;
+    pvt['handleGroup'](
+      makeGroupEvent({
+        content: '<@OPENID_BOT> <@OPENID_ALICE> /schedule list',
+        mentions: [
+          { member_openid: 'bot-openid', is_you: true },
+          { member_openid: 'alice-openid', is_you: false },
+        ],
+      }),
+    );
+    await vi.advanceTimersByTimeAsync(600);
+    const env = mockHandleInbound.mock.calls[0][0] as Record<string, unknown>;
+    expect(env['text']).toBe('/schedule list');
+    expect(env['displayText']).toBe('<@OPENID_ALICE> /schedule list');
+  });
+
   it('重复消息不触发', async () => {
     const ch = makeChannel();
     const pvt = ch as unknown as QQChannelRaw;

From 06336a25cb0856d03c2cc3e9ffabbd1260bac886 Mon Sep 17 00:00:00 2001
From: "qwen-code-autofix[bot]"
 <qwen-code-autofix[bot]@users.noreply.github.com>
Date: Wed, 12 Aug 2026 11:46:01 +0000
Subject: [PATCH 16/16] fix(web-shell): pin Other channels group after platform
 sections (#8457)

---
 .../sidebar/channelSessionGroups.test.ts      | 35 +++++++++++++++++--
 .../sidebar/channelSessionGroups.ts           | 12 +++++--
 2 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
index 7cb5dbbf048..925cb429c71 100644
--- a/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
+++ b/packages/web-shell/client/components/sidebar/channelSessionGroups.test.ts
@@ -30,6 +30,10 @@ function instance(name: string, type: string): DaemonChannelInstanceSnapshot {
   };
 }
 
+function groupIds(groups: ReturnType<typeof groupSessionsByChannelType>) {
+  return groups.map((group) => group.id);
+}
+
 describe('groupSessionsByChannelType', () => {
   it('combines channel instances of the same type in first-seen order', () => {
     const groups = groupSessionsByChannelType(
@@ -90,16 +94,41 @@ describe('groupSessionsByChannelType', () => {
         sessions: sessions.map((item) => item.sessionId),
       })),
     ).toEqual([
+      {
+        id: 'channel-type:dingtalk',
+        label: 'DingTalk',
+        sessions: ['d1'],
+      },
       {
         id: 'channel-type-fallback',
         label: 'Other channels',
         sessions: ['orphan-constructor', 'orphan-proto'],
       },
+    ]);
+  });
+
+  it('pins the fallback group after every resolved platform section', () => {
+    // The fallback section is emitted in session iteration order unless pinned,
+    // so an orphan seen before any platform session would otherwise render
+    // between two real platform sections.
+    const groups = groupSessionsByChannelType(
+      [
+        session('legacy', 'retired-instance'),
+        session('f1', 'feishu'),
+        session('d1', 'ding-one'),
+      ],
+      catalog,
       {
-        id: 'channel-type:dingtalk',
-        label: 'DingTalk',
-        sessions: ['d1'],
+        feishu: instance('feishu', 'feishu'),
+        'ding-one': instance('ding-one', 'dingtalk'),
       },
+      'Other channels',
+    );
+
+    expect(groupIds(groups)).toEqual([
+      'channel-type:feishu',
+      'channel-type:dingtalk',
+      'channel-type-fallback',
     ]);
   });
 
diff --git a/packages/web-shell/client/components/sidebar/channelSessionGroups.ts b/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
index 8da23c154ff..9d946da90a5 100644
--- a/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
+++ b/packages/web-shell/client/components/sidebar/channelSessionGroups.ts
@@ -10,6 +10,8 @@ export interface ChannelSessionGroup {
   sessions: DaemonSessionSummary[];
 }
 
+const FALLBACK_GROUP_ID = 'channel-type-fallback';
+
 export function groupSessionsByChannelType(
   sessions: readonly DaemonSessionSummary[],
   catalog: DaemonChannelTypeCatalog,
@@ -34,7 +36,7 @@ export function groupSessionsByChannelType(
       typeof configuredType === 'string'
         ? configuredType.trim() || undefined
         : undefined;
-    const id = type ? `channel-type:${type}` : 'channel-type-fallback';
+    const id = type ? `channel-type:${type}` : FALLBACK_GROUP_ID;
     const existing = groups.get(id);
     if (existing) {
       existing.sessions.push(session);
@@ -47,5 +49,11 @@ export function groupSessionsByChannelType(
     });
   }
 
-  return [...groups.values()];
+  const ordered = [...groups.values()];
+  const fallback = groups.get(FALLBACK_GROUP_ID);
+  // Keep the unresolved "Other channels" section after every named platform
+  // instead of letting first-seen session order wedge it between two of them.
+  return fallback === undefined
+    ? ordered
+    : [...ordered.filter((group) => group !== fallback), fallback];
 }