@qwen-code/web-shell 0.25.0 → 0.25.1-preview.1

package/dist/types/adapters/messageTypes.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { DaemonBackgroundTurn, DaemonSessionArtifactInput, DaemonInputAnnotation } from '@qwen-code/sdk/daemon';
+import type { DaemonBackgroundTurn, DaemonSessionArtifactInput, DaemonInputAnnotation, QwenAgentMessageMeta } from '@qwen-code/sdk/daemon';
 import type { components } from '../components/managed/generated/managed-agent-api.js';
 export interface AttachmentPreviewRequest {
     name: string;
@@ -119,6 +119,8 @@ export interface DaemonUserMessage extends DaemonMessageMeta {
     }>;
     inputAnnotations?: DaemonInputAnnotation[];
     source?: string;
+    /** `_meta.qwenAgentMessage` of an @-mention (`kind: 'agent_mention'`). */
+    agentMessage?: QwenAgentMessageMeta;
 }
 export interface DaemonAssistantMessage extends DaemonMessageMeta {
     reportedArtifacts?: DaemonSessionArtifactInput[];
@@ -138,6 +140,11 @@ export interface DaemonAssistantMessage extends DaemonMessageMeta {
         outputTokens: number;
         cachedTokens?: number;
     };
+    /**
+     * `_meta.qwenAgentMessage` of a workspace agent's reply in this session
+     * (`kind: 'agent_message'`): its run status, error, steps and tokens.
+     */
+    agentMessage?: QwenAgentMessageMeta;
 }
 export interface DaemonThinkingMessage extends DaemonMessageMeta {
     id: string;

package/dist/types/adapters/transcriptAdapter.d.ts

@@ -1,3 +1,4 @@
 import type { DaemonTranscriptBlock } from '@qwen-code/web-shell/daemon-react-sdk';
 import type { PermissionRequest } from './types';
 export declare function extractPendingPermission(blocks: readonly DaemonTranscriptBlock[]): PermissionRequest | null;
+export declare function escapePreviewText(text: string): string;

package/dist/types/components/ChatContextHeader.d.ts

@@ -1,6 +1,8 @@
 import type { ReactNode } from 'react';
 interface ChatContextHeaderProps {
     content: ReactNode;
+    /** Names where the chat runs, beside the actions; hidden when omitted. */
+    location?: ReactNode;
     /**
      * Workspace shown as the header's leading icon. Omitting it means the shell
      * has no workspace: the icon stays the same folder and only its tooltip says
@@ -23,5 +25,5 @@ interface ChatContextHeaderProps {
     /** Shows the Local Control QR entry; hidden when omitted. */
     onOpenLocalControlSettings?: () => void;
 }
-export declare function ChatContextHeader({ content, workspaceName, workspacePath, environmentOpen, environmentAvailable, rightPanelOpen, rightPanelAvailable, onToggleEnvironment, onToggleRightPanel, onOpenTokenUsage, onOpenContextUsage, onOpenLocalControlSettings, }: ChatContextHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChatContextHeader({ content, location, workspaceName, workspacePath, environmentOpen, environmentAvailable, rightPanelOpen, rightPanelAvailable, onToggleEnvironment, onToggleRightPanel, onOpenTokenUsage, onOpenContextUsage, onOpenLocalControlSettings, }: ChatContextHeaderProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/agents/AgentCreatePage.d.ts

@@ -17,6 +17,11 @@ interface AgentCreatePageProps {
     }[];
     /** Preselects the runtime, e.g. right after it joined. */
     initialHostId?: string;
+    /**
+     * Program ids this computer's daemon reported it can run. Absent (an older
+     * daemon) means Qwen Code only.
+     */
+    localPrograms?: readonly string[];
     onSaveWorkspaceAgent?: (input: {
         name: string;
         description?: string;
@@ -26,6 +31,7 @@ interface AgentCreatePageProps {
         maxConcurrentRuns: number;
         execution?: {
             mode: 'local';
+            provider?: AgentProgramView;
         } | {
             mode: 'managed-host';
             hostIds: string[];
@@ -33,5 +39,5 @@ interface AgentCreatePageProps {
         };
     }) => Promise<void>;
 }
-export declare function AgentCreatePage({ initialScope, agent, onCancel, onCreated, executionHosts, workspaceCwd, initialHostId, onSaveWorkspaceAgent, }: AgentCreatePageProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentCreatePage({ initialScope, agent, onCancel, onCreated, executionHosts, workspaceCwd, initialHostId, localPrograms, onSaveWorkspaceAgent, }: AgentCreatePageProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/agents/AgentsManagerPage.d.ts

@@ -1,13 +1,12 @@
 import type { EmbeddedManagerPage } from '../plugins/manager-page';
 interface AgentsManagerPageProps {
-    initialAgentView?: 'agents' | 'tasks' | 'runtime' | 'new-agent';
+    initialAgentView?: 'agents' | 'squads' | 'runtime' | 'new-agent';
     onClose: () => void;
     embedded?: EmbeddedManagerPage;
     initialCreateScope?: 'workspace' | 'global' | null;
     workspaceCwd?: string;
-    /** Opens an agent's own session in the shell's session view. */
-    onOpenAgentSession?: (sessionId: string) => void;
-    onOpenThreadChat?: (threadId: string, workspaceCwd: string) => void;
+    /** Puts `@name ` into the chat composer, from an agent card. */
+    onMentionAgent?: (name: string) => void;
 }
-export declare function AgentsManagerPage({ initialAgentView, onClose, embedded, initialCreateScope, workspaceCwd, onOpenAgentSession, onOpenThreadChat, }: AgentsManagerPageProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentsManagerPage({ initialAgentView, onClose, embedded, initialCreateScope, workspaceCwd, onMentionAgent, }: AgentsManagerPageProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/artifacts/ArtifactPanel.d.ts

@@ -171,12 +171,6 @@ export type ArtifactPanelTab = (WebPreviewState & {
     kind: 'workflow';
     title: string;
     sessionId?: string;
-} | {
-    id: string;
-    kind: 'agent_activity';
-    title: string;
-    threadId: string;
-    workspaceCwd: string;
 } | {
     id: 'turn_calls';
     kind: 'turn_calls';
@@ -245,7 +239,6 @@ interface ArtifactPanelProps {
     agentTraceLoading?: boolean;
     agentTraceError?: string;
     onOpenWorkflowAgent?: (task: EnvironmentAgentTask) => void;
-    onOpenCollaborationSession?: (sessionId: string, workspaceCwd: string) => void;
     onError?: (error: unknown, fallback: string) => void;
     sessionWorkflowEnabled?: boolean;
     modelManagement?: WebShellModelManagementOptions;
@@ -270,5 +263,5 @@ interface ArtifactPanelProps {
     fullscreen?: boolean;
     onToggleFullscreen?: () => void;
 }
-export declare function ArtifactPanel({ contextUsageControls, artifacts, tabs, activeTabId, reviewChanges, selectedReviewPath, panelWidth, workspaceCwd, loading, restoring, error, onSelectTab, onSelectTurnCallsPrompt, onCloseTab, onOpenFilePreview, latestReviewAvailable, onOpenLatestReview, onOpenTerminal, onOpenTrajectory, trajectoryTabId, onOpenWebPreview, onWebPreviewChange, items, sideTaskAvailable, sideTasks, sideTasksLoading, onCreateSideTask, onOpenSideTask, onCreateSideTaskSession, onSideTaskCreated, onSideTaskTitleChange, onSideTaskInitialPromptRefused, onNestedRightPanelOpen, onNestedArtifactsChange, onOpenNestedSubagent, agentTasks, agentTraceLoading, agentTraceError, onOpenWorkflowAgent, onOpenCollaborationSession, onError, sessionWorkflowEnabled, modelManagement, workflow, onImageIngestionNotice, deferSubagentMount, onClose, variant, fullscreen, onToggleFullscreen, }: ArtifactPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArtifactPanel({ contextUsageControls, artifacts, tabs, activeTabId, reviewChanges, selectedReviewPath, panelWidth, workspaceCwd, loading, restoring, error, onSelectTab, onSelectTurnCallsPrompt, onCloseTab, onOpenFilePreview, latestReviewAvailable, onOpenLatestReview, onOpenTerminal, onOpenTrajectory, trajectoryTabId, onOpenWebPreview, onWebPreviewChange, items, sideTaskAvailable, sideTasks, sideTasksLoading, onCreateSideTask, onOpenSideTask, onCreateSideTaskSession, onSideTaskCreated, onSideTaskTitleChange, onSideTaskInitialPromptRefused, onNestedRightPanelOpen, onNestedArtifactsChange, onOpenNestedSubagent, agentTasks, agentTraceLoading, agentTraceError, onOpenWorkflowAgent, onError, sessionWorkflowEnabled, modelManagement, workflow, onImageIngestionNotice, deferSubagentMount, onClose, variant, fullscreen, onToggleFullscreen, }: ArtifactPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/artifacts/TrajectoryFilters.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TrajectoryFilter } from '../../trajectory/filterTrajectory';
+export declare function TrajectoryFilters({ value, onChange, onNavigate, onClear, count, position, truncatedCount, }: {
+    value: TrajectoryFilter;
+    onChange: (filter: TrajectoryFilter) => void;
+    onNavigate: (direction: 1 | -1, filter?: TrajectoryFilter) => void;
+    onClear: () => void;
+    count: number;
+    position: number;
+    truncatedCount: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/artifacts/TrajectoryInspector.d.ts

@@ -4,13 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { TrajectoryRow } from '../../trajectory/types';
-export declare function TrajectoryInspector({ row, title, stale, turnSelected, hiddenByRange, hiddenByCollapse, onReveal, onClearRange, onClose, }: {
+export declare function TrajectoryInspector({ row, title, stale, turnSelected, hiddenByRange, hiddenByCollapse, hiddenByFilter, onClearFilter, onReveal, onClearRange, onClose, }: {
     row?: TrajectoryRow;
     title?: string;
     stale?: boolean;
     turnSelected?: boolean;
     hiddenByRange: boolean;
     hiddenByCollapse: boolean;
+    hiddenByFilter?: boolean;
+    onClearFilter?: () => void;
     onReveal: () => void;
     onClearRange: () => void;
     onClose: () => void;

package/dist/types/components/managed/generated/managed-agent-api.d.ts

@@ -74,7 +74,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Maps workspaceId/cwdRelative to public Workspace selection without using environmentId or absolute cwd. Shares G0's opt-in initial file-tool Turn admission and fixed server-owned profile with public Session creation. The Session creator may submit later Turns and cancel its running Turns under the same opt-in, and may rename the Session, while the creator currently holds Workspace read and create grants on a registry row whose state is ACTIVE and the Session is an active, undeleted qwen-code Session on the frozen execution profile; Workspace close follows its separate close capability and lifecycle admission; archive, delete and unarchive follow their separate retention capabilities after reliable Workspace close; cwd operations remain gated. The per-caller workspaceTurns capability on this surface advertises the same rule. Freeze selection with the original idempotency key; admission does not prove physical directory readiness. */
+        /** @description Maps workspaceId/cwdRelative to public Workspace selection without using environmentId or absolute cwd. Shares G0's opt-in initial file-tool Turn admission and fixed server-owned profile with public Session creation. The Session creator may submit later Turns under the same opt-in with current read and create grants on the bound ACTIVE Workspace generation and storage. Cancellation of running work requires the creator’s read grant and the opt-in, even after create authority is revoked (a live cancel reuses the owner's resident Harness attachment; a cold connector cache passively re-attaches for a persisted cancellation after frozen identity checks, independently of current creation grants, registry state or mount readiness; new work still rechecks execution authority); Workspace close follows its separate close capability and lifecycle admission; archive and unarchive follow retention capabilities after reliable Workspace close; delete supports either L3 idle ACTIVE files Sessions or L2 CLOSED/ARCHIVED Sessions; controlled same-Workspace cwd changes ship through the durable cwd_change operations (v1.32). The per-caller workspaceTurns capability on this surface advertises current submit and rename admission; it does not gate cancellation. Freeze selection with the original idempotency key; admission does not prove physical directory readiness. */
         post: operations["webShellCreateSession"];
         delete?: never;
         options?: never;
@@ -131,6 +131,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/agent/web-shell/v1/sessions/cwd/change": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description W2, implemented: the camelCase twin of the public changeSessionCwd with the matched refusal order: 400 invalid_request for a missing or malformed field; 401 actor_required without a trusted actor; 400 invalid_idempotency_key for a malformed idempotencyKey — with two documented divergences: a key over 128 characters is refused during request validation with 400 invalid_request before the service's check, and a blank idempotencyKey is refused there too, while the public header answers 400 invalid_idempotency_key for both shapes; 400 invalid_cwd for a lexical violation and 400 invalid_request for an expectedContextRevision below 1; 404 session_not_found for an unknown Session id; 400 unsupported_feature for an unbound Session; 404 session_not_found for an unreadable Session and 403 session_operation_forbidden when a readable actor is not the creator; 409 idempotency_conflict when one key carries different content; 409 workspace_unavailable when execution is disabled; 404 session_not_found for a deleted Session — a completed change under the same key still replays instead; then 409 session_state_conflict, 409 workspace_unavailable from moved Registry facts, 409 context_revision_conflict and 409 session_context_busy exactly like the public surface. Poll the operation or await session.context.changed; do not treat 202 as activation. */
+        post: operations["webShellChangeCwd"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/agent/web-shell/v1/operations/query": {
         parameters: {
             query?: never;
@@ -207,7 +224,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Uses the same close admission, creator authorization and durable cleanup semantics as the public close route. sessionClose describes deployment support; it does not grant actor authorization. */
+        /** @description Uses the same close admission, creator authorization and durable cleanup semantics as the public close route. sessionClose describes deployment support; it does not grant actor authorization. New L3 Workspace close operations run SessionEnd only, retain data, and finish after durable effects verification and original Runtime stop. SessionDelete is reserved for ACTIVE delete. Missing protocol support rejects new admission; previously admitted operations retain their saved protocol. Unknown outcomes remain recovery_blocked. */
         post: operations["closeWebShellSession"];
         delete?: never;
         options?: never;
@@ -241,7 +258,7 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** @description Workspace-bound delete accepts only closed or archived Sessions with completed reliable-close evidence and the creator with current read access. Active deletion returns 409 session_state_conflict. Completion atomically retires private recovery/publication access with the tombstone, operation receipt and terminal event; it calls neither Harness nor Runtime and erases no shared Workspace files or backup bytes. Operations remain readable under current read grants; the same authorized actor/key can replay after deletion. A readable non-creator returns 403; missing close evidence returns 409 workspace_unavailable. */
+        /** @description Workspace-bound ACTIVE deletion supports idle hosted-workspace-files/1 Sessions when L3 lifecycle protocol and reliable Runtime stop are available. Only the creator with current read access may admit it; accepted, running, cancelling or approval-waiting Turns return 409 turn_active. Admission persists a lifecycle-only execution fence and a versioned actor-scoped operation. SessionEnd settles before SessionDelete; committed Hook results are verified in Session Store and saved before permanent draining, attachment cleanup and original worker stop. Unknown outcomes or missing original stop evidence remain recovery_blocked and are never replayed on a replacement worker. CLOSED/ARCHIVED deletion retains L2: completed reliable-close evidence is required and no Harness or Hook is invoked. Completion atomically commits retirement, tombstone, receipt and terminal event, retaining shared Workspace files and neighboring holders. Authorized same-actor/key replays return the original operation, including after deletion; readable non-creators return 403. Missing lifecycle capability or close evidence returns 409 workspace_unavailable. */
         post: operations["deleteWebShellSession"];
         delete?: never;
         options?: never;
@@ -298,6 +315,22 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/agent/web-shell/v1/tasks/events/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["queryWebShellTaskEvents"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/agent/web-shell/v1/tool-results/get": {
         parameters: {
             query?: never;
@@ -495,10 +528,10 @@ export interface components {
             /** @default false */
             actions: boolean;
             /**
-             * @description True when the caller may submit later Turns of this Workspace-bound Session, cancel its running Turns and rename it: the deployment enables Workspace files, the caller created the Session and currently holds Workspace read and create grants on a registry row whose state is ACTIVE, and the Session is an active qwen-code Session on the frozen execution profile. False for every other caller and for unbound Sessions, which do not use it.
+             * @description True when the caller may submit later Turns of this Workspace-bound Session: the deployment enables Workspace files, the caller created the Session and currently holds Workspace read and create grants on a registry row whose state is ACTIVE and still carries the Workspace generation and storage identity the Session was bound to, and the Session is an active, undeleted qwen-code Session on the frozen execution profile. Cancelling only aborts work that is already running, so the creator may cancel a running Turn even when this is false, as long as they can still read the Workspace and the deployment still enables Workspace files. False for every other caller and for unbound Sessions, which do not use it.
              * @default false
              */
-            workspaceTurns?: boolean;
+            workspaceTurns: boolean;
             tasks: boolean;
             artifacts: boolean;
             /**
@@ -517,7 +550,7 @@ export interface components {
              */
             sessionUnarchive?: boolean;
             /**
-             * @description Optional support for this retention operation. For a Workspace-bound Session requires completed reliable-close evidence; authorization and source-state validation still apply.
+             * @description Optional support capability. ACTIVE Workspace files Sessions require L3 lifecycle protocol and reliable original Runtime stop; CLOSED/ARCHIVED Sessions use independent L2 close evidence. Current creator/read authorization and idle/source-state admission checks still apply. The aggregate session lifecycle capability is unchanged.
              * @default false
              */
             sessionDelete?: boolean;
@@ -607,6 +640,8 @@ export interface components {
                 code: string;
                 message: string;
                 request_id: string;
+                /** @description Present on Runtime Broker refusals; true permits retry, false is a definite refusal. Other errors may omit this field. */
+                retryable?: boolean;
                 /** Format: int64 */
                 replay_floor_sequence?: number | null;
                 /** Format: int64 */
@@ -619,6 +654,8 @@ export interface components {
          * @example services/api
          */
         WorkspaceRelativePath: string;
+        /** @enum {string} */
+        CwdOperationStatus: "pending" | "installing" | "completed" | "failed";
         WebShellWorkspaceSelection: {
             workspaceId: string;
             /** @default . */
@@ -661,11 +698,36 @@ export interface components {
                 canCreateSession?: true;
             }) | null;
         };
+        WebShellChangeCwdRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            idempotencyKey: string;
+            cwdRelative: components["schemas"]["WorkspaceRelativePath"];
+            /** Format: int64 */
+            expectedContextRevision: number;
+            requestId?: string | null;
+        };
         WebShellOperationRequest: {
             /** Format: uuid */
             sessionId: string;
             operationId: string;
         };
+        /** @description A completed operation returns the committed target revision. A replay returns the same operation identity and latest durable status, with replayed=true; polling itself is not replay. */
+        WebShellCwdOperation: {
+            operationId: string;
+            /** Format: uuid */
+            sessionId: string;
+            /** @constant */
+            type: "cwd_change";
+            status: components["schemas"]["CwdOperationStatus"];
+            /** Format: int64 */
+            expectedContextRevision: number;
+            targetCwdRelative: components["schemas"]["WorkspaceRelativePath"];
+            /** Format: int64 */
+            resultContextRevision?: number | null;
+            failureCode?: string | null;
+            replayed: boolean;
+        } & (unknown & unknown);
         WebShellAction: components["schemas"]["WebShellPermissionAction"] | components["schemas"]["WebShellQuestionAction"];
         WebShellActionResolution: {
             actionId: string;
@@ -728,7 +790,7 @@ export interface components {
             decisionReceiptId?: string;
             questions: components["schemas"]["WebShellActionQuestion"][];
         } & unknown;
-        /** @description At most one requested Hosted approval per Turn. allow and deny are stable option IDs. Tool arguments are read from Items by function_call_id (functionCallId in WebShell). Public timestamps are milliseconds, as recorded by the Harness. Decision receipts are opaque product IDs. */
+        /** @description At most one requested Hosted approval per Turn. allow and deny are stable option IDs. A requested native-tool Action may carry a bounded input preview when the producer supplies an input reference. Version 1 Actions and unavailable inputs omit it. Public timestamps are milliseconds, as recorded by the Harness. Decision receipts are opaque product IDs. */
         WebShellPermissionAction: {
             actionId: string;
             /** Format: uuid */
@@ -750,6 +812,7 @@ export interface components {
             turnId?: string;
             functionCallId: string;
             toolName: string;
+            inputPreview?: components["schemas"]["WebShellActionInputPreview"];
         } & unknown;
         WebShellPermissionResponse: {
             /** @constant */
@@ -784,7 +847,7 @@ export interface components {
             policyRevision: string;
             answers: components["schemas"]["WebShellQuestionAnswer"][];
         };
-        WebShellOperation: components["schemas"]["WebShellCommandOperation"];
+        WebShellOperation: components["schemas"]["WebShellCwdOperation"] | components["schemas"]["WebShellCommandOperation"];
         WebShellActionQueryRequest: {
             /** Format: uuid */
             sessionId: string;
@@ -863,6 +926,8 @@ export interface components {
              * @description Unix epoch milliseconds.
              */
             settledAt?: number;
+            /** @description Stable task event cursor after the committed tail at view read time. No event can later appear at or before it. Pass it as after to follow only new events; recovery must instead keep its saved event page cursor so it does not skip intervening output. Normal retention may expire it. */
+            outputCursor?: string;
             /** @description The newest Artifacts that hold durable task output, at most 100, oldest first. Entries must not rotate out until older Artifacts can be enumerated and attributed to the task: an evicted Artifact stays readable by id through the Session artifact routes but is no longer discoverable from the task. */
             artifactRefs: string[];
             actionCapabilities: components["schemas"]["TaskActionCapability"][];
@@ -872,6 +937,31 @@ export interface components {
             hasMore: boolean;
             nextCursor?: string | null;
         } & unknown;
+        /** @description One task event: a logical state change, a bounded output chunk, or an Artifact reference. High-volume output goes to Artifacts or bounded chunks in this paged stream, never one Session event per raw line. The closed schema validates the server's own version; clients ignore unknown optional fields and unknown types and checkpoint their cursors. Strict response validation against an older minor version is not supported. Event identity, position, payload and accepted schema/projection versions are immutable across restart, projection rebuild and archival. */
+        WebShellTaskEvent: {
+            schemaVersion: number;
+            projectionVersion: number;
+            taskId: string;
+            /** Format: uuid */
+            sessionId: string;
+            type: components["schemas"]["TaskEventType"];
+            /** @description Stable opaque position after this event and its identity. Atomically apply the event and save this cursor to avoid duplicate application after a crash. It is never reassigned; normal retention can expire it. */
+            cursor: string;
+            /** Format: int64 */
+            createdAt: number;
+            state?: components["schemas"]["TaskState"];
+            runtimeState?: components["schemas"]["TaskRuntimeState"];
+            text?: string;
+            /** @description True when the chunk was cut to the event limit; its full output is already durably readable and discoverable in the task Artifacts when the event is published. */
+            truncated?: boolean;
+            artifactId?: string;
+        } & (unknown & unknown & unknown);
+        WebShellTaskEventPage: {
+            data: components["schemas"]["WebShellTaskEvent"][];
+            hasMore: boolean;
+            /** @description The last returned event cursor, never passing an event held back by limit. On an empty page, the requested position, or the durable retention floor if after was omitted. Required and never null, including when no events remain. No event may later become visible at or before this position. */
+            nextCursor: string;
+        };
         WebShellTaskQueryRequest: {
             /** Format: uuid */
             sessionId: string;
@@ -884,6 +974,17 @@ export interface components {
             sessionId: string;
             taskId: string;
         };
+        WebShellTaskEventQueryRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            taskId: string;
+            /** @description Opaque task event cursor: an event cursor, a page nextCursor or a task outputCursor. Omit it to read from the durable retention floor. Strictly below the floor is 409 cursor_expired; equality is valid, including with no retained events. */
+            after?: string;
+            /** @default 20 */
+            limit?: number;
+        };
+        /** @description state_changed, output or artifact. The set is open: a later minor version may add types and optional fields. Clients ignore unknown optional fields and unknown types, while still checkpointing event cursors; strict validation against an older minor response schema is not supported. Existing fields forbidden for a known type cannot be repurposed on that type. */
+        TaskEventType: string;
         ToolResultPreview: {
             text: string;
             truncated: boolean;
@@ -948,6 +1049,18 @@ export interface components {
             /** @default 20 */
             limit?: number;
         };
+        /** @description Optional preview for requested native read_file, write_file, edit or run_shell_command approvals. Missing or invalid input, and internal MCP inputs, omit the preview. No general secret redaction is performed; visibility follows Session read permissions. Deploy the version 2 Java reader before a Harness producer starts writing version 2 options. */
+        WebShellActionInputPreview: {
+            /** @description Exact prefix of the stored payloadJson ({toolName,input}), at most 8192 UTF-8 bytes ending at a complete code point. Truncated text may not be valid JSON. */
+            text: string;
+            /** @description True when text is shorter than the complete UTF-8 input. */
+            truncated: boolean;
+            /**
+             * Format: int64
+             * @description Byte length of the complete payloadJson in UTF-8, before truncation.
+             */
+            byteLength: number;
+        };
     };
     responses: {
         /** @description The authenticated actor belongs to another tenant than X-Qwen-Tenant-Id or has an invalid ID (actor_scope_mismatch, which the tenant filter answers on every /v1/agents/ and WebShell route), or the resource is readable but the actor lacks this operation or the original Action responder permission. Artifact content reads may also return artifact_content_forbidden when the actor cannot read the original bytes. */
@@ -986,7 +1099,7 @@ export interface components {
                 "application/json": components["schemas"]["ErrorEnvelope"];
             };
         };
-        /** @description State, idempotency, or recovery conflict. */
+        /** @description State, idempotency, or recovery conflict. New Workspace-scoped admissions return workspace_unavailable with retryable=false while an offline Workspace migration holds the storage fence; authorized durable replays retain their existing behavior. */
         Conflict: {
             headers: {
                 [name: string]: unknown;
@@ -1004,6 +1117,15 @@ export interface components {
                 "application/json": components["schemas"]["ErrorEnvelope"];
             };
         };
+        /** @description Task event cursor is strictly below the task's durable retention floor, which survives an empty retained set; equality is valid. The envelope's replay_floor_sequence and snapshot_through_sequence stay absent because task cursors are opaque. */
+        TaskCursorExpired: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
         /** @description A dependency such as the Hosted Harness is unavailable; retry later. */
         Unavailable: {
             headers: {
@@ -1264,6 +1386,36 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
+    webShellChangeCwd: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellChangeCwdRequest"];
+            };
+        };
+        responses: {
+            /** @description Durable cwd operation; acceptance does not mean the new cwd is active. */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellCwdOperation"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
     webShellQueryCwdOperation: {
         parameters: {
             query?: never;
@@ -1566,6 +1718,36 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
+    queryWebShellTaskEvents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellTaskEventQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Same authorized task semantics as the public task events route, including the durable retention floor, committed-prefix publication, Artifact recovery order and client tolerance of unknown optional fields and event types. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellTaskEventPage"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["TaskCursorExpired"];
+            413: components["responses"]["PayloadTooLarge"];
+        };
+    };
     getWebShellToolResult: {
         parameters: {
             query?: never;

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

@@ -58,6 +58,8 @@ export declare class JavaManagedAgentClient {
     cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
     queryActions(request: Schemas['WebShellActionQueryRequest'], signal?: AbortSignal): Promise<JavaAgentActionPage>;
     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']>;
     getToolResult(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
         result: components["schemas"]["PublicToolResult"];
         access: components["schemas"]["ArtifactAccess"];
@@ -78,7 +80,7 @@ export declare class JavaManagedAgentClient {
     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): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
+    streamEvents(request: Schemas['WebShellStreamRequest'], signal?: AbortSignal, onOpen?: () => void): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
     private post;
     private request;
 }

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

@@ -1,3 +1,4 @@
+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';
@@ -75,6 +76,7 @@ export interface ManagedAgentPendingAction {
         id: string;
         label: string;
     }>;
+    inputPreview?: components['schemas']['WebShellActionInputPreview'];
 }
 export interface ManagedAgentProvider {
     readonly kind: 'daemon' | 'java';
@@ -130,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/messages/AssistantMessage.d.ts

@@ -1,9 +1,11 @@
 import { type WebShellAssistantFeedbackRating, type WebShellAssistantTurnFooterRenderInfo, type WebShellSource } from '../../customization';
-import type { DaemonSessionGenerationEvent } from '@qwen-code/sdk/daemon';
+import type { DaemonSessionGenerationEvent, QwenAgentMessageMeta } from '@qwen-code/sdk/daemon';
 import type { DaemonMessageAuthor } from '../../adapters/messageTypes';
 interface AssistantMessageProps {
     content: string;
     author?: DaemonMessageAuthor;
+    /** A workspace agent's reply: its run status, error, steps and tokens. */
+    agentMessage?: QwenAgentMessageMeta;
     isStreaming?: boolean;
     timestamp?: number;
     onBranchSession?: () => void | Promise<void>;

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

@@ -1,6 +1,6 @@
 import type { DaemonInputAnnotation } from '@qwen-code/sdk/daemon';
 import type { ComposerTagClickHandler, ComposerTagRenderer, WebShellComposerTag, WebShellComposerTagIconMap } from '../../customization';
-import type { AttachmentPreviewRequest } from '../../adapters/messageTypes';
+import type { AttachmentPreviewRequest, DaemonMessageAuthor } from '../../adapters/messageTypes';
 import type { ImageTabSource } from '../artifacts/ArtifactPanel';
 interface UserMessageImage {
     data: string;
@@ -32,6 +32,8 @@ interface UserMessageProps {
     /** Click an uploaded image to preview it in the right panel. */
     onImagePreview?: (src: string, alt?: string, source?: ImageTabSource) => void;
     onAttachmentPreview?: (file: AttachmentPreviewRequest) => void;
+    /** Set when a workspace agent, not the user, posted this message. */
+    author?: DaemonMessageAuthor;
 }
 export declare const UserMessage: import("react").NamedExoticComponent<UserMessageProps>;
 export declare function ReadonlyComposerTag({ tag, composerTagIcons, renderComposerTag, renderComposerTagTooltip, onComposerTagClick, title, preserveCustomKindLabel, }: {

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

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { QwenAgentMessageMeta, SessionAgentStep } from '@qwen-code/sdk/daemon';
+/** True when an agent's text shows nothing: render it as no text at all. */
+export declare function isBlankAgentText(text: string): boolean;
+/**
+ * One line per tool call an agent made, like a CI job's step list. Shared by
+ * the live run card and the finished reply, so a run reads the same before
+ * and after its record lands.
+ *
+ * Renders in exported transcripts: only `agentMessage.*` strings (i18n.tsx),
+ * never the collaboration dictionary.
+ */
+export declare function AgentStepList({ steps, label, settled, }: {
+    steps: readonly SessionAgentStep[];
+    label?: string;
+    /**
+     * The run has ended (completed, failed, stopped, offline). A step still
+     * marked running then never finished; show it as stopped, not spinning.
+     */
+    settled?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;
+/** "1,234 tokens", or nothing when the run reported no usage. */
+export declare function AgentTokenUsage({ totalTokens }: {
+    totalTokens?: number;
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Status, error, steps and token usage of a finished agent reply. A completed
+ * run shows no status word: its text is the result.
+ */
+export declare function AgentMessageDetails({ meta }: {
+    meta: QwenAgentMessageMeta;
+}): import("react/jsx-runtime").JSX.Element | null;