@qwen-code/web-shell 0.25.1 → 0.25.2-nightly.20261016.b4614845f0

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

@@ -52,15 +52,91 @@ export declare class JavaManagedAgentClient {
         canCreateSession: boolean;
         state: "active" | "draining" | "removed";
     }>;
+    listRuntimeNodes(signal?: AbortSignal): Promise<{
+        supported: boolean;
+        data: components["schemas"]["WebShellRuntimeNode"][];
+    }>;
+    checkWorkspaceDirectory(request: Schemas['WebShellWorkspaceDirectoryRequest'], signal?: AbortSignal): Promise<{
+        nodeId: string;
+        canonicalPath: string;
+        platform: "linux" | "darwin";
+    }>;
+    registerWorkspace(request: Schemas['WebShellWorkspaceRegisterRequest'], signal?: AbortSignal): Promise<{
+        operationId: string;
+        type: "workspace_create";
+        status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
+        workspaceId?: string | null;
+        failureCode?: string | null;
+        replayed: boolean;
+    }>;
+    getWorkspaceOperation(operationId: string, signal?: AbortSignal): Promise<{
+        operationId: string;
+        type: "workspace_create";
+        status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
+        workspaceId?: string | null;
+        failureCode?: string | null;
+        replayed: boolean;
+    }>;
+    createWorkspace(request: Schemas['WebShellWorkspaceCreateRequest'], signal?: AbortSignal): Promise<JavaAgentWorkspace>;
+    getSessionApproval(sessionId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionApproval']>;
+    changeApproval(request: Schemas['WebShellChangeApprovalRequest'], signal?: AbortSignal): Promise<Schemas['WebShellApprovalChangeResult']>;
+    getSessionOptions(agentId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionOptions']>;
     getTranscript(request: Schemas['WebShellTranscriptRequest'], signal?: AbortSignal): Promise<JavaAgentTranscript>;
     createSession(request: Schemas['WebShellCreateRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     queryActions(request: Schemas['WebShellActionQueryRequest'], signal?: AbortSignal): Promise<JavaAgentActionPage>;
+    listTasks(request: Schemas['WebShellTaskQueryRequest'], signal?: AbortSignal): Promise<{
+        data: components["schemas"]["WebShellTask"][];
+        hasMore: boolean;
+        nextCursor?: string | null;
+    }>;
+    getTask(request: Schemas['WebShellTaskGetRequest'], signal?: AbortSignal): Promise<{
+        taskId: string;
+        sessionId: string;
+        kind: components["schemas"]["TaskKind"];
+        state: components["schemas"]["TaskState"];
+        definitionRevision?: number;
+        runtimeState?: components["schemas"]["TaskRuntimeState"];
+        createdAt: number;
+        startedAt?: number;
+        settledAt?: number;
+        outputCursor?: string;
+        artifactRefs: string[];
+        actionCapabilities: components["schemas"]["TaskActionCapability"][];
+    }>;
+    listTaskEvents(request: Schemas['WebShellTaskEventQueryRequest'], signal?: AbortSignal): Promise<{
+        data: components["schemas"]["WebShellTaskEvent"][];
+        hasMore: boolean;
+        nextCursor: string;
+    }>;
+    cancelTask(request: Schemas['WebShellTaskCancelRequest'], signal?: AbortSignal): Promise<{
+        operationId: string;
+        sessionId: string;
+        type: "create_session" | "submit_input" | "cancel" | "action_response" | "close" | "archive" | "delete" | "task_cancel";
+        taskId?: string;
+        status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
+        admissionStage: "java_durable" | "harness_confirmed";
+        deliveryState: "pending" | "leased" | "confirmed" | "blocked";
+        receiptId?: string;
+        actionResolution?: components["schemas"]["WebShellActionResolution"];
+        failureCode?: string;
+        replayed: boolean;
+    }>;
     respondAction(request: Schemas['WebShellActionRespondRequest'], signal?: AbortSignal): Promise<Schemas['WebShellCommandOperation']>;
     /** Reads an operation's latest durable status; polling is not a replay. */
     queryOperation(request: Schemas['WebShellOperationRequest'], signal?: AbortSignal): Promise<Schemas['WebShellOperation']>;
     changeCwd(request: Schemas['WebShellChangeCwdRequest'], signal?: AbortSignal): Promise<Schemas['WebShellCwdOperation']>;
+    getSessionModels(sessionId: string, signal?: AbortSignal): Promise<{
+        models: components["schemas"]["WebShellModelOption"][];
+        modelSelection: components["schemas"]["WebShellModelSelection"];
+        supported: boolean;
+    }>;
+    changeModel(request: Schemas['WebShellChangeModelRequest'], signal?: AbortSignal): Promise<{
+        sessionId: string;
+        modelSelection: components["schemas"]["WebShellModelSelection"];
+        replayed: boolean;
+    }>;
     getToolResult(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
         result: components["schemas"]["PublicToolResult"];
         access: components["schemas"]["ArtifactAccess"];

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

@@ -7,6 +7,10 @@ export interface JavaManagedAgentProviderOptions extends JavaManagedAgentClientO
     /** Include tenant and actor identity; replace this scope/provider when either changes. Token refresh alone can use getHeaders. */
     productScope?: string;
     enableWorkspaceBinding?: boolean;
+    modelPresets?: readonly {
+        agentId: string;
+        label: string;
+    }[];
     /** Acquire a streaming save target during the user gesture, then call openStream. */
     saveArtifact?: ManagedArtifactSave;
 }

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

@@ -2,8 +2,53 @@ 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 type ManagedApprovalMode = 'default' | 'auto-edit' | 'yolo';
+export declare function isManagedApprovalMode(value: unknown): value is ManagedApprovalMode;
+export interface ManagedSessionOptions {
+    approvalMode: ManagedApprovalMode;
+    availableApprovalModes: ManagedApprovalMode[];
+}
+export interface ManagedSessionApproval extends ManagedSessionOptions {
+    approvalRevision: number;
+    supported: boolean;
+}
+export interface ManagedApprovalChangeResult {
+    sessionId: string;
+    approvalMode: ManagedApprovalMode;
+    approvalRevision: number;
+    replayed: boolean;
+}
+export interface ManagedModelContext {
+    modelId: string;
+    inputTokens?: number;
+    contextWindowSize?: number;
+    observedAt: number;
+}
+export interface ManagedModelSelection {
+    modelId?: string;
+    revision: number;
+}
+export interface ManagedSessionModels {
+    models: {
+        modelId: string;
+        label: string;
+    }[];
+    modelSelection: ManagedModelSelection;
+    supported: boolean;
+}
+export interface ManagedModelChangeResult {
+    sessionId: string;
+    modelSelection: ManagedModelSelection;
+    replayed: boolean;
+}
 export interface ManagedAgentSessionSummary {
     sessionId: string;
+    agentId?: string;
+    approvalMode?: ManagedApprovalMode;
+    initialApprovalMode?: ManagedApprovalMode;
+    approvalRevision?: number;
+    modelContext?: ManagedModelContext;
+    modelSelection?: ManagedModelSelection;
     activeTurnId?: string;
     title: string;
     workspaceCwd?: string;
@@ -23,10 +68,13 @@ export interface ManagedAgentSessionSummary {
         canSend: boolean;
         canCancel: boolean;
         actions?: boolean;
+        tasks?: boolean;
         artifacts?: boolean;
         /** The caller may submit later Turns to this Workspace-bound Session. */
         workspaceTurns?: boolean;
         cwdChange?: boolean;
+        modelChange?: boolean;
+        approvalModeChange?: boolean;
     };
     failure?: {
         code: string;
@@ -65,6 +113,22 @@ export interface ManagedAgentCommandOptions extends ManagedAgentRequestOptions {
     idempotencyKey: string;
 }
 export type ManagedCwdOperation = components['schemas']['WebShellCwdOperation'];
+export type ManagedTask = components['schemas']['WebShellTask'];
+export type ManagedTaskPage = components['schemas']['WebShellTaskPage'];
+export type ManagedTaskEvent = components['schemas']['WebShellTaskEvent'];
+export type ManagedTaskEventPage = components['schemas']['WebShellTaskEventPage'];
+export type ManagedTaskCancelOperation = components['schemas']['WebShellCommandOperation'] & {
+    type: 'task_cancel';
+};
+export type ManagedRuntimeNode = components['schemas']['WebShellRuntimeNode'];
+export type ManagedWorkspaceDirectory = components['schemas']['WebShellWorkspaceDirectory'];
+export type ManagedWorkspaceCreateOperation = components['schemas']['WebShellWorkspaceCreateOperation'];
+export interface ManagedWorkspaceRegistration {
+    listNodes(options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellRuntimeNodePage']>;
+    checkDirectory(request: components['schemas']['WebShellWorkspaceDirectoryRequest'], options: ManagedAgentRequestOptions): Promise<ManagedWorkspaceDirectory>;
+    create(request: Omit<components['schemas']['WebShellWorkspaceRegisterRequest'], 'idempotencyKey' | 'requestId'>, options: ManagedAgentCommandOptions): Promise<ManagedWorkspaceCreateOperation>;
+    query(operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedWorkspaceCreateOperation>;
+}
 /** A Hosted tool approval waiting for the Session owner's answer. */
 export interface ManagedAgentPendingAction {
     actionId: string;
@@ -93,6 +157,21 @@ export interface ManagedAgentProvider {
         respond(action: ManagedAgentPendingAction, optionId: string, options: ManagedAgentCommandOptions): Promise<void>;
     };
     readonly toolResults?: ManagedToolResultReader;
+    readonly tasks?: {
+        list(sessionId: string, options: ManagedAgentRequestOptions & {
+            cursor?: string;
+            limit?: number;
+        }): Promise<ManagedTaskPage>;
+        get(sessionId: string, taskId: string, options: ManagedAgentRequestOptions): Promise<ManagedTask>;
+        listEvents(sessionId: string, taskId: string, options: ManagedAgentRequestOptions & {
+            after?: string;
+            limit?: number;
+        }): Promise<ManagedTaskEventPage>;
+        readonly cancel?: {
+            submit(sessionId: string, taskId: string, options: ManagedAgentCommandOptions): Promise<ManagedTaskCancelOperation>;
+            query(sessionId: string, taskId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedTaskCancelOperation>;
+        };
+    };
     readonly cwdChange?: {
         submit(sessionId: string, request: {
             cwdRelative: string;
@@ -100,8 +179,30 @@ export interface ManagedAgentProvider {
         }, options: ManagedAgentCommandOptions): Promise<ManagedCwdOperation>;
         query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedCwdOperation>;
     };
+    readonly approvalChange?: {
+        queryOptions(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionApproval>;
+        submit(sessionId: string, request: {
+            approvalMode: ManagedApprovalMode;
+            expectedRevision: number;
+        }, options: ManagedAgentCommandOptions & {
+            requestId: string;
+        }): Promise<ManagedApprovalChangeResult>;
+    };
+    readonly modelChange?: {
+        queryOptions(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionModels>;
+        submit(sessionId: string, request: {
+            modelId: string;
+            expectedRevision: number;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedModelChangeResult>;
+    };
     readonly workspaceBinding?: {
         readonly agentId: string;
+        readonly registration?: ManagedWorkspaceRegistration;
+        /** Host-published model-specific AgentDefinitions available for new Sessions. */
+        readonly modelPresets?: readonly {
+            agentId: string;
+            label: string;
+        }[];
         list(options: ManagedAgentRequestOptions & {
             cursor?: string;
             limit?: number;
@@ -110,12 +211,28 @@ export interface ManagedAgentProvider {
             defaultWorkspace?: ManagedAgentWorkspace | null;
             nextCursor?: string;
             supported: boolean;
+            canCreateWorkspace?: boolean;
+            supportsApprovalModeSelection?: boolean;
         }>;
         get(workspaceId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentWorkspace>;
+        createWorkspace?(request: {
+            displayName: string;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedAgentWorkspace>;
+        getSessionOptions?(agentId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionOptions>;
         createEmpty(request: {
             agentId: string;
             workspaceId: string;
             cwdRelative: string;
+            approvalMode?: ManagedApprovalMode;
+        }, options: ManagedAgentCommandOptions): Promise<{
+            sessionId: string;
+        }>;
+        createSession?(request: {
+            agentId: string;
+            workspaceId: string;
+            cwdRelative: string;
+            text: string;
+            approvalMode?: ManagedApprovalMode;
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;

package/dist/types/components/managed/managed-development-options.d.ts

@@ -0,0 +1,7 @@
+import type { JavaManagedAgentProviderOptions } from './java-managed-agent-provider';
+/** Local Vite configuration; the production host supplies these provider options directly. */
+export declare function managedDevelopmentOptions(params: URLSearchParams, env: {
+    VITE_MANAGED_AGENT_ACTOR_ID?: string;
+    VITE_MANAGED_AGENT_MODEL_PRESETS?: string;
+    VITE_MANAGED_AGENT_WORKSPACE_BINDING?: string;
+}): Pick<JavaManagedAgentProviderOptions, 'productScope' | 'getHeaders' | 'enableWorkspaceBinding' | 'modelPresets'>;

package/dist/types/components/managed/managed-session-storage.d.ts

@@ -1,6 +1,6 @@
 export declare function managedRequestId(): string;
 export declare function getManagedClientId(baseUrl: string): string;
-export declare function managedSelectionFromUrl(): {
+export declare function managedSelectionFromUrl(defaultOpen?: boolean): {
     open: boolean;
     sessionId?: string;
 };

package/dist/types/components/managed/managed-task-messages.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+type ManagedTaskMessage = string | ((vars?: Record<string, string | number>) => string);
+export declare const MANAGED_TASK_MESSAGES_EN: Record<string, ManagedTaskMessage>;
+export declare const MANAGED_TASK_MESSAGES_ZH: Record<string, ManagedTaskMessage>;
+export {};

package/dist/types/components/managed/managed-task-messages.transcript-stub.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const MANAGED_TASK_MESSAGES_EN: {};
+export declare const MANAGED_TASK_MESSAGES_ZH: {};

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

@@ -0,0 +1,4 @@
+import type { ManagedTask, ManagedTaskCancelOperation, ManagedTaskEvent } from './managed-agent-provider';
+export declare const task: ManagedTask;
+export declare const taskOperation: ManagedTaskCancelOperation;
+export declare function taskEvent(cursor: string, type?: string): ManagedTaskEvent;

package/dist/types/components/managed/managed-workspace-messages.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const WORKSPACE_REGISTRATION_MESSAGES_EN: Record<string, string>;
+export declare const WORKSPACE_REGISTRATION_MESSAGES_ZH: Record<string, string>;

package/dist/types/components/managed/managed-workspace-messages.transcript-stub.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const WORKSPACE_REGISTRATION_MESSAGES_EN: {};
+export declare const WORKSPACE_REGISTRATION_MESSAGES_ZH: {};

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

@@ -0,0 +1,24 @@
+import type { ManagedAgentProvider, ManagedApprovalMode, ManagedAgentSessionSummary, ManagedSessionApproval } from './managed-agent-provider';
+interface ApprovalIntent {
+    sessionId: string;
+    approvalMode: ManagedApprovalMode;
+    expectedRevision: number;
+    idempotencyKey: string;
+    requestId: string;
+}
+export declare function useManagedApprovalChange(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>, interactive: boolean): {
+    options: ManagedSessionApproval | undefined;
+    optionsLoading: boolean;
+    optionsError: boolean;
+    supported: boolean;
+    blocked: boolean;
+    submit: (approvalMode: ManagedApprovalMode) => Promise<true | undefined>;
+    confirm: () => Promise<true | undefined>;
+    reloadOptions: () => void;
+    isBlocked: () => boolean;
+    key: string;
+    pending?: ApprovalIntent;
+    busy: boolean;
+    errorCode?: string;
+};
+export {};

package/dist/types/components/managed/use-managed-model-change.d.ts

@@ -0,0 +1,23 @@
+import type { ManagedAgentProvider, ManagedAgentSessionSummary, ManagedSessionModels } from './managed-agent-provider';
+interface ModelIntent {
+    sessionId: string;
+    modelId: string;
+    expectedRevision: number;
+    idempotencyKey: string;
+}
+export declare function useManagedModelChange(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>, interactive: boolean): {
+    options: ManagedSessionModels | undefined;
+    optionsLoading: boolean;
+    optionsError: boolean;
+    supported: boolean;
+    blocked: boolean;
+    submit: (modelId: string) => Promise<true | undefined>;
+    confirm: () => Promise<true | undefined>;
+    reloadOptions: () => void;
+    isBlocked: () => boolean;
+    key: string;
+    pending?: ModelIntent;
+    busy: boolean;
+    errorCode?: string;
+};
+export {};

package/dist/types/components/managed/use-managed-task-cancel.d.ts

@@ -0,0 +1,12 @@
+import type { ManagedAgentProvider, ManagedTask } from './managed-agent-provider';
+export interface ManagedTaskCancelState {
+    status: 'submitting' | 'stopping' | 'unconfirmed' | 'failed';
+    busy: boolean;
+    code?: string;
+}
+export declare function useManagedTaskCancel(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, snapshots: readonly ManagedTask[], refreshTasks: () => void, applySnapshot: (task: ManagedTask) => void): {
+    states: Record<string, ManagedTaskCancelState>;
+    pendingTaskIds: string[];
+    submit(task: ManagedTask): Promise<void>;
+    resume(taskId: string): Promise<void>;
+};

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

@@ -0,0 +1,49 @@
+import type { ManagedAgentProvider, ManagedTask } from './managed-agent-provider';
+export declare function isManagedTaskTerminal(task: ManagedTask): boolean;
+export declare function useManagedTasks(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, open: boolean): {
+    page: {
+        data: import("./generated/managed-agent-api").components["schemas"]["WebShellTask"][];
+        hasMore: boolean;
+        nextCursor?: string | null;
+    };
+    task: {
+        taskId: string;
+        sessionId: string;
+        kind: import("./generated/managed-agent-api").components["schemas"]["TaskKind"];
+        state: import("./generated/managed-agent-api").components["schemas"]["TaskState"];
+        definitionRevision?: number;
+        runtimeState?: import("./generated/managed-agent-api").components["schemas"]["TaskRuntimeState"];
+        createdAt: number;
+        startedAt?: number;
+        settledAt?: number;
+        outputCursor?: string;
+        artifactRefs: string[];
+        actionCapabilities: import("./generated/managed-agent-api").components["schemas"]["TaskActionCapability"][];
+    } | undefined;
+    selectedId: string | undefined;
+    events: {
+        schemaVersion: number;
+        projectionVersion: number;
+        taskId: string;
+        sessionId: string;
+        type: import("./generated/managed-agent-api").components["schemas"]["TaskEventType"];
+        cursor: string;
+        createdAt: number;
+        state?: import("./generated/managed-agent-api").components["schemas"]["TaskState"];
+        runtimeState?: import("./generated/managed-agent-api").components["schemas"]["TaskRuntimeState"];
+        text?: string;
+        truncated?: boolean;
+        artifactId?: string;
+    }[];
+    moreEvents: boolean;
+    historyGap: boolean;
+    loading: boolean;
+    error: unknown;
+    hasPrevious: boolean;
+    refresh: () => void;
+    apply: (task: ManagedTask) => void;
+    select: (taskId?: string) => void;
+    next: () => void;
+    previous: () => void;
+    loadMoreEvents: () => void;
+};

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

@@ -0,0 +1 @@
+export declare function BrowserNotificationControl(): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,8 @@
+import { type ReactNode } from 'react';
+export interface SelectionCopyMenuProps {
+    children: ReactNode;
+    className: string;
+    content: string;
+    enabled: boolean;
+}
+export declare function SelectionCopyMenu({ children, className, content, enabled, }: SelectionCopyMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/SelectionCopyMenu.transcript-stub.d.ts

@@ -0,0 +1,2 @@
+import type { SelectionCopyMenuProps } from './SelectionCopyMenu';
+export declare function SelectionCopyMenu({ children, className, }: SelectionCopyMenuProps): import("react/jsx-runtime").JSX.Element;

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

@@ -1,6 +1,7 @@
 import type { DaemonSessionMonitorTaskStatus, DaemonSessionShellTaskStatus, DaemonSessionWorkflowTasksStatus } from '@qwen-code/sdk/daemon';
 import { type DaemonSessionActions } from '@qwen-code/web-shell/daemon-react-sdk';
 import type { ACPToolCall, TodoItem } from '../../adapters/types';
+import type { OpenSubagentDetails } from '../../subagentDetailsContext';
 declare const ACTIVE_EVENT = "web-shell:tasks-panel-active";
 type DaemonSessionTasksStatus = DaemonSessionWorkflowTasksStatus;
 export interface SerializedTasksMessage {
@@ -24,7 +25,7 @@ export declare function TasksStatusMessage({ message, embedded, manageActiveEven
     onClose?: () => void;
     planTodos?: readonly TodoItem[];
     agentTools?: readonly ACPToolCall[];
-    onOpenSubagent?: (tool: ACPToolCall) => void;
+    onOpenSubagent?: OpenSubagentDetails;
     onOpenMonitor?: (task: DaemonSessionMonitorTaskStatus) => void;
 }): import("react/jsx-runtime").JSX.Element | null;
 export declare function MonitorTaskDetail({ task, actions: providedActions, }: {

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

@@ -5,6 +5,7 @@ interface ToolApprovalProps {
     onConfirm: (id: string, selectedOption: string) => void | Promise<void>;
     variant?: 'inline' | 'floating';
     disabled?: boolean;
+    showBrowserNotifications?: boolean;
     /**
      * Whether this approval should pull keyboard focus to its safe-default option
      * when it becomes the topmost (visible) one — on appearance, or when a panel/
@@ -32,5 +33,5 @@ export declare function parseTitle(title?: string): {
     toolName: string;
     description: string;
 };
-export declare function ToolApproval({ request, onConfirm, variant, disabled, keyboardActive, extraDescriptionId, planTodos, planExecutionMode, generateContent, }: ToolApprovalProps): import("react/jsx-runtime").JSX.Element;
+export declare function ToolApproval({ request, onConfirm, variant, disabled, showBrowserNotifications, keyboardActive, extraDescriptionId, planTodos, planExecutionMode, generateContent, }: ToolApprovalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,5 +1,6 @@
 import { type ReactNode } from 'react';
 import type { DaemonSessionWorkflowTaskStatus, DaemonWorkflowDispatchStatus, DaemonWorkflowDispatchStatusEntry } from '@qwen-code/sdk/daemon';
+import type { OpenSubagentDetails } from '../../subagentDetailsContext';
 export declare const WORKFLOW_GRAPH_RENDER_LIMITS: {
     readonly lanes: 64;
     readonly nodes: 240;
@@ -36,7 +37,7 @@ export interface WorkflowGraphLayout {
 export declare function buildWorkflowGraphLayout(task: DaemonSessionWorkflowTaskStatus, options?: {
     laneWidth?: number;
 }): WorkflowGraphLayout;
-export declare function WorkflowExecutionView({ task, sourceTask, historyTasks, historyActionBusy, onDeleteHistory, actions, }: {
+export declare function WorkflowExecutionView({ task, sourceTask, historyTasks, historyActionBusy, onDeleteHistory, actions, onOpenSubagent, }: {
     task: DaemonSessionWorkflowTaskStatus;
     sourceTask?: DaemonSessionWorkflowTaskStatus;
     historyTasks?: readonly DaemonSessionWorkflowTaskStatus[];
@@ -44,5 +45,6 @@ export declare function WorkflowExecutionView({ task, sourceTask, historyTasks,
     onDeleteHistory?: (runId: string) => void;
     /** Run controls (pause / stop / rerun …) shown at the end of the metrics strip. */
     actions?: ReactNode;
+    onOpenSubagent?: OpenSubagentDetails;
 }): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,5 +1,6 @@
-import type { ACPToolCall } from '../../adapters/types';
-export { isActiveToolStatus } from '../../adapters/toolClassification';
+import type { ACPToolCall } from '../../adapters/types.js';
+export { isAskUserQuestionToolName } from '../../constants/toolNames.js';
+export { isActiveToolStatus } from '../../adapters/toolClassification.js';
 /**
  * Internal-tool-name → display-name lookup. This is a standalone copy of
  * core's `ToolDisplayNames` (mapped to wire names, as the CLI's shared
@@ -19,7 +20,6 @@ export declare function formatToolDisplayName(toolName: string): string;
  * English {@link formatToolDisplayName}. Pass the `t` from `useI18n()`.
  */
 export declare function localizeToolDisplayName(toolName: string, t: (key: string, vars?: Record<string, string | number>) => string): string;
-export declare function isAskUserQuestionToolName(toolName: string): boolean;
 export declare function isAdvisorToolName(toolName: string): boolean;
 export declare function isCompletedAskUserQuestion(tool: ACPToolCall): boolean;
 export declare function getQuestionAnswerResult(tool: ACPToolCall): {

package/dist/types/components/messages/workflow-agent-details.d.ts

@@ -0,0 +1,3 @@
+import type { DaemonSessionWorkflowTaskStatus, DaemonWorkflowDispatchStatusEntry } from '@qwen-code/sdk/daemon';
+import { type OpenSubagentDetails } from '../../subagentDetailsContext';
+export declare function useWorkflowAgentDetails(task: DaemonSessionWorkflowTaskStatus, onOpenSubagent?: OpenSubagentDetails): (dispatch: DaemonWorkflowDispatchStatusEntry) => void;

package/dist/types/components/messages/workflow-agent-details.transcript-stub.d.ts

@@ -0,0 +1 @@
+export declare function useWorkflowAgentDetails(): () => void;

package/dist/types/components/panels/EnvironmentPanel.d.ts

@@ -44,5 +44,10 @@ export type EnvironmentAgentTask = DaemonSessionAgentTaskStatus & {
     color?: string;
     lineageState?: 'complete' | 'orphaned' | 'cycle';
 };
+/**
+ * Statuses this panel renders with a spinner. The header's activity dot keys
+ * off the same set, so the dot cannot promise a row the panel shows settled.
+ */
+export declare function isTaskInProgress(status: DaemonSessionTaskWithWorkflowStatus['status']): boolean;
 export declare function EnvironmentPanel({ sources, onOpenSource, retrySourceRegistration, floating, hidden, workspaceCwd, gitWorkspaceCwd, gitCwd, gitSessionId, branch, gitStatus, tasks, agentTasks, attachments, attachmentsLoading, attachmentsError, onRetryAttachments, artifacts, artifactsLoading, items, onOpenGitDiff, onOpenGitCommit, onOpenGitWorktrees, onOpenGitLog, onOpenAgent, onOpenAgentWorkflow, onOpenTask, onReadImage, onImagePreview, onAttachmentPreview, onAttachmentPreviewError, onOpenArtifact, onDismiss, }: EnvironmentPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -135,6 +135,9 @@ interface WebShellSidebarProps {
     lockedWorkspace?: WebShellSidebarLockedWorkspace;
     branding?: false | WebShellSidebarBranding;
     primaryNav?: WebShellSidebarPrimaryNavOptions;
+    /** Replace daemon history with navigation owned by an external session provider. */
+    sessionContent?: ReactNode;
+    sessionHeader?: ReactNode;
     /** Whether to show the Tasks/Channels session-source switch. Defaults to true. */
     showSessionSourceSwitch?: boolean;
     /** Show Live conversations and, in rail layout, the Live entry. Defaults to false. */
@@ -162,4 +165,4 @@ interface WebShellSidebarProps {
     onLoadStandaloneSession?: (sessionId: string) => Promise<void> | void;
     onStandaloneNotice?: (message: string) => void;
 }
-export declare function WebShellSidebar({ 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, onOpenHostSession, 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({ 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, onOpenHostSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, sessionContent, sessionHeader, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ui/alert.d.ts

@@ -1,7 +1,7 @@
 import type * as React from 'react';
 import { type VariantProps } from 'class-variance-authority';
 declare const alertVariants: (props?: ({
-    variant?: "default" | "destructive" | "success" | null | undefined;
+    variant?: "default" | "success" | "destructive" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 declare function Alert({ className, variant, ...props }: React.ComponentProps<'div'> & VariantProps<typeof alertVariants>): import("react/jsx-runtime").JSX.Element;
 declare function AlertTitle({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/ui/drawer.d.ts

@@ -4,7 +4,7 @@ declare function Drawer({ ...props }: React.ComponentProps<typeof DrawerPrimitiv
 declare function DrawerTrigger({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
 declare function DrawerPortal({ container, ...props }: React.ComponentProps<typeof DrawerPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
 declare function DrawerClose({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
-declare const DrawerOverlay: React.ForwardRefExoticComponent<Omit<Omit<import("@radix-ui/react-dialog").DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DrawerOverlay: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Overlay> & React.RefAttributes<HTMLDivElement>>;
 type DrawerContentProps = React.ComponentProps<typeof DrawerPrimitive.Content> & {
     overlayProps?: React.ComponentProps<typeof DrawerPrimitive.Overlay>;
 };

package/dist/types/components/ui/resizable.d.ts

@@ -0,0 +1,5 @@
+import * as ResizablePrimitive from 'react-resizable-panels';
+declare const ResizablePanelGroup: import("react").ForwardRefExoticComponent<Omit<ResizablePrimitive.GroupProps, "elementRef"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ResizablePanel: import("react").ForwardRefExoticComponent<Omit<ResizablePrimitive.PanelProps, "elementRef"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ResizableHandle: import("react").ForwardRefExoticComponent<Omit<ResizablePrimitive.SeparatorProps, "elementRef"> & import("react").RefAttributes<HTMLDivElement>>;
+export { ResizableHandle, ResizablePanel, ResizablePanelGroup };

package/dist/types/components/workflows/WorkflowRunsPage.d.ts

@@ -1,6 +1,8 @@
+import type { OpenSubagentDetails } from '../../subagentDetailsContext';
 interface WorkflowRunsPageProps {
     onCreateViaChat: () => void;
     onWorkflowRunStarted?: () => void;
+    onOpenSubagent?: OpenSubagentDetails;
 }
-export declare function WorkflowRunsPage({ onCreateViaChat, onWorkflowRunStarted, }: WorkflowRunsPageProps): import("react/jsx-runtime").JSX.Element;
+export declare function WorkflowRunsPage({ onCreateViaChat, onWorkflowRunStarted, onOpenSubagent, }: WorkflowRunsPageProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/constants/sessions.d.ts

@@ -8,6 +8,7 @@
  * retention limits cannot drift between the main and split views.
  */
 export declare const SESSION_LIST_PAGE_SIZE = 1000;
+export declare const SESSION_ARCHIVE_BATCH_SIZE = 100;
 export declare const SIDEBAR_SESSION_PREVIEW_LIMIT = 5;
 export declare const SESSION_ORGANIZATION_FEATURE = "session_organization";
 export declare const SESSION_LIVE_STATE_FEATURE = "workspace_session_live_state";