@qwen-code/web-shell 0.24.7 → 0.25.1-preview.0

package/dist/types/components/managed/java-managed-agent-client.d.ts

@@ -1,4 +1,5 @@
 import type { components } from './generated/managed-agent-api';
+import type { ManagedArtifact } from './managed-tool-result-types';
 type Schemas = components['schemas'];
 export type JavaAgentDate = number | string;
 export type JavaAgentTurn = Schemas['WebShellTurn'];
@@ -17,11 +18,14 @@ export type JavaAgentSessionPage = Omit<Schemas['WebShellSessionPage'], 'data'>
 };
 export type JavaAgentEvent = Schemas['WebShellEvent'];
 export type JavaAgentResyncRequired = Schemas['WebShellResyncRequired'];
+export declare const SKIP_ON_CORRUPT: ReadonlySet<string>;
 export declare function isJavaAgentResyncRequired(frame: JavaAgentEvent | JavaAgentResyncRequired): frame is JavaAgentResyncRequired;
 export type JavaAgentContentPart = Schemas['WebShellContentPart'];
 export type JavaAgentItem = Schemas['WebShellItem'];
 export type JavaAgentCommandAdmission = Schemas['WebShellAdmission'];
 export type JavaAgentTranscript = Schemas['WebShellTranscript'];
+export type JavaAgentAction = Schemas['WebShellAction'];
+export type JavaAgentActionPage = Schemas['WebShellActionPage'];
 export interface JavaManagedAgentClientOptions {
     baseUrl: string;
     getHeaders?: () => HeadersInit | Promise<HeadersInit>;
@@ -52,7 +56,29 @@ export declare class JavaManagedAgentClient {
     createSession(request: Schemas['WebShellCreateRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
-    streamEvents(request: Schemas['WebShellStreamRequest'], signal?: AbortSignal): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
+    queryActions(request: Schemas['WebShellActionQueryRequest'], signal?: AbortSignal): Promise<JavaAgentActionPage>;
+    respondAction(request: Schemas['WebShellActionRespondRequest'], signal?: AbortSignal): Promise<Schemas['WebShellCommandOperation']>;
+    getToolResult(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
+        result: components["schemas"]["PublicToolResult"];
+        access: components["schemas"]["ArtifactAccess"];
+    }>;
+    listArtifacts(request: {
+        sessionId: string;
+        cursor?: string;
+        limit?: number;
+    }, signal?: AbortSignal): Promise<{
+        data: components["schemas"]["ArtifactResponse"][];
+        nextCursor: string | null;
+        hasMore: boolean;
+    }>;
+    getArtifact(sessionId: string, artifactId: string, signal?: AbortSignal): Promise<{
+        artifact: components["schemas"]["PublicArtifact"];
+        access: components["schemas"]["ArtifactAccess"];
+    }>;
+    readArtifactRange(artifact: ManagedArtifact, offset: number, length: number, signal?: AbortSignal): Promise<Uint8Array>;
+    openArtifactStream(artifact: ManagedArtifact, signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+    private artifactContent;
+    streamEvents(request: Schemas['WebShellStreamRequest'], signal?: AbortSignal, onOpen?: () => void): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
     private post;
     private request;
 }

package/dist/types/components/managed/java-managed-agent-provider.d.ts

@@ -1,9 +1,13 @@
 import { type JavaManagedAgentClientOptions } from './java-managed-agent-client';
+import type { ManagedArtifactSave } from './managed-tool-result-types';
 import type { ManagedAgentProvider } from './managed-agent-provider';
 export interface JavaManagedAgentProviderOptions extends JavaManagedAgentClientOptions {
     agentId?: string;
     environmentId?: string;
+    /** Include tenant and actor identity; replace this scope/provider when either changes. Token refresh alone can use getHeaders. */
     productScope?: string;
     enableWorkspaceBinding?: boolean;
+    /** Acquire a streaming save target during the user gesture, then call openStream. */
+    saveArtifact?: ManagedArtifactSave;
 }
 export declare function createJavaManagedAgentProvider(options: JavaManagedAgentProviderOptions): ManagedAgentProvider;

package/dist/types/components/managed/managed-agent-provider.d.ts

@@ -1,3 +1,5 @@
+import type { components } from './generated/managed-agent-api';
+import type { ManagedToolResultReader } from './managed-tool-result-types';
 export type ManagedAgentSessionPhase = 'created' | 'admitted' | 'runtime_starting' | 'agent_running' | 'waiting_runtime' | 'tool_running' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
 export type ManagedAgentRuntimeState = 'unknown' | 'starting' | 'ready' | 'failed';
 export interface ManagedAgentSessionSummary {
@@ -18,13 +20,17 @@ export interface ManagedAgentSessionSummary {
     capabilities: {
         canSend: boolean;
         canCancel: boolean;
+        actions?: boolean;
+        artifacts?: boolean;
+        /** The caller may submit later Turns to this Workspace-bound Session. */
+        workspaceTurns?: boolean;
     };
     failure?: {
         code: string;
         message: string;
     };
 }
-export type ManagedAgentSessionEventType = 'accepted' | 'runtime_starting' | 'runtime_ready' | 'runtime_failed' | 'runtime_released' | 'agent_started' | 'assistant_thought' | 'assistant_delta' | 'tool_requested' | 'tool_started' | 'tool_completed' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'stream_gap';
+export type ManagedAgentSessionEventType = 'accepted' | 'runtime_starting' | 'runtime_ready' | 'runtime_failed' | 'runtime_released' | 'agent_started' | 'assistant_thought' | 'assistant_delta' | 'tool_requested' | 'tool_started' | 'tool_completed' | 'tool_result_updated' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'action_updated' | 'stream_gap';
 export interface ManagedAgentSessionEvent {
     id: number;
     at: number;
@@ -32,6 +38,12 @@ export interface ManagedAgentSessionEvent {
     sessionId: string;
     turnId: string;
     data?: unknown;
+    /**
+     * Projected from a durable snapshot item rather than a raw event. The
+     * server can retract its items (reconciliation), after which these
+     * projections must not survive a resync.
+     */
+    assembledFromItem?: boolean;
 }
 export interface ManagedAgentSessionTranscript {
     events: ManagedAgentSessionEvent[];
@@ -49,11 +61,34 @@ export interface ManagedAgentRequestOptions {
 export interface ManagedAgentCommandOptions extends ManagedAgentRequestOptions {
     idempotencyKey: string;
 }
+/** A Hosted tool approval waiting for the Session owner's answer. */
+export interface ManagedAgentPendingAction {
+    actionId: string;
+    sessionId: string;
+    /** Public Turn ID; absent when the Turn could not be resolved. */
+    turnId?: string;
+    functionCallId: string;
+    toolName: string;
+    inputRevision: number;
+    policyRevision: string;
+    expiresAt: number;
+    options: Array<{
+        id: string;
+        label: string;
+    }>;
+    inputPreview?: components['schemas']['WebShellActionInputPreview'];
+}
 export interface ManagedAgentProvider {
     readonly kind: 'daemon' | 'java';
     readonly storageKey: string;
     readonly canCancel: boolean;
     readonly acceptsWorkspaceCwd: boolean;
+    /** Present when the provider can serve Hosted permission Actions. */
+    readonly actions?: {
+        listPending(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentPendingAction[]>;
+        respond(action: ManagedAgentPendingAction, optionId: string, options: ManagedAgentCommandOptions): Promise<void>;
+    };
+    readonly toolResults?: ManagedToolResultReader;
     readonly workspaceBinding?: {
         readonly agentId: string;
         list(options: ManagedAgentRequestOptions & {
@@ -97,6 +132,13 @@ export interface ManagedAgentProvider {
     cancel(sessionId: string, turnId: string, options: ManagedAgentCommandOptions): Promise<void>;
     subscribeEvents(sessionId: string, options: ManagedAgentRequestOptions & {
         lastEventId?: number;
+        /**
+         * Called once the stream connection has been (re-)established. An
+         * established stream can stay silent indefinitely — heartbeats are
+         * not events — so this is the only liveness signal that does not
+         * depend on stream activity.
+         */
+        onEstablished?(): void;
     }): AsyncIterable<ManagedAgentSessionEvent>;
 }
 export interface ManagedAgentWorkspace {

package/dist/types/components/managed/managed-agent-sse.test-fixtures.d.ts

@@ -0,0 +1,8 @@
+export declare function javaDeltaEvent(sequence: number, text: string): string;
+/** A complete item.output_text.delta SSE frame. */
+export declare function sseFrame(sequence: number, text: string): string;
+/** A complete item.output_text.delta SSE frame with an empty data object. */
+export declare function validEventFrame(sequence: number): string;
+/** A well-formed SSE frame whose data payload is truncated JSON. */
+export declare function corruptFrame(sequence: number, name?: string): string;
+export declare function javaSessionPayload(lastSequence: number): string;

package/dist/types/components/managed/managed-approval.d.ts

@@ -0,0 +1,10 @@
+import type { ACPToolCall, Message, PermissionRequest } from '../../adapters/types';
+import type { ManagedAgentPendingAction } from './managed-agent-provider';
+/**
+ * Finds the transcript tool that a pending Action asks about. Managed tool
+ * rows are keyed `${turnId}:${toolCallId}`, and the Action's functionCallId is
+ * that tool call ID; without a resolved Turn only the call ID can match.
+ */
+export declare function findManagedApprovalTool(messages: readonly Message[], action: ManagedAgentPendingAction): ACPToolCall | undefined;
+/** Presents a pending Hosted approval through the shared approval card. */
+export declare function toManagedPermissionRequest(action: ManagedAgentPendingAction, messages: readonly Message[]): PermissionRequest;

package/dist/types/components/managed/managed-artifact-download.d.ts

@@ -0,0 +1,2 @@
+import type { ManagedArtifactSave } from './managed-tool-result-types';
+export declare function browserArtifactSave(): ManagedArtifactSave | undefined;

package/dist/types/components/managed/managed-request-error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Whether the service answered a request in a way a retry cannot change.
+ *
+ * A 4xx other than a timeout (408) or a rate limit (429) is an answer, not a
+ * hiccup: a deleted Session or an unknown Action replies the same way however
+ * often it is asked, so retrying only burns requests. Timeouts and rate limits
+ * are worth another attempt.
+ */
+export declare function isNonRetryableClientError(error: unknown): boolean;

package/dist/types/components/managed/managed-tool-result-types.d.ts

@@ -0,0 +1,24 @@
+import type { components } from './generated/managed-agent-api';
+import type { ManagedAgentRequestOptions } from './managed-agent-provider';
+type Schemas = components['schemas'];
+export type ManagedToolResult = Schemas['PublicToolResult'];
+export type ManagedArtifact = Schemas['PublicArtifact'];
+export type ManagedToolResultResponse = Schemas['ToolResultResponse'];
+export type ManagedArtifactResponse = Schemas['ArtifactResponse'];
+export type ManagedArtifactPage = Schemas['WebShellArtifactPage'];
+export type ManagedArtifactSave = (artifact: ManagedArtifact, options: {
+    signal?: AbortSignal;
+    openStream: () => Promise<ReadableStream<Uint8Array>>;
+}) => Promise<void>;
+export interface ManagedToolResultReader {
+    readonly canDownload: boolean;
+    getResult(sessionId: string, itemId: string, options: ManagedAgentRequestOptions): Promise<ManagedToolResultResponse>;
+    listArtifacts(sessionId: string, options: ManagedAgentRequestOptions & {
+        cursor?: string;
+        limit?: number;
+    }): Promise<ManagedArtifactPage>;
+    getArtifact(sessionId: string, artifactId: string, options: ManagedAgentRequestOptions): Promise<ManagedArtifactResponse>;
+    readRange(artifact: ManagedArtifact, offset: number, length: number, options: ManagedAgentRequestOptions): Promise<Uint8Array>;
+    downloadArtifact(artifact: ManagedArtifact, options: ManagedAgentRequestOptions): Promise<void>;
+}
+export {};

package/dist/types/components/managed/managed-tool-result.test-fixtures.d.ts

@@ -0,0 +1,6 @@
+import type { ManagedArtifact, ManagedToolResult } from './managed-tool-result-types';
+export declare const artifact: ManagedArtifact;
+export declare const result: ManagedToolResult;
+export declare const notStartedResult: ManagedToolResult;
+export declare const blockedResult: ManagedToolResult;
+export declare const previewOnlyResult: ManagedToolResult;

package/dist/types/components/managed/use-managed-actions.d.ts

@@ -0,0 +1,33 @@
+import type { ManagedAgentPendingAction, ManagedAgentProvider, ManagedAgentSessionEvent } from './managed-agent-provider';
+export interface ManagedActionsState {
+    /** The approval to show; answered ones stay hidden while they settle. */
+    action?: ManagedAgentPendingAction;
+    /** Reading the pending approvals failed; retries run in the background. */
+    loadError?: unknown;
+    /**
+     * The pending approvals have been read for this Session, so a failed read is
+     * a failed refresh of what the page already shows rather than an empty list.
+     */
+    loaded: boolean;
+    /** Sending an answer failed; the approval is shown again. */
+    answerError?: unknown;
+    /**
+     * The service refused an answer as creator-only. That is a fact about the
+     * viewer and the Session, not about one Action, so it outlives the refused
+     * Action, covers every later approval the same Session raises, and survives
+     * leaving that Session and coming back. It is remembered per mount: a reload
+     * or reopening the panel starts clean.
+     */
+    respondForbidden: boolean;
+    respond(actionId: string, optionId: string): Promise<void>;
+    /** Reads the pending approvals again now. */
+    retry(): void;
+}
+/**
+ * Loads a Session's pending Hosted approvals and answers them. It re-reads
+ * when the transcript reports an approval change or a reconciled gap, when an
+ * approval expires, and after an answer. `enabled` is undefined while the
+ * Session summary is unknown, for example during a reload: the shown approval
+ * stays and can be answered, and reads resume once the capability is known.
+ */
+export declare function useManagedActions(provider: ManagedAgentProvider, sessionId: string | undefined, clientId: string, enabled: boolean | undefined, events: readonly ManagedAgentSessionEvent[]): ManagedActionsState;

package/dist/types/components/messages/AssistantMessage.d.ts

@@ -1,7 +1,9 @@
 import { type WebShellAssistantFeedbackRating, type WebShellAssistantTurnFooterRenderInfo, type WebShellSource } from '../../customization';
 import type { DaemonSessionGenerationEvent } from '@qwen-code/sdk/daemon';
+import type { DaemonMessageAuthor } from '../../adapters/messageTypes';
 interface AssistantMessageProps {
     content: string;
+    author?: DaemonMessageAuthor;
     isStreaming?: boolean;
     timestamp?: number;
     onBranchSession?: () => void | Promise<void>;
@@ -19,6 +21,7 @@ interface AssistantMessageProps {
 export declare const AssistantMessage: import("react").NamedExoticComponent<AssistantMessageProps>;
 interface ThinkingMessageProps {
     content: string;
+    author?: DaemonMessageAuthor;
     isStreaming?: boolean;
     timestamp?: number;
     isLocateFlashing?: boolean;

package/dist/types/components/messages/AuthorAvatar.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The initial of a named assistant voice, tinted with its color when it has
+ * one. The same mark stands for an agent in its replies, the Team panel and
+ * the Agents page, so a reader learns it once.
+ */
+export declare function AuthorAvatar({ name, color, size, className, }: {
+    name: string;
+    color?: string;
+    size?: 'sm' | 'md';
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/ContextUsageMessage.d.ts

@@ -1,6 +1,10 @@
 import type { DaemonSessionContextUsageStatus } from '@qwen-code/web-shell/daemon-react-sdk';
+export declare function createContextUsageMessageData(status: DaemonSessionContextUsageStatus): {
+    type: string;
+    status: DaemonSessionContextUsageStatus;
+};
 export declare function serializeContextUsageMessage(status: DaemonSessionContextUsageStatus): string;
-export declare function parseContextUsageMessage(content: string): DaemonSessionContextUsageStatus | null;
+export declare function parseContextUsageMessage(content: string, data?: unknown): DaemonSessionContextUsageStatus | null;
 export declare function ContextUsageMessage({ status, onShowDetail, compact, }: {
     status: DaemonSessionContextUsageStatus;
     /** Run /context detail, exactly like typing it. */

package/dist/types/components/messages/StatsMessage.d.ts

@@ -4,8 +4,13 @@ interface ParsedStats {
     view: StatsView;
     status: DaemonSessionStatsStatus;
 }
+export declare function createStatsMessageData(status: DaemonSessionStatsStatus, view?: StatsView): {
+    type: string;
+    view: StatsView;
+    status: DaemonSessionStatsStatus;
+};
 export declare function serializeStatsMessage(status: DaemonSessionStatsStatus, view?: StatsView): string;
-export declare function parseStatsMessage(content: string): ParsedStats | null;
+export declare function parseStatsMessage(content: string, data?: unknown): ParsedStats | null;
 export declare function formatDuration(ms: number): string;
 export declare function StatsMessage({ view, status, }: {
     view: StatsView;

package/dist/types/components/messages/ToolApproval.d.ts

@@ -16,6 +16,14 @@ interface ToolApprovalProps {
      * it — it just never grabs focus on its own.
      */
     keyboardActive?: boolean;
+    /**
+     * Id of an extra description the caller renders beside this panel, added to
+     * `aria-describedby`. The Managed approvals card states there that the tool
+     * arguments are unavailable, which is exactly the case where the panel's own
+     * description (tool name only) would let a screen-reader user confirm blind.
+     * Pass it only while that element is mounted, so no IDREF dangles.
+     */
+    extraDescriptionId?: string;
     planTodos?: readonly TodoItem[];
     planExecutionMode?: string;
     generateContent?: SessionContentGenerator;
@@ -24,5 +32,5 @@ export declare function parseTitle(title?: string): {
     toolName: string;
     description: string;
 };
-export declare function ToolApproval({ request, onConfirm, variant, disabled, keyboardActive, planTodos, planExecutionMode, generateContent, }: ToolApprovalProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToolApproval({ request, onConfirm, variant, disabled, keyboardActive, extraDescriptionId, planTodos, planExecutionMode, generateContent, }: ToolApprovalProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/messages/ToolGroup.d.ts

@@ -19,6 +19,7 @@ interface ToolGroupProps {
     pendingApproval?: PermissionRequest | null;
     workspaceCwd?: string;
     onTurnOutputOpen?: (request: TurnOutputOpenRequest) => void;
+    onToolResultOpen?: (itemId: string) => void;
     isLocateFlashing?: boolean;
     /** Powers the translate action on completed thinking rows (zh-CN). */
     generateContent?: SessionContentGenerator;
@@ -32,6 +33,7 @@ interface ToolLineProps {
     approval?: PermissionRequest | null;
     workspaceCwd?: string;
     onTurnOutputOpen?: (request: TurnOutputOpenRequest) => void;
+    onToolResultOpen?: (itemId: string) => void;
     summaryOnly?: boolean;
     forceExpanded?: boolean;
     detailsVisible?: boolean;

package/dist/types/components/sidebar/UpdateControl.d.ts

@@ -5,6 +5,8 @@ interface UpdateControlProps {
     currentVersion: string;
     onError: (error: unknown, fallback: string) => void;
     onRestarted?: (url: string) => void;
+    /** Keep background update/restart polling alive when the menu closes. */
+    portalContainer?: HTMLElement | null;
 }
-export declare function UpdateControl({ client, collapsed, currentVersion, onError, onRestarted, }: UpdateControlProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function UpdateControl({ client, collapsed, currentVersion, onError, onRestarted, portalContainer, }: UpdateControlProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/types/components/sidebar/WebShellSidebar.d.ts

@@ -2,11 +2,12 @@ import { type ReactNode } from 'react';
 import { type DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
 import { type WebShellTheme } from '../../themeContext';
 import { type WorkspaceManagementTarget, type WorkspaceOverviewItem } from './workspaceOverviewModel';
+export declare const SIDEBAR_RAIL_WIDTH = 56;
 export type WebShellSidebarFooterItem = 'settings' | 'update' | 'version' | 'theme' | 'sessionsOverview' | 'workspacesOverview' | 'splitView' | 'daemonStatus' | 'localFiles' | 'desktopRelay' | 'collapse';
 export interface WebShellSidebarBranding {
     /** Replace the complete top branding row. */
     render?: () => ReactNode;
-    /** Hide the branding row in the compact drawer. Defaults to true. */
+    /** Hide the branding row in the compact drawer. Defaults to false. */
     hideWhenCompact?: boolean;
 }
 export interface WebShellSidebarLockedWorkspace {
@@ -15,9 +16,9 @@ export interface WebShellSidebarLockedWorkspace {
         expanded: boolean;
     }) => ReactNode;
 }
-export type WebShellSidebarPrimaryNavItem = 'newTask' | 'plugins' | 'channels' | 'scheduledTasks' | 'workflows' | 'goals' | 'managed';
+export type WebShellSidebarPrimaryNavItem = 'newTask' | 'agents' | 'plugins' | 'channels' | 'live' | 'scheduledTasks' | 'workflows' | 'goals' | 'managed';
 export interface WebShellSidebarPrimaryNavOptions {
-    /** Built-in primary nav entries to show. Defaults to all. */
+    /** Built-in primary nav entries to show. Embedded hosts default to New task only. */
     items?: readonly WebShellSidebarPrimaryNavItem[];
     /** Additional custom content rendered after the built-in nav buttons. */
     render?: () => ReactNode;
@@ -28,6 +29,9 @@ export interface WebShellSidebarFooterOptions {
     /** Additional custom content rendered before the built-in footer items (left side). */
     render?: () => ReactNode;
 }
+export declare const DEFAULT_FOOTER_ITEMS: readonly WebShellSidebarFooterItem[];
+export declare const DESKTOP_DEFAULT_FOOTER_ITEMS: readonly WebShellSidebarFooterItem[];
+export declare const DEFAULT_PRIMARY_NAV_ITEMS: readonly WebShellSidebarPrimaryNavItem[];
 export type WebShellSidebarSessionActionItem = 'details' | 'rename' | 'group' | 'export' | 'delete' | 'pin' | 'archive';
 /** Subset of action items that have working inline (hover-button) handlers. */
 export type WebShellSidebarSessionInlineActionItem = 'pin' | 'rename' | 'export' | 'delete';
@@ -54,11 +58,20 @@ export interface WebShellSidebarWorkspaceOverviewOptions {
 }
 export type { WorkspaceManagementTarget, WorkspaceOverviewItem };
 interface WebShellSidebarProps {
+    selectedCollaborationId?: string;
+    onOpenCollaboration?: (id: string, cwd: string) => void;
     collapsed: boolean;
+    layout?: 'single' | 'rail';
+    activePage?: string;
+    containerWidth?: number;
+    onOpenHome?: () => void;
     onCollapsedChange: (collapsed: boolean) => void;
     onOpenSettings: () => void;
+    onOpenAgents?: (view?: 'agents' | 'tasks' | 'runtime') => void;
     onOpenPlugins: () => void;
     onOpenChannels: () => void;
+    onOpenLive?: () => void;
+    onLiveVoiceSlotChange?: (element: HTMLDivElement | null) => void;
     onOpenManagedSessions?: () => void;
     onOpenDaemonStatus: () => void;
     onOpenScheduledTasks: () => void;
@@ -120,7 +133,7 @@ interface WebShellSidebarProps {
     primaryNav?: WebShellSidebarPrimaryNavOptions;
     /** Whether to show the Tasks/Channels session-source switch. Defaults to true. */
     showSessionSourceSwitch?: boolean;
-    /** Whether to show daemon-owned Live conversations. Defaults to false. */
+    /** Show Live conversations and, in rail layout, the Live entry. Defaults to false. */
     showLive?: boolean;
     /** Whether to hide the "Projects" header row (with search and add workspace). Defaults to false (shown). */
     hideProjectHeader?: boolean;
@@ -145,4 +158,4 @@ interface WebShellSidebarProps {
     onLoadStandaloneSession?: (sessionId: string) => Promise<void> | void;
     onStandaloneNotice?: (message: string) => void;
 }
-export declare function WebShellSidebar({ collapsed, onCollapsedChange, onOpenSettings, onOpenPlugins, onOpenChannels, onOpenManagedSessions, onOpenDaemonStatus, onOpenScheduledTasks, onOpenWorkflows, onOpenGoals, onOpenSessions, canOpenSessionsOverview, onOpenWorkspacesOverview, onOpenSplitView, canOpenSplitView, onNewSession, onNewStandaloneSession, onLoadSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;
+export declare function WebShellSidebar({ selectedCollaborationId, onOpenCollaboration, collapsed, layout, activePage, containerWidth, onOpenHome, onCollapsedChange, onOpenSettings, onOpenAgents, onOpenPlugins, onOpenChannels, onOpenLive, onLiveVoiceSlotChange, onOpenManagedSessions, onOpenDaemonStatus, onOpenScheduledTasks, onOpenWorkflows, onOpenGoals, onOpenSessions, canOpenSessionsOverview, onOpenWorkspacesOverview, onOpenSplitView, canOpenSplitView, onNewSession, onNewStandaloneSession, onLoadSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/sidebar/WorkspaceSection.d.ts

@@ -9,9 +9,11 @@ export interface WorkspaceHeaderActionsContext {
     gitBranch: string | null | undefined;
 }
 interface WorkspaceSectionProps {
+    additionalSessions?: readonly DaemonSessionSummary[];
     workspace: DaemonWorkspaceCapability;
     remote?: boolean;
     renderHeader?: (expanded: boolean) => ReactNode;
+    hideHeader?: boolean;
     client: DaemonClient;
     reloadToken: number;
     untrustedLabel: string;
@@ -116,5 +118,5 @@ interface WorkspaceSectionProps {
     /** Commit entry for the same picker; the row still opens without it. */
     onOpenCommit?: (workspaceCwd: string) => void;
 }
-export declare function WorkspaceSection({ workspace, remote, renderHeader, client, reloadToken, untrustedLabel, readOnlyLabel, trustToOpenLabel, noSessionsLabel, loadErrorLabel, organizationEnabled, sessionCatalogRequestsEnabled, sessionGroupCatalog, sessionLiveStateEnabled, sourceType, channelGroupingEnabled, ungroupedLabel, searchQuery, expanded: controlledExpanded, autoExpandKey, forceAutoExpand, onExpandedChange, renderSessions, renderSession, pendingSession, mapSession, showSessionDetails, headerActions, overviewEnabled, overviewMenuOpen, overviewItems, gitBranchWanted, sessionStats, onRenameGroup, onDeleteGroup, renameGroupLabel, deleteGroupLabel, groupActionsDisabled, excludePinned, limitSessions, isPinnedSectionMember, onOpenPathLocally, onOpenTerminalLocally, onOpenGitDiff, onOpenCommit, }: WorkspaceSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function WorkspaceSection({ additionalSessions, workspace, remote, renderHeader, hideHeader, client, reloadToken, untrustedLabel, readOnlyLabel, trustToOpenLabel, noSessionsLabel, loadErrorLabel, organizationEnabled, sessionCatalogRequestsEnabled, sessionGroupCatalog, sessionLiveStateEnabled, sourceType, channelGroupingEnabled, ungroupedLabel, searchQuery, expanded: controlledExpanded, autoExpandKey, forceAutoExpand, onExpandedChange, renderSessions, renderSession, pendingSession, mapSession, showSessionDetails, headerActions, overviewEnabled, overviewMenuOpen, overviewItems, gitBranchWanted, sessionStats, onRenameGroup, onDeleteGroup, renameGroupLabel, deleteGroupLabel, groupActionsDisabled, excludePinned, limitSessions, isPinnedSectionMember, onOpenPathLocally, onOpenTerminalLocally, onOpenGitDiff, onOpenCommit, }: WorkspaceSectionProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/sidebar/sessionSearch.d.ts

@@ -8,7 +8,8 @@ export declare function sessionMatchesGitQuery(session: DaemonSessionSummary, qu
 /**
  * The sidebar's session-source scope: the "channel" tab lists only
  * channel-source sessions, the "default" tab lists unattributed (legacy)
- * and default/Qwen Live tasks, and no filter lists everything.
+ * and default/Qwen Live tasks, every other source lists exact matches, and
+ * no filter lists everything.
  */
 export declare function sessionMatchesSource(session: DaemonSessionSummary, source: string | undefined): boolean;
 /**

package/dist/types/components/workspace-agents/LazyThreadsRoute.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ThreadsRouteProps } from './ThreadsRoute';
+export declare function LazyThreadsRoute(props: ThreadsRouteProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/ThreadChat.d.ts

@@ -0,0 +1,35 @@
+import { type ThreadDetailView } from './ThreadView';
+import { type RoutingPreviewTarget } from './agents-view-logic';
+interface AgentEntry {
+    id: string;
+    name: string;
+    color?: string;
+    enabled: boolean;
+    retiredAt?: number;
+    status?: string;
+    runtime?: {
+        label: string;
+        status: string;
+    };
+}
+export declare function ThreadChat({ thread, agents, preview, pending, onSend, onDraftChange, onOpenAgentSession, onCancelRun, onMarkDone, onOpenThread, onRespondPermission, onAssign, onBack, activityOnly, onOpenActivity, headerActionsContainer, }: {
+    headerActionsContainer?: HTMLElement | null;
+    activityOnly?: boolean;
+    onOpenActivity?: () => void;
+    preview?: readonly RoutingPreviewTarget[];
+    agents: readonly AgentEntry[];
+    thread: ThreadDetailView;
+    pending: boolean;
+    onSend: (text: string) => Promise<boolean>;
+    onDraftChange: (text: string) => void;
+    onOpenAgentSession?: (sessionId: string) => void;
+    onCancelRun: (runId: string) => void;
+    onMarkDone: () => void;
+    onOpenThread: (threadId: string) => void;
+    onRespondPermission?: (sessionId: string, requestId: string, optionId: string) => Promise<unknown>;
+    /** Hands the conversation to another agent. */
+    onAssign?: (assignee?: string) => void;
+    /** Shown when the conversation is not in the shell's own chat column. */
+    onBack?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/workspace-agents/ThreadView.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type RunRow, type RunView } from './agents-view-logic';
+export interface ThreadPostView {
+    sourceRunId?: string;
+    id: string;
+    sequence: number;
+    authorKind: 'human' | 'agent' | 'system';
+    authorName: string;
+    authorDeleted?: boolean;
+    text: string;
+    at: number;
+    outcomes?: readonly {
+        agentName?: string;
+        kind: 'dispatch' | 'coalesce' | 'skip';
+        reason?: string;
+        into?: 'queued' | 'running';
+    }[];
+}
+export interface ThreadDetailView {
+    id: string;
+    title: string;
+    body: string;
+    /** What "done" means here, in the author's words. */
+    acceptanceCriteria?: string;
+    priority?: 'urgent' | 'high' | 'normal' | 'low';
+    parent?: {
+        id: string;
+        title: string;
+    };
+    assigneeName?: string;
+    status: 'open' | 'in_progress' | 'blocked' | 'in_review' | 'done' | 'cancelled';
+    /** The resolver's sentence. Rendered verbatim. */
+    reason: string;
+    posts: readonly ThreadPostView[];
+    runs: readonly RunView[];
+    children?: readonly ThreadChildView[];
+    budget: {
+        turnsUsed: number;
+        turnLimit: number;
+        tokensUsed: number;
+        tokenLimit: number;
+    };
+}
+export interface ThreadChildView {
+    id: string;
+    title: string;
+    status: ThreadDetailView['status'];
+    reason: string;
+    assigneeName?: string;
+}
+/**
+ * One run: its state, how long it has gone, and what it is doing, with the
+ * thinking and output so far folded under it. Under a member in the Team
+ * panel the member row already names the agent, so `hideAgent` drops it.
+ */
+export declare function RunRowView({ row, agent, hideAgent, onOpenAgentSession, onCancelRun, }: {
+    row: RunRow;
+    agent?: {
+        status?: string;
+        runtime?: {
+            label: string;
+            status: string;
+        };
+    };
+    hideAgent?: boolean;
+    onOpenAgentSession?: (sessionId: string) => void;
+    onCancelRun?: (runId: string) => void;
+}): import("react/jsx-runtime").JSX.Element;