diff --git a/packages/web-shell/client/components/ChatEditor.test.tsx b/packages/web-shell/client/components/ChatEditor.test.tsx
index e9e381913f6..3c7c07d8cd2 100644
--- a/packages/web-shell/client/components/ChatEditor.test.tsx
+++ b/packages/web-shell/client/components/ChatEditor.test.tsx
@@ -404,7 +404,6 @@ interface ChatEditorRenderProps {
   builtinAtProviders?: WebShellCustomization['builtinAtProviders'];
   atProviders?: WebShellCustomization['atProviders'];
   skills?: Array<{ name: string; description: string }>;
-  language?: WebShellLanguage;
   reasoning?: DaemonReasoningControls;
   onSelectReasoningEffort?: (value: ReasoningSelection) => Promise<void> | void;
 }
@@ -422,7 +421,6 @@ function renderChatEditorInto(
     language = 'en',
     renderComposerTagTooltip,
     onComposerTagClick,
-    language = 'en',
     ...chatEditorProps
   } = props;
   if (composerTags) {
diff --git a/packages/web-shell/client/components/SessionOverviewPanel.test.tsx b/packages/web-shell/client/components/SessionOverviewPanel.test.tsx
index 56c4ede4917..7743d6f75cc 100644
--- a/packages/web-shell/client/components/SessionOverviewPanel.test.tsx
+++ b/packages/web-shell/client/components/SessionOverviewPanel.test.tsx
@@ -1165,7 +1165,7 @@ describe('SessionOverviewPanel', () => {
     expect(rows()).toHaveLength(50);
     act(() => click(selectAllCheckbox()));
     expect(container!.textContent).toContain('60 of 60 row(s) selected.');
-  });
+  }, 15000);
 
   it('lists an other-workspace session as a row with its folder', async () => {
     connectionState.capabilities = {
diff --git a/packages/web-shell/client/components/sidebar/SessionGroupSection.test.tsx b/packages/web-shell/client/components/sidebar/SessionGroupSection.test.tsx
index 4e87ce9c785..19717699fd3 100644
--- a/packages/web-shell/client/components/sidebar/SessionGroupSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/SessionGroupSection.test.tsx
@@ -9,6 +9,35 @@ import { SessionGroupSection } from './SessionGroupSection';
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
 
 describe('SessionGroupSection', () => {
+  it('renders a supplied source icon instead of a color dot', () => {
+    const container = document.createElement('div');
+    document.body.appendChild(container);
+    const root = createRoot(container);
+    act(() => {
+      root.render(
+        <I18nProvider language="en">
+          <SessionGroupSection
+            id="scheduled-task:task-1"
+            label="Review PRs"
+            count={1}
+            expanded
+            icon={<svg data-testid="scheduled-task-icon" />}
+            onToggle={() => {}}
+          >
+            <div>Run 1</div>
+          </SessionGroupSection>
+        </I18nProvider>,
+      );
+    });
+
+    expect(
+      container.querySelector('[data-testid="scheduled-task-icon"]'),
+    ).not.toBeNull();
+    expect(container.querySelector('[class*="sessionGroupDot"]')).toBeNull();
+    act(() => root.unmount());
+    container.remove();
+  });
+
   it('shows five sessions and resets Show all after collapsing', () => {
     const container = document.createElement('div');
     document.body.appendChild(container);
diff --git a/packages/web-shell/client/components/sidebar/SessionGroupSection.tsx b/packages/web-shell/client/components/sidebar/SessionGroupSection.tsx
index 9d2c49d9a2a..bf77c1dd0f9 100644
--- a/packages/web-shell/client/components/sidebar/SessionGroupSection.tsx
+++ b/packages/web-shell/client/components/sidebar/SessionGroupSection.tsx
@@ -22,6 +22,7 @@ export interface SessionGroupSectionProps {
   count: number;
   expanded: boolean;
   color?: DaemonSessionGroupColor;
+  icon?: ReactNode;
   children: ReactNode;
   onToggle: () => void;
   onRename?: () => void;
@@ -37,6 +38,7 @@ export function SessionGroupSection({
   count,
   expanded,
   color,
+  icon,
   children,
   onToggle,
   onRename,
@@ -71,11 +73,17 @@ export function SessionGroupSection({
           aria-expanded={expanded}
           onClick={onToggle}
         >
-          <span
-            className={`${styles.sessionGroupDot} ${colorClass}`}
-            style={dotStyle}
-            aria-hidden="true"
-          />
+          {icon ? (
+            <span className={styles.sessionGroupIcon} aria-hidden="true">
+              {icon}
+            </span>
+          ) : (
+            <span
+              className={`${styles.sessionGroupDot} ${colorClass}`}
+              style={dotStyle}
+              aria-hidden="true"
+            />
+          )}
           <span className={styles.sessionGroupTitle}>{label}</span>
           <span className={styles.sessionGroupCount}>· {count}</span>
           <span className={styles.sessionGroupChevron} aria-hidden="true">
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.module.css b/packages/web-shell/client/components/sidebar/WebShellSidebar.module.css
index 20a6f136afa..9c8d299d86f 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.module.css
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.module.css
@@ -604,6 +604,26 @@
   background: var(--muted-foreground);
 }
 
+.sessionGroupIcon {
+  width: 14px;
+  height: 14px;
+  flex: 0 0 14px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.sessionGroupIcon svg {
+  width: 14px;
+  height: 14px;
+  display: block;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.6;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+
 .sessionGroupTitle {
   min-width: 0;
   overflow: hidden;
diff --git a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
index 3eeb4eace0e..9aa9e47c2eb 100644
--- a/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
+++ b/packages/web-shell/client/components/sidebar/WebShellSidebar.tsx
@@ -117,6 +117,11 @@ import {
   replaceOwnedCollapsedSessionSectionIds,
 } from './collapsedSessionSections';
 import { measureSessionTitleScroll } from './sessionTitleScroll';
+import {
+  collectScheduledTaskSession,
+  getScheduledTaskSessionGroup,
+  type ScheduledTaskSessionSection,
+} from './scheduled-task-session-groups';
 import {
   SESSION_LIST_PAGE_SIZE,
   SESSION_ORGANIZATION_FEATURE,
@@ -155,19 +160,12 @@ const SESSION_MENU_PORTAL_STYLE: CSSProperties = {
 const GROUP_MENU_MARGIN = 8;
 const CUSTOM_GROUP_COLOR_OPTION = '__custom__';
 const DEFAULT_CUSTOM_GROUP_COLOR: DaemonSessionGroupHexColor = '#416ef5';
-// Mirrors `SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX` in acp-bridge/session-source.ts
-// (the client cannot import that package). Per-run scheduled task children keep
-// the `default` source type so they list with ordinary conversations.
-const SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX = 'scheduled_task_run:';
-
 type SidebarSessionSource = 'default' | 'channel';
 
 function isScheduledTaskSession(session: DaemonSessionSummary): boolean {
   return (
     session.sourceType === 'scheduled_task' ||
-    (session.sourceType === 'default' &&
-      session.sourceId?.startsWith(SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX) ===
-        true)
+    getScheduledTaskSessionGroup(session) !== undefined
   );
 }
 
@@ -324,7 +322,7 @@ const SESSION_GROUP_COLORS: DaemonSessionGroupPresetColor[] = [
 
 type GroupEditorMode = 'create' | 'edit';
 
-type SessionSectionKind = 'color' | 'group' | 'recent';
+type SessionSectionKind = 'color' | 'group' | 'scheduled-task' | 'recent';
 
 interface SessionSection {
   id: string;
@@ -968,11 +966,13 @@ export function WebShellSidebar({
       ? sessionSource
       : 'default'
     : undefined;
-  const channelGroupingEnabled = Boolean(
-    projectFeaturesEnabled &&
-      selectedSessionSource === 'channel' &&
-      workspace.capabilities?.features.includes('channel_management'),
+  const channelManagementEnabled = Boolean(
+    workspace.capabilities?.features.includes('channel_management'),
   );
+  const channelGroupingEnabled =
+    projectFeaturesEnabled &&
+    selectedSessionSource === 'channel' &&
+    channelManagementEnabled;
   const {
     data: channelCatalogData,
     catalog: channelTypeCatalog,
@@ -1284,6 +1284,29 @@ export function WebShellSidebar({
   if (prevOrganizationEnabled !== organizationEnabled) {
     setPrevOrganizationEnabled(organizationEnabled);
     setGroupsCatalogReady(!organizationEnabled);
+    if (organizationEnabled) {
+      // An org-disabled settle may already have consumed the Tasks latch
+      // against scheduled-task sections alone — possibly while the Channels
+      // tab was selected. Re-arm the source whose catalog gains manual
+      // groups so the first organized settle registers them as initial
+      // instead of collapsing them.
+      awaitingInitialSessionCatalogBySourceRef.current.default = true;
+    }
+  }
+  // The channel-grouping branch clears `groups` while the Channels tab is
+  // selected; when switching back to Tasks, close the gate during that same
+  // render so the settle cannot consume the first-sync latch against the
+  // empty catalog before the organized groups reload lands.
+  const [prevSessionSource, setPrevSessionSource] = useState(sessionSource);
+  if (prevSessionSource !== sessionSource) {
+    setPrevSessionSource(sessionSource);
+    if (
+      organizationEnabled &&
+      sessionSource === 'default' &&
+      channelManagementEnabled
+    ) {
+      setGroupsCatalogReady(false);
+    }
   }
   const [sidebarWidth, setSidebarWidth] = useState(readSidebarWidth);
   const [projectExpanded, setProjectExpanded] = useState(() =>
@@ -3855,7 +3878,6 @@ export function WebShellSidebar({
   );
 
   const sessionSections = useMemo<SessionSection[]>(() => {
-    if (!organizationEnabled) return [];
     const searching = searchQuery.trim().length > 0;
     const validGroupIds = new Set(groups.map((group) => group.id));
     const sessionsByColor = new Map<
@@ -3863,6 +3885,10 @@ export function WebShellSidebar({
       DaemonSessionSummary[]
     >();
     const sessionsByGroupId = new Map<string, DaemonSessionSummary[]>();
+    const scheduledTaskSections = new Map<
+      string,
+      ScheduledTaskSessionSection
+    >();
     for (const group of groups) {
       sessionsByGroupId.set(group.id, []);
     }
@@ -3878,7 +3904,11 @@ export function WebShellSidebar({
     for (const session of searchedSessions) {
       // Color takes precedence: the picker keeps color and group mutually
       // exclusive, but stay defensive if a store somehow carries both.
-      if (session.color && SESSION_GROUP_COLORS.includes(session.color)) {
+      if (
+        organizationEnabled &&
+        session.color &&
+        SESSION_GROUP_COLORS.includes(session.color)
+      ) {
         const bucket = sessionsByColor.get(session.color) ?? [];
         bucket.push(session);
         sessionsByColor.set(session.color, bucket);
@@ -3892,6 +3922,9 @@ export function WebShellSidebar({
         groupSessions.push(session);
         continue;
       }
+      if (collectScheduledTaskSession(scheduledTaskSections, session)) {
+        continue;
+      }
       // On sources with a Pinned section, a pinned session without a
       // (renderable) group stays Pinned-section-only; it never spills into
       // Ungrouped. The channel source has no Pinned section, so its pinned
@@ -3936,6 +3969,9 @@ export function WebShellSidebar({
         sessions: groupSessions,
       });
     }
+    for (const section of scheduledTaskSections.values()) {
+      sections.push({ ...section, kind: 'scheduled-task' });
+    }
     if (recentSessions.length > 0 && sections.length > 0) {
       sections.push({
         id: RECENT_SESSION_SECTION_ID,
@@ -3964,8 +4000,8 @@ export function WebShellSidebar({
       // 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;
+      if (!sessionsCatalogReady) return;
+      if (organizationEnabled && !groupsCatalogReady) return;
     }
     const unseenIds = activeSections
       .map((section) => section.id)
@@ -4809,9 +4845,6 @@ export function WebShellSidebar({
     if (selectedSessionSource === 'channel') {
       return renderFlatSessions();
     }
-    if (!organizationEnabled) {
-      return renderFlatSessions();
-    }
     if (sessionSections.length === 0) {
       return renderFlatSessions();
     }
@@ -4826,6 +4859,11 @@ export function WebShellSidebar({
           label={section.label}
           count={section.sessions.length}
           color={section.color}
+          icon={
+            section.kind === 'scheduled-task' ? (
+              <CalendarClockIcon data-web-shell-scheduled-task-group />
+            ) : undefined
+          }
           limitSessions={editingSessionIdentity === null && !searchQuery.trim()}
           expanded={expanded}
           onToggle={() => toggleSessionSection(section.id)}
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 670efa6a481..d08b9bc6873 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
@@ -1122,7 +1122,7 @@ describe('WebShellSidebar workspace removal', () => {
     });
     expect(secondaryArchive).toHaveBeenCalledWith(['other-secondary']);
     expect(primaryArchive).not.toHaveBeenCalled();
-  });
+  }, 15000);
 
   it('shows rename for current and non-current locked-secondary sessions', async () => {
     connection.sessionId = 'locked-current';
@@ -1507,7 +1507,7 @@ describe('WebShellSidebar workspace removal', () => {
     expect(primaryDelete).not.toHaveBeenCalled();
     expect(primaryArchive).not.toHaveBeenCalled();
     expect(primaryOrganization).not.toHaveBeenCalled();
-  });
+  }, 15000);
 
   it('requires workspace_qualified_rest_core for locked secondary destructive and organization controls', async () => {
     connection.capabilities = {
@@ -1647,6 +1647,23 @@ describe('WebShellSidebar workspace removal', () => {
     });
   });
 
+  it('stops channel grouping when project features hide while the channel source is active', async () => {
+    enableChannelOrganization();
+    renderSidebar();
+    await switchSessionSource('Channels');
+    expect(useChannels).toHaveBeenLastCalledWith({
+      autoLoad: true,
+      enabled: true,
+    });
+
+    renderSidebar({ projectFeaturesEnabled: false });
+
+    expect(useChannels).toHaveBeenLastCalledWith({
+      autoLoad: false,
+      enabled: false,
+    });
+  });
+
   it('clears project search state while project features are hidden', async () => {
     active.sessions = [
       {
@@ -4454,21 +4471,45 @@ describe('WebShellSidebar session source switch', () => {
     expect(container.textContent).toContain('Channel session');
   });
 
-  it('renders scheduled-task runs with a flat source icon', async () => {
+  it('groups scheduled-task runs under the task title and source icon', async () => {
     const scheduledRun: DaemonSessionSummary = {
       sessionId: 'scheduled-run',
-      displayName: 'Hourly review',
+      displayName: 'Hourly review · 08-31 09:30',
       workspaceCwd: '/tmp/project',
       sourceType: 'default',
       sourceId: 'scheduled_task_run:task-1',
     };
-    active.sessions.push(scheduledRun);
+    active.sessions.push(scheduledRun, {
+      ...scheduledRun,
+      sessionId: 'scheduled-run-2',
+      displayName: 'Hourly review · 08-31 08:30',
+    });
     renderSidebar();
     await ensureWorkspaceExpanded('project');
 
+    const group = container.querySelector(
+      'section[aria-label="Hourly review"]',
+    );
+    expect(group).not.toBeNull();
+    expect(
+      group?.querySelector('[data-web-shell-scheduled-task-group]'),
+    ).not.toBeNull();
+    expect(
+      group?.querySelectorAll('[data-web-shell-session-title]'),
+    ).toHaveLength(2);
+    expect(
+      Array.from(
+        container.querySelectorAll('[data-web-shell-session-title]'),
+      ).filter((candidate) =>
+        candidate.textContent?.startsWith('Hourly review ·'),
+      ),
+    ).toHaveLength(2);
+
     const title = Array.from(
       container.querySelectorAll('[data-web-shell-session-title]'),
-    ).find((candidate) => candidate.textContent === 'Hourly review');
+    ).find(
+      (candidate) => candidate.textContent === 'Hourly review · 08-31 09:30',
+    );
     const row = title?.closest('[role="button"]');
     expect(row).toBeTruthy();
     const sourceIcon = row?.querySelector(
@@ -4489,7 +4530,9 @@ describe('WebShellSidebar session source switch', () => {
     const completedRow = Array.from(
       container.querySelectorAll('[data-web-shell-session-title]'),
     )
-      .find((candidate) => candidate.textContent === 'Hourly review')
+      .find(
+        (candidate) => candidate.textContent === 'Hourly review · 08-31 09:30',
+      )
       ?.closest('[role="button"]');
     expect(
       completedRow?.querySelector('[data-web-shell-scheduled-task-session]'),
@@ -5294,6 +5337,146 @@ describe('WebShellSidebar session source switch', () => {
       window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
     ).not.toContain('channel-type:');
   });
+
+  it('registers manual groups as initial when organization lands after a scheduled-task settle', async () => {
+    active.sessions.push({
+      sessionId: 'scheduled-run',
+      displayName: 'Hourly review · 08-31 09:30',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'default',
+      sourceId: 'scheduled_task_run:task-1',
+    });
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    // Organization is disabled, so the flat settle carries only the
+    // scheduled-task section. Nothing may be persisted as collapsed yet.
+    expect(
+      container.querySelector('section[aria-label="Hourly review"]'),
+    ).not.toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('scheduled-task:');
+
+    // The session_organization capability lands mid-session and the groups
+    // catalog settles with a manual group.
+    const organized = {
+      ...capabilities,
+      features: [...capabilities.features, 'session_organization'],
+    };
+    connection.capabilities = organized;
+    workspace.capabilities = organized;
+    workspaceActions.listSessionGroups.mockResolvedValue({
+      groups: [{ id: 'manual-group', name: 'Manual group', color: 'blue' }],
+      colorOptions: ['blue'],
+    });
+    renderSidebar();
+    await settleGroupsCatalog();
+
+    const manualGroup = container.querySelector(
+      'section[aria-label="Manual group"]',
+    );
+    expect(manualGroup).not.toBeNull();
+    expect(
+      manualGroup!.querySelector('button[aria-expanded="true"]'),
+    ).not.toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('group:');
+    // The organized settle keeps the scheduled-task section too: ungrouped
+    // runs still form their task section while organization is enabled.
+    expect(
+      container.querySelector('section[aria-label="Hourly review"]'),
+    ).not.toBeNull();
+  });
+
+  it('registers manual groups as initial when organization lands while the channel source is selected', async () => {
+    const channelCapabilities = {
+      ...capabilities,
+      features: [...capabilities.features, 'channel_management'],
+    };
+    connection.capabilities = channelCapabilities;
+    workspace.capabilities = channelCapabilities;
+    setChannelCatalog();
+    active.sessions.push({
+      sessionId: 'scheduled-run',
+      displayName: 'Hourly review · 08-31 09:30',
+      workspaceCwd: '/tmp/project',
+      sourceType: 'default',
+      sourceId: 'scheduled_task_run:task-1',
+    });
+    const channelSessions: DaemonSessionSummary[] = [
+      {
+        sessionId: 'ding-one-session',
+        displayName: 'DingTalk one',
+        workspaceCwd: '/tmp/project',
+        sourceType: 'channel',
+        sourceId: 'ding-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: active.sessions,
+          data: active.sessions,
+        };
+      },
+    );
+
+    renderSidebar();
+    await ensureWorkspaceExpanded('project');
+
+    // Organization is disabled, so the Tasks settle carries only the
+    // scheduled-task section and consumes the Tasks latch.
+    expect(
+      container.querySelector('section[aria-label="Hourly review"]'),
+    ).not.toBeNull();
+
+    // Consume the Channels latch too while the capability is still out.
+    await switchSessionSource('Channels');
+    expect(
+      container.querySelector('section[aria-label="DingTalk"]'),
+    ).not.toBeNull();
+
+    // The session_organization capability lands while the Channels tab is
+    // selected; the groups catalog settles only after the switch back.
+    const organized = {
+      ...channelCapabilities,
+      features: [...channelCapabilities.features, 'session_organization'],
+    };
+    connection.capabilities = organized;
+    workspace.capabilities = organized;
+    workspaceActions.listSessionGroups.mockResolvedValue({
+      groups: [{ id: 'manual-group', name: 'Manual group', color: 'blue' }],
+      colorOptions: ['blue'],
+    });
+    renderSidebar();
+    await switchSessionSource('Tasks');
+    await settleGroupsCatalog();
+
+    const manualGroup = container.querySelector(
+      'section[aria-label="Manual group"]',
+    );
+    expect(manualGroup).not.toBeNull();
+    expect(
+      manualGroup!.querySelector('button[aria-expanded="true"]'),
+    ).not.toBeNull();
+    expect(
+      window.localStorage.getItem(COLLAPSED_SESSION_SECTIONS_STORAGE_KEY) ?? '',
+    ).not.toContain('group:');
+  });
 });
 
 describe('WebShellSidebar session list notices', () => {
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
index 5ef39fa8504..ae7ee5b857e 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.test.tsx
@@ -836,6 +836,167 @@ describe('WorkspaceSection label', () => {
 });
 
 describe('WorkspaceSection session loading', () => {
+  it('groups scheduled-task runs without a session-organization capability', async () => {
+    const sessions = [
+      {
+        sessionId: 'run-1',
+        displayName: 'Review PRs · 08-31 09:30',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+      },
+      {
+        sessionId: 'run-2',
+        displayName: 'Review PRs · 08-31 08:30',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+      },
+      {
+        sessionId: 'ordinary',
+        displayName: 'Ordinary session',
+        sourceType: 'default',
+      },
+    ] as DaemonSessionSummary[];
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessionsPage: vi.fn().mockResolvedValue({ sessions }),
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({ client, expanded: true, sourceType: 'default' });
+    await flush();
+
+    const taskGroup = container.querySelector(
+      'section[aria-label="Review PRs"]',
+    );
+    expect(taskGroup).not.toBeNull();
+    expect(
+      taskGroup?.querySelector('[data-web-shell-scheduled-task-group]'),
+    ).not.toBeNull();
+    expect(taskGroup?.textContent).toContain('Review PRs · 08-31 09:30');
+    expect(taskGroup?.textContent).toContain('Review PRs · 08-31 08:30');
+    expect(
+      container.querySelector('section[aria-label="Ungrouped"]')?.textContent,
+    ).toContain('Ordinary session');
+    expect(
+      container.querySelector('section[aria-label="Ungrouped"]')?.textContent,
+    ).not.toContain('Review PRs ·');
+  });
+
+  it('forms the scheduled-task section while organization is enabled', async () => {
+    const sessions = [
+      {
+        sessionId: 'run-1',
+        displayName: 'Review PRs · 08-31 09:30',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+      },
+      {
+        sessionId: 'ordinary',
+        displayName: 'Ordinary session',
+        sourceType: 'default',
+      },
+    ] as DaemonSessionSummary[];
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessionsPage: vi.fn().mockResolvedValue({ sessions }),
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'default',
+      organizationEnabled: true,
+    });
+    await flush();
+
+    const taskGroup = container.querySelector(
+      'section[aria-label="Review PRs"]',
+    );
+    expect(taskGroup).not.toBeNull();
+    expect(
+      taskGroup?.querySelector('[data-web-shell-scheduled-task-group]'),
+    ).not.toBeNull();
+    expect(
+      container.querySelector('section[aria-label="Ungrouped"]')?.textContent,
+    ).toContain('Ordinary session');
+  });
+
+  it('keeps a manually grouped scheduled-task run under its manual group', async () => {
+    const sessions = [
+      {
+        sessionId: 'run-1',
+        displayName: 'Review PRs · 08-31 09:30',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+        groupId: 'manual-1',
+      },
+    ] as DaemonSessionSummary[];
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessionsPage: vi.fn().mockResolvedValue({ sessions }),
+        listSessionGroups: vi.fn().mockResolvedValue({
+          groups: [{ id: 'manual-1', name: 'My group', color: 'blue' }],
+        }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({
+      client,
+      expanded: true,
+      sourceType: 'default',
+      organizationEnabled: true,
+    });
+    await flush();
+
+    const manualGroup = container.querySelector(
+      'section[aria-label="My group"]',
+    );
+    expect(manualGroup).not.toBeNull();
+    expect(manualGroup?.textContent).toContain('Review PRs · 08-31 09:30');
+    expect(
+      container.querySelector('[data-web-shell-scheduled-task-group]'),
+    ).toBeNull();
+  });
+
+  it('keeps scheduled-task runs read-only in an untrusted workspace', async () => {
+    const sessions = [
+      {
+        sessionId: 'run-1',
+        displayName: 'Review PRs · 08-31 09:30',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+      },
+    ] as DaemonSessionSummary[];
+    const client = {
+      workspaceByCwd: vi.fn(() => ({
+        workspaceGit,
+        listWorkspaceSessionsPage: vi.fn().mockResolvedValue({ sessions }),
+        listSessionGroups: vi.fn().mockResolvedValue({ groups: [] }),
+      })),
+    } as unknown as DaemonClient;
+
+    renderSection({
+      client,
+      workspace: untrustedWorkspace,
+      expanded: true,
+      sourceType: 'default',
+    });
+    await flush();
+
+    expect(
+      container.querySelector('[data-web-shell-scheduled-task-group]'),
+    ).toBeNull();
+    const note = container.querySelector<HTMLElement>('[role="note"]');
+    expect(note).not.toBeNull();
+    expect(note?.getAttribute('aria-label')).toContain('Trust to open');
+  });
+
   it('shows five sessions and resets Show all after the workspace closes', async () => {
     const sessions = Array.from({ length: 6 }, (_, index) => ({
       sessionId: `session-${index + 1}`,
diff --git a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
index f73813b358c..4c2f8b68bb6 100644
--- a/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
+++ b/packages/web-shell/client/components/sidebar/WorkspaceSection.tsx
@@ -18,7 +18,11 @@ import type {
   DaemonWorkspaceCapability,
   DaemonWorkspaceGitStatus,
 } from '@qwen-code/sdk/daemon';
-import { FolderClosedIcon, FolderOpenIcon } from 'lucide-react';
+import {
+  CalendarClockIcon,
+  FolderClosedIcon,
+  FolderOpenIcon,
+} from 'lucide-react';
 import { GitBranchIndicator } from '../GitBranchIndicator';
 import { BranchPickerPopover } from '../BranchPickerPopover';
 import { useI18n } from '../../i18n';
@@ -45,6 +49,10 @@ import {
 } from './sessionSearch';
 import { useSessionContentSearch } from './useSessionContentSearch';
 import { measureSessionTitleScroll } from './sessionTitleScroll';
+import {
+  collectScheduledTaskSession,
+  type ScheduledTaskSessionSection,
+} from './scheduled-task-session-groups';
 import { groupSessionsByChannelType } from './channelSessionGroups';
 import { useWorkspaceOverview } from './useWorkspaceOverview';
 import { WorkspaceOverview } from './WorkspaceOverview';
@@ -644,23 +652,35 @@ export function WorkspaceSection({
       : visibleSessions.slice(0, SIDEBAR_SESSION_PREVIEW_LIMIT);
 
   const groupedSessions = useMemo(() => {
-    if (!organizationEnabled || channelGroupingEnabled || groups.length === 0)
-      return null;
+    // The grouped branch has no trust gate of its own; untrusted secondary
+    // workspaces keep the flat branch's read-only "trust to open" rows.
+    if (channelGroupingEnabled || readOnly) return null;
     const assigned = new Set<string>();
-    const sections = groups.map((group) => {
-      // Group sections derive from the search-filtered list, not the
-      // pinned-filtered one: pinned members are lifted into the Pinned
-      // section, but dropping them here rendered a group whose members are
-      // all pinned as `· 0`, indistinguishable from lost memberships
-      // (#10391).
-      const items = searchedSessions.filter(
-        (session) => session.groupId === group.id,
-      );
-      items.forEach((session) => assigned.add(session.sessionId));
-      return { group, sessions: items };
-    });
+    const sections = organizationEnabled
+      ? groups.map((group) => {
+          // Group sections derive from the search-filtered list, not the
+          // pinned-filtered one: pinned members are lifted into the Pinned
+          // section, but dropping them here rendered a group whose members are
+          // all pinned as `· 0`, indistinguishable from lost memberships
+          // (#10391).
+          const items = searchedSessions.filter(
+            (session) => session.groupId === group.id,
+          );
+          items.forEach((session) => assigned.add(session.sessionId));
+          return { group, sessions: items };
+        })
+      : [];
+    const scheduledSections = new Map<string, ScheduledTaskSessionSection>();
+    for (const session of searchedSessions) {
+      if (assigned.has(session.sessionId)) continue;
+      if (collectScheduledTaskSession(scheduledSections, session)) {
+        assigned.add(session.sessionId);
+      }
+    }
+    if (sections.length === 0 && scheduledSections.size === 0) return null;
     return {
       sections,
+      scheduledSections: [...scheduledSections.values()],
       // Pinned sessions without a group stay Pinned-section-only; they never
       // spill into Ungrouped.
       ungrouped: visibleSessions.filter(
@@ -671,6 +691,7 @@ export function WorkspaceSection({
     channelGroupingEnabled,
     groups,
     organizationEnabled,
+    readOnly,
     searchedSessions,
     visibleSessions,
   ]);
@@ -857,9 +878,12 @@ export function WorkspaceSection({
               // when the grouped view has nothing to render either.
               !(
                 groupedSessions &&
-                groupedSessions.sections.some(
+                (groupedSessions.sections.some(
                   (section) => section.sessions.length > 0,
-                )
+                ) ||
+                  groupedSessions.scheduledSections.some(
+                    (section) => section.sessions.length > 0,
+                  ))
               ) ? (
               // A source switch swaps the query key; until the new source's
               // page settles there is no data yet, so the "no sessions" notice
@@ -930,6 +954,29 @@ export function WorkspaceSection({
                     )}
                   </SessionGroupSection>
                 ))}
+                {groupedSessions.scheduledSections.map((section) => (
+                  <SessionGroupSection
+                    id={section.id}
+                    key={`${section.id}:${sourceType ?? ''}`}
+                    label={section.label}
+                    count={section.sessions.length}
+                    limitSessions={limitSessions && !searchActive}
+                    icon={
+                      <CalendarClockIcon data-web-shell-scheduled-task-group />
+                    }
+                    expanded={!collapsedGroupIds.has(section.id)}
+                    onToggle={() => {
+                      setCollapsedGroupIds((current) => {
+                        const next = new Set(current);
+                        if (next.has(section.id)) next.delete(section.id);
+                        else next.add(section.id);
+                        return next;
+                      });
+                    }}
+                  >
+                    {section.sessions.map((session) => renderSession(session))}
+                  </SessionGroupSection>
+                ))}
                 {groupedSessions.ungrouped.length > 0 && (
                   <SessionGroupSection
                     key={`ungrouped:${sourceType ?? ''}`}
diff --git a/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts b/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts
index dc88d68ee16..61d400ed3e0 100644
--- a/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts
+++ b/packages/web-shell/client/components/sidebar/collapsedSessionSections.ts
@@ -4,8 +4,10 @@
  * key so preferences survive reload without competing overwrites.
  *
  * Id conventions:
- * - Primary catalog: `group:<id>`, `recent`, `color:<name>`, `channel-type:<type>`
- * - Workspace-scoped: `ws:<workspaceId>|group:<id>`, `ws:<workspaceId>|ungrouped`
+ * - Primary catalog: `group:<id>`, `recent`, `color:<name>`,
+ *   `scheduled-task:<taskId>`, `channel-type:<type>`
+ * - Workspace-scoped: `ws:<workspaceId>|group:<id>` (including automatic
+ *   scheduled-task ids), `ws:<workspaceId>|ungrouped`
  */
 
 export const COLLAPSED_SESSION_SECTIONS_STORAGE_KEY =
diff --git a/packages/web-shell/client/components/sidebar/scheduled-task-session-groups.test.ts b/packages/web-shell/client/components/sidebar/scheduled-task-session-groups.test.ts
new file mode 100644
index 00000000000..981eae110ec
--- /dev/null
+++ b/packages/web-shell/client/components/sidebar/scheduled-task-session-groups.test.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+import type { DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+import {
+  collectScheduledTaskSession,
+  getScheduledTaskSessionGroup,
+} from './scheduled-task-session-groups';
+
+describe('getScheduledTaskSessionGroup', () => {
+  it('uses the task id and removes the generated run-time suffix', () => {
+    expect(
+      getScheduledTaskSessionGroup({
+        sessionId: 'run-1',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+        displayName: 'Review PRs · 08-31 09:30',
+      } as DaemonSessionSummary),
+    ).toEqual({
+      id: 'scheduled-task:task-1',
+      label: 'Review PRs',
+    });
+  });
+
+  it('falls back to the task id when the display name is missing or blank', () => {
+    expect(
+      getScheduledTaskSessionGroup({
+        sessionId: 'run-1',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+      } as DaemonSessionSummary),
+    ).toEqual({ id: 'scheduled-task:task-1', label: 'task-1' });
+    expect(
+      getScheduledTaskSessionGroup({
+        sessionId: 'run-1',
+        sourceType: 'default',
+        sourceId: 'scheduled_task_run:task-1',
+        displayName: '   ',
+      } as DaemonSessionSummary),
+    ).toEqual({ id: 'scheduled-task:task-1', label: 'task-1' });
+  });
+
+  it('does not group ordinary or malformed sessions', () => {
+    const base = { sessionId: 'run-1', sourceType: 'default' };
+    expect(
+      getScheduledTaskSessionGroup(base as DaemonSessionSummary),
+    ).toBeUndefined();
+    expect(
+      getScheduledTaskSessionGroup({
+        ...base,
+        sourceId: 'scheduled_task_run:',
+      } as DaemonSessionSummary),
+    ).toBeUndefined();
+    expect(
+      getScheduledTaskSessionGroup({
+        ...base,
+        sourceType: 'channel',
+        sourceId: 'scheduled_task_run:task-1',
+      } as DaemonSessionSummary),
+    ).toBeUndefined();
+  });
+});
+
+describe('collectScheduledTaskSession', () => {
+  const run = (sessionId: string, displayName: string) =>
+    ({
+      sessionId,
+      sourceType: 'default',
+      sourceId: 'scheduled_task_run:task-1',
+      displayName,
+    }) as DaemonSessionSummary;
+
+  it('prefers the generated task title over a rename regardless of collection order', () => {
+    const renamedFirst = new Map();
+    collectScheduledTaskSession(
+      renamedFirst,
+      run('run-1', 'Investigate flake'),
+    );
+    collectScheduledTaskSession(
+      renamedFirst,
+      run('run-2', 'Hourly review · 08-31 09:30'),
+    );
+    expect(renamedFirst.get('scheduled-task:task-1')?.label).toBe(
+      'Hourly review',
+    );
+    expect(
+      renamedFirst
+        .get('scheduled-task:task-1')
+        ?.sessions.map((s) => s.sessionId),
+    ).toEqual(['run-1', 'run-2']);
+
+    const generatedFirst = new Map();
+    collectScheduledTaskSession(
+      generatedFirst,
+      run('run-2', 'Hourly review · 08-31 09:30'),
+    );
+    collectScheduledTaskSession(
+      generatedFirst,
+      run('run-1', 'Investigate flake'),
+    );
+    expect(generatedFirst.get('scheduled-task:task-1')?.label).toBe(
+      'Hourly review',
+    );
+    expect(
+      generatedFirst
+        .get('scheduled-task:task-1')
+        ?.sessions.map((s) => s.sessionId),
+    ).toEqual(['run-2', 'run-1']);
+  });
+
+  it('treats a rename matching the suffix shape as a generated name', () => {
+    // Pins the known limit documented above SCHEDULED_TASK_RUN_TIME_SUFFIX
+    // in scheduled-task-session-groups.ts:
+    // shape-based classification cannot tell such a rename from a generated
+    // run name, so it outranks other renames and loses its suffix.
+    const sections = new Map();
+    collectScheduledTaskSession(sections, run('run-1', 'Investigate flake'));
+    collectScheduledTaskSession(
+      sections,
+      run('run-2', 'Follow-up · 08-31 09:30'),
+    );
+    expect(sections.get('scheduled-task:task-1')?.label).toBe('Follow-up');
+  });
+
+  it('keeps the first rename as the label when no run carries the generated shape', () => {
+    const sections = new Map();
+    collectScheduledTaskSession(sections, run('run-1', 'First rename'));
+    collectScheduledTaskSession(sections, run('run-2', 'Second rename'));
+    expect(sections.get('scheduled-task:task-1')?.label).toBe('First rename');
+    expect(sections.get('scheduled-task:task-1')?.sessions).toHaveLength(2);
+  });
+});
diff --git a/packages/web-shell/client/components/sidebar/scheduled-task-session-groups.ts b/packages/web-shell/client/components/sidebar/scheduled-task-session-groups.ts
new file mode 100644
index 00000000000..4cd955ecea8
--- /dev/null
+++ b/packages/web-shell/client/components/sidebar/scheduled-task-session-groups.ts
@@ -0,0 +1,77 @@
+import type { DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+
+// Mirrors `SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX` in
+// acp-bridge/session-source.ts. The client cannot import that package.
+const SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX = 'scheduled_task_run:';
+// Mirrors the time suffix appended by scheduledTaskRunSessionName in
+// cli/src/runtime/scheduled-task-run.ts; change both together.
+// Known limit: a user rename ending in this same shape is indistinguishable
+// from a generated run name here, so it is classified as generated (outranks
+// other renames, suffix stripped). Carrying the task title structurally —
+// persisted alongside the run — would remove the guesswork.
+const SCHEDULED_TASK_RUN_TIME_SUFFIX = / · \d{2}-\d{2} \d{2}:\d{2}$/u;
+
+export interface ScheduledTaskSessionGroupIdentity {
+  id: string;
+  label: string;
+}
+
+export interface ScheduledTaskSessionSection {
+  id: string;
+  label: string;
+  sessions: DaemonSessionSummary[];
+}
+
+function hasGeneratedRunName(session: DaemonSessionSummary): boolean {
+  const displayName = session.displayName?.trim();
+  return Boolean(
+    displayName && SCHEDULED_TASK_RUN_TIME_SUFFIX.test(displayName),
+  );
+}
+
+export function getScheduledTaskSessionGroup(
+  session: DaemonSessionSummary,
+): ScheduledTaskSessionGroupIdentity | undefined {
+  if (session.sourceType !== 'default') return undefined;
+  const sourceId = session.sourceId;
+  if (!sourceId?.startsWith(SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX)) {
+    return undefined;
+  }
+  const taskId = sourceId.slice(SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX.length);
+  if (!taskId) return undefined;
+  const displayName = session.displayName?.trim();
+  // The label recovers the task title from the run display name generated by
+  // scheduledTaskRunSessionName (cli/src/runtime/scheduled-task-run.ts),
+  // which caps the title at MAX_RUN_SESSION_NAME_LENGTH: long or unnamed
+  // tasks keep the producer's truncation and its trailing `…` here.
+  const label = displayName?.replace(SCHEDULED_TASK_RUN_TIME_SUFFIX, '').trim();
+  return {
+    id: `scheduled-task:${taskId}`,
+    label: label || taskId,
+  };
+}
+
+export function collectScheduledTaskSession(
+  sections: Map<string, ScheduledTaskSessionSection>,
+  session: DaemonSessionSummary,
+): boolean {
+  const group = getScheduledTaskSessionGroup(session);
+  if (!group) return false;
+  const section = sections.get(group.id);
+  if (section) {
+    // Prefer the task title carried by a generated display name over a user
+    // rename: runs are renameable, so first-wins would let the header flip
+    // between the title and a rename whenever the catalog order shifts
+    // (pinned rows sort first, the org-disabled path re-sorts by creation).
+    if (
+      hasGeneratedRunName(session) &&
+      !section.sessions.some(hasGeneratedRunName)
+    ) {
+      section.label = group.label;
+    }
+    section.sessions.push(session);
+  } else {
+    sections.set(group.id, { ...group, sessions: [session] });
+  }
+  return true;
+}