@qwen-code/web-shell 0.25.2 → 0.25.3-nightly.20261019.5dcf7c7cb1

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

@@ -51,7 +51,41 @@ export declare class JavaManagedAgentClient {
         displayName: string;
         canCreateSession: boolean;
         state: "active" | "draining" | "removed";
+        defaultCwdRelative?: string;
+        canSelectDirectory?: boolean;
     }>;
+    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>;
+    queryWorkspaceFiles(request: Schemas['WebShellWorkspaceFileQueryRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFilePage']>;
+    readWorkspaceFile(request: Schemas['WebShellWorkspaceFileReadRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileSnapshot']>;
+    workspaceDirectories(request: Schemas['WebShellWorkspaceDirectoryQueryRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceDirectoryPage']>;
+    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>;
@@ -65,6 +99,7 @@ export declare class JavaManagedAgentClient {
     getTask(request: Schemas['WebShellTaskGetRequest'], signal?: AbortSignal): Promise<{
         taskId: string;
         sessionId: string;
+        childSessionId?: string;
         kind: components["schemas"]["TaskKind"];
         state: components["schemas"]["TaskState"];
         definitionRevision?: number;
@@ -98,6 +133,27 @@ export declare class JavaManagedAgentClient {
     /** 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;
+    }>;
+    getSessionSkills(sessionId: string, signal?: AbortSignal): Promise<{
+        skills: components["schemas"]["WebShellSkill"][];
+    }>;
+    changeModel(request: Schemas['WebShellChangeModelRequest'], signal?: AbortSignal): Promise<{
+        sessionId: string;
+        modelSelection: components["schemas"]["WebShellModelSelection"];
+        replayed: boolean;
+    }>;
+    getToolDetails(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
+        input: {
+            [key: string]: unknown;
+        } | null;
+        output: string | null;
+        truncated: boolean;
+        shellResult?: components["schemas"]["WebShellShellResult"];
+    }>;
     getToolResult(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
         result: components["schemas"]["PublicToolResult"];
         access: components["schemas"]["ArtifactAccess"];

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

@@ -2,9 +2,61 @@ 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 type ManagedInputBlock = components['schemas']['InputBlock'];
+export type ManagedSessionSkills = components['schemas']['WebShellSessionSkills'];
+export declare function isManagedApprovalMode(value: unknown): value is ManagedApprovalMode;
+export interface ManagedSessionOptions {
+    approvalMode: ManagedApprovalMode;
+    availableApprovalModes: ManagedApprovalMode[];
+    planModeSupported?: boolean;
+    inputAttachments?: boolean;
+}
+export interface ManagedSessionApproval extends ManagedSessionOptions {
+    approvalRevision: number;
+    supported: boolean;
+    planMode?: boolean;
+}
+export interface ManagedApprovalChangeResult {
+    sessionId: string;
+    approvalMode: ManagedApprovalMode;
+    approvalRevision: number;
+    replayed: boolean;
+    planMode?: 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;
+    planMode?: boolean;
+    planModeSupported?: boolean;
+    modelContext?: ManagedModelContext;
+    modelSelection?: ManagedModelSelection;
     activeTurnId?: string;
     title: string;
     workspaceCwd?: string;
@@ -29,6 +81,9 @@ export interface ManagedAgentSessionSummary {
         /** The caller may submit later Turns to this Workspace-bound Session. */
         workspaceTurns?: boolean;
         cwdChange?: boolean;
+        modelChange?: boolean;
+        approvalModeChange?: boolean;
+        inputAttachments?: boolean;
     };
     failure?: {
         code: string;
@@ -74,6 +129,15 @@ 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;
@@ -96,12 +160,18 @@ export interface ManagedAgentProvider {
     readonly storageKey: string;
     readonly canCancel: boolean;
     readonly acceptsWorkspaceCwd: boolean;
+    readonly skills?: {
+        list(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionSkills>;
+    };
     /** 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 toolDetails?: {
+        get(sessionId: string, itemId: string, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellToolDetails']>;
+    };
     readonly tasks?: {
         list(sessionId: string, options: ManagedAgentRequestOptions & {
             cursor?: string;
@@ -124,8 +194,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;
+            planMode?: boolean;
+        }, 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 workspaceFiles?: {
+        query(request: components['schemas']['WebShellWorkspaceFileQueryRequest'], options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFilePage']>;
+        read(request: components['schemas']['WebShellWorkspaceFileReadRequest'], options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileSnapshot']>;
+    };
     readonly workspaceBinding?: {
         readonly agentId: string;
+        readonly registration?: ManagedWorkspaceRegistration;
         /** Host-published model-specific AgentDefinitions available for new Sessions. */
         readonly modelPresets?: readonly {
             agentId: string;
@@ -139,12 +231,27 @@ export interface ManagedAgentProvider {
             defaultWorkspace?: ManagedAgentWorkspace | null;
             nextCursor?: string;
             supported: boolean;
+            canCreateWorkspace?: boolean;
+            canSelectDirectory?: boolean;
+            supportsApprovalModeSelection?: boolean;
         }>;
         get(workspaceId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentWorkspace>;
+        createWorkspace?(request: {
+            displayName: string;
+            sourceWorkspaceId?: string;
+            cwdRelative?: string;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedAgentWorkspace>;
+        directories?(request: {
+            workspaceId: string;
+            cwdRelative: string;
+        }, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceDirectoryPage']>;
+        getSessionOptions?(agentId: string, options: ManagedAgentRequestOptions): Promise<ManagedSessionOptions>;
         createEmpty(request: {
             agentId: string;
             workspaceId: string;
             cwdRelative: string;
+            approvalMode?: ManagedApprovalMode;
+            planMode?: boolean;
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
@@ -153,6 +260,9 @@ export interface ManagedAgentProvider {
             workspaceId: string;
             cwdRelative: string;
             text: string;
+            input?: ManagedInputBlock[];
+            approvalMode?: ManagedApprovalMode;
+            planMode?: boolean;
         }, options: ManagedAgentCommandOptions): Promise<{
             sessionId: string;
         }>;
@@ -173,9 +283,11 @@ export interface ManagedAgentProvider {
     createSession(request: {
         text: string;
         workspaceCwd?: string;
+        input?: ManagedInputBlock[];
     }, options: ManagedAgentCommandOptions): Promise<ManagedAgentTurnAdmission>;
     submitPrompt(sessionId: string, request: {
         text: string;
+        input?: ManagedInputBlock[];
     }, options: ManagedAgentCommandOptions): Promise<ManagedAgentTurnAdmission>;
     cancel(sessionId: string, turnId: string, options: ManagedAgentCommandOptions): Promise<void>;
     subscribeEvents(sessionId: string, options: ManagedAgentRequestOptions & {
@@ -200,4 +312,6 @@ export interface ManagedAgentWorkspace {
     displayName: string;
     state: string;
     canCreateSession: boolean;
+    defaultCwdRelative?: string;
+    canSelectDirectory?: boolean;
 }

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

@@ -0,0 +1,7 @@
+import type { PromptFile, PromptImage } from '../../adapters/promptTypes';
+import type { ManagedInputBlock } from './managed-agent-provider';
+import type { EditorHandle } from '../../hooks/useComposerCore';
+export declare function isManagedInput(value: unknown): value is ManagedInputBlock[];
+export declare function encodeManagedInput(text: string, images?: readonly PromptImage[], files?: readonly PromptFile[]): Promise<ManagedInputBlock[]>;
+export declare function managedInputText(input: readonly ManagedInputBlock[]): string;
+export declare function restoreManagedAttachments(editor: EditorHandle | null, input?: readonly ManagedInputBlock[]): void;

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

@@ -0,0 +1,2 @@
+export declare function readManagedPending(key: string): Promise<unknown>;
+export declare function saveManagedPending(key: string, value?: unknown): Promise<boolean>;

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

@@ -2,3 +2,4 @@ import type { Message } from '../../adapters/types';
 import type { ManagedAgentSessionEvent } from './managed-agent-provider';
 export declare function mergeManagedEvents(current: readonly ManagedAgentSessionEvent[], incoming: readonly ManagedAgentSessionEvent[]): ManagedAgentSessionEvent[];
 export declare function managedEventsToMessages(events: readonly ManagedAgentSessionEvent[], truncatedLabel: string): Message[];
+export declare function createManagedMessageProjector(): (events: readonly ManagedAgentSessionEvent[], truncatedLabel: string) => Message[];

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-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,25 @@
+import type { ManagedAgentProvider, ManagedApprovalMode, ManagedAgentSessionSummary, ManagedSessionApproval } from './managed-agent-provider';
+interface ApprovalIntent {
+    sessionId: string;
+    approvalMode: ManagedApprovalMode;
+    expectedRevision: number;
+    idempotencyKey: string;
+    requestId: string;
+    planMode?: boolean;
+}
+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, planMode?: boolean) => 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-file-references.d.ts

@@ -0,0 +1,19 @@
+import type { AtMentionWorkspaceActions } from '../../hooks/useAtMentionSources';
+import type { ComposerSubmitMetadata } from '../../hooks/useComposerCore';
+import type { ManagedAgentProvider } from './managed-agent-provider';
+import type { PromptFile } from '../../adapters/promptTypes';
+export declare function useManagedFileReferences(provider: ManagedAgentProvider, clientId: string, workspace: {
+    workspaceId: string;
+    cwdRelative: string;
+    contextRevision?: number;
+    state?: string;
+} | undefined, sessionId?: string): {
+    actions: AtMentionWorkspaceActions | undefined;
+    busy: boolean;
+    prepareInput: (text: string, files?: readonly PromptFile[], metadata?: ComposerSubmitMetadata) => Promise<{
+        text: string;
+        files: PromptFile[];
+    }>;
+    assertCurrent: () => void;
+    error: string | undefined;
+};

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-skills.d.ts

@@ -0,0 +1,12 @@
+import type { ManagedAgentProvider } from './managed-agent-provider';
+export declare function useManagedSkills(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined): {
+    supported: boolean;
+    skills: {
+        name: string;
+        description: string;
+    }[];
+    loading: boolean;
+    loaded: boolean;
+    error: boolean;
+    onOpenChange: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

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

@@ -9,6 +9,7 @@ export declare function useManagedTasks(provider: ManagedAgentProvider, clientId
     task: {
         taskId: string;
         sessionId: string;
+        childSessionId?: string;
         kind: import("./generated/managed-agent-api").components["schemas"]["TaskKind"];
         state: import("./generated/managed-agent-api").components["schemas"]["TaskState"];
         definitionRevision?: number;

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

@@ -34,6 +34,7 @@ export declare function getToolDescription(tool: ACPToolCall, workspaceCwd?: str
 export declare function getToolSummaryDescription(tool: ACPToolCall, workspaceCwd?: string): string;
 export declare function getShellToolSemanticDescription(tool: ACPToolCall): string;
 export declare function extractText(tool: ACPToolCall): string | null;
+export declare function hasRecordedOutput(tool: ACPToolCall): boolean;
 export declare function getAdvisorDisplayText(tool: ACPToolCall): string | null;
 export declare function getToolResultSummary(tool: ACPToolCall): string;
 export declare function getEmptyMcpToolTitleDescription(toolName: string | undefined, title: string | undefined, input: Record<string, unknown> | undefined): string | undefined;

package/dist/types/components/messages/tools/ToolDetailsContext.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from 'react';
+import type { ACPToolCall } from '../../../adapters/types';
+export type ToolDetailsLoader = (callId: string, signal: AbortSignal) => Promise<Pick<ACPToolCall, 'args' | 'rawOutput'>>;
+export declare const ToolDetailsContext: import("react").Context<ToolDetailsLoader | undefined>;
+export declare function useToolDetails(tool: ACPToolCall, expanded: boolean): {
+    tool: import("../../../adapters/messageTypes").DaemonMessageToolCall;
+    loading: boolean;
+};
+export declare function ToolDetails({ tool, enabled, children, }: {
+    tool: ACPToolCall;
+    enabled: boolean;
+    children: (tool: ACPToolCall) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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?: "success" | "default" | "destructive" | 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/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";

package/dist/types/customization.d.ts

@@ -1,3 +1,4 @@
+import type { WebShellApprovalMode } from './utils/planMode';
 import type { ArtifactFilter } from './components/artifacts/TurnOutputs';
 import { type CSSProperties, type ComponentType, type ReactNode } from 'react';
 import type { Components, Options } from 'react-markdown';
@@ -512,6 +513,7 @@ export type FooterRenderer = ComponentType<WebShellFooterRenderInfo>;
  */
 export type LoadingPhrasesResolver = (language: string) => readonly string[] | undefined | null;
 export interface WebShellCustomization {
+    allowedApprovalModes?: readonly WebShellApprovalMode[];
     filterArtifact?: ArtifactFilter;
     artifact?: WebShellArtifactCustomization;
     /** Host-specific label for the Ask User Question free-text choice. */

package/dist/types/daemon/session/actions.d.ts

@@ -14,6 +14,13 @@ export declare function resolveSessionRestoreTimeouts(capabilities: DaemonCapabi
     requestTimeoutMs: number;
     watchdogTimeoutMs: number | undefined;
 };
+/**
+ * Limit for a workspace create, which waits for the capability preflight and
+ * then for the create request. The SDK sizes that request from the same
+ * advertised session budget as a restore, so an action limit below the sum of
+ * the two reports a timeout on a spawn the daemon is still finishing.
+ */
+export declare function resolveCreateWatchdogTimeoutMs(capabilities: DaemonCapabilities | undefined): number;
 export interface CreateDaemonSessionActionsArgs {
     store: DaemonTranscriptStore;
     sessionRef: RefBox<DaemonSessionClient | undefined>;

package/dist/types/daemon/session/types.d.ts

@@ -363,7 +363,9 @@ export interface DaemonSessionActions {
      */
     setDaemonActivePrompt(active: boolean | undefined, owner?: Pick<DaemonActivePromptState, 'workspaceCwd' | 'sessionId'>, backgroundTurn?: DaemonBackgroundTurn, requestStartedAt?: number): void;
     sendPrompt(text: string, options?: SendPromptOptions): Promise<PromptResult>;
-    continueSession(): Promise<void>;
+    continueSession(options?: {
+        confirmCancellation?: string;
+    }): Promise<void>;
     /**
      * Non-blocking prompt submission. POSTs to the daemon and returns
      * immediately with the `promptId`. The daemon queues the prompt in its

package/dist/types/hooks/useApprovalModes.d.ts

@@ -0,0 +1,2 @@
+import { type WebShellApprovalMode } from '../utils/planMode';
+export declare function useApprovalModes(cwd: string | undefined, allowedApprovalModes: readonly WebShellApprovalMode[] | undefined): readonly WebShellApprovalMode[];

package/dist/types/hooks/useAtMentionSources.d.ts

@@ -66,6 +66,11 @@ export declare function createBuiltinProviderCache(): BuiltinProviderCache;
 export declare function getCached<K, V>(cache: Map<K, Promise<V>>, key: K, load: () => Promise<V>): Promise<V>;
 export interface AtMentionWorkspaceActions {
     globWorkspace?: GlobWorkspaceFn;
+    searchWorkspaceFiles?: (query: string, signal: AbortSignal) => Promise<string[]>;
+    prepareFileReference?: (tag: WebShellComposerTag) => Promise<WebShellComposerTag>;
+    onFileReferenceDiscarded?: () => void;
+    scopeKey?: string;
+    filesOnly?: boolean;
     loadExtensionsStatus?: LoadExtensionsStatusFn;
     listDirectory?: ListDirectoryFn;
     loadMcpStatus?: LoadMcpStatusFn;

package/dist/types/hooks/useComposerCore.d.ts

@@ -101,6 +101,8 @@ export interface UseComposerCoreOptions {
     shellModeEnabled?: boolean;
     attachmentsEnabled?: boolean;
     workspaceFeaturesEnabled?: boolean;
+    fileReferenceActions?: AtMentionWorkspaceActions;
+    persistFileReferences?: boolean;
     composerTagIcons?: WebShellComposerTagIconMap;
     parseUserMessageContent?: UserMessageContentParser;
     renderComposerTag?: ComposerTagRenderer;
@@ -210,8 +212,6 @@ export interface UseComposerCoreReturn {
     currentMode: string;
     sessionName: string | undefined;
     searchState: SearchState;
-    navigatePrevHistory: () => void;
-    navigateNextHistory: () => void;
     showShortcutHints: boolean;
     followupState: UseDaemonFollowupSuggestionReturn['followupState'];
     disabled: boolean;

package/dist/types/hooks/useInputHistory.d.ts

@@ -10,8 +10,4 @@ export declare function useInputHistory(storageKey?: string, fallbackStorageKey?
     getReverseMatches: (query: string) => string[];
     getLastEntry: (filter?: (entry: string) => boolean) => string | null;
     resetSearch: () => void;
-    nav: {
-        canUp: boolean;
-        canDown: boolean;
-    };
 };

package/dist/types/index.d.ts

@@ -6,12 +6,13 @@ import { type WebShellBrowserNotificationsOptions } from './browser-turn-notific
 export { WebShellTranscript } from './components/WebShellTranscript';
 export type { WebShellTranscriptProps } from './components/WebShellTranscript';
 export * from './daemon-react-sdk';
+export type { WebShellApprovalMode } from './utils/planMode';
 export type { WebShellBrowserNotificationsOptions } from './browser-turn-notifications';
 export { JavaManagedAgentClient, JavaManagedAgentHttpError, type JavaAgentCommandAdmission, type JavaAgentEnvironment, type JavaAgentEvent, type JavaAgentSession, type JavaAgentTranscript, type JavaAgentTurn, type JavaManagedAgentClientOptions, } from './components/managed/java-managed-agent-client';
 export { createJavaManagedAgentProvider, type JavaManagedAgentProviderOptions, } from './components/managed/java-managed-agent-provider';
 export { ManagedAgentWebShell, type ManagedAgentWebShellProps, } from './ManagedAgentWebShell';
 export type { ManagedArtifact, ManagedArtifactPage, ManagedArtifactResponse, ManagedArtifactSave, ManagedToolResult, ManagedToolResultReader, ManagedToolResultResponse, } from './components/managed/managed-tool-result-types';
-export { type ManagedAgentCommandOptions, type ManagedAgentPendingAction, type ManagedAgentProvider, type ManagedAgentRequestOptions, type ManagedAgentRuntimeState, type ManagedAgentSessionEvent, type ManagedAgentSessionEventType, type ManagedAgentSessionPhase, type ManagedAgentSessionSummary, type ManagedAgentSessionTranscript, type ManagedAgentTurnAdmission, } from './components/managed/managed-agent-provider';
+export { type ManagedAgentCommandOptions, type ManagedAgentPendingAction, type ManagedAgentProvider, type ManagedAgentRequestOptions, type ManagedAgentRuntimeState, type ManagedAgentSessionEvent, type ManagedAgentSessionEventType, type ManagedAgentSessionPhase, type ManagedAgentSessionSummary, type ManagedAgentSessionTranscript, type ManagedAgentTurnAdmission, type ManagedRuntimeNode, type ManagedWorkspaceDirectory, type ManagedWorkspaceCreateOperation, type ManagedWorkspaceRegistration, } from './components/managed/managed-agent-provider';
 export interface WebShellWithProvidersProps extends WebShellProps {
     /**
      * Opt in to URL routing. Explicit initial session target props override the

package/dist/types/trajectory/execution-messages.d.ts

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

package/dist/types/trajectory/execution-messages.transcript-stub.d.ts

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

package/dist/types/trajectory/project-trajectory-executions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TrajectoryLifecycleEntry, TrajectoryLifecycleProjection } from './project-trajectory-lifecycle';
+export interface TrajectoryExecutionRow {
+    key: string;
+    entry: TrajectoryLifecycleEntry;
+    name: string;
+    status: 'running' | 'unknown' | 'conflict' | 'success' | 'error' | 'cancelled' | 'interrupted' | 'not_started';
+    startedAt?: number;
+    endedAt?: number;
+    durationMs?: number;
+    historyRowKey?: string;
+}
+export declare function projectTrajectoryExecutions(lifecycle: TrajectoryLifecycleProjection, identity?: {
+    sessionId: string;
+    scope?: string;
+}): {
+    rows: TrajectoryExecutionRow[];
+    omitted: number;
+};