@qwen-code/web-shell 0.25.0 → 0.25.1-nightly.20261012.18f80f5666

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

@@ -57,7 +57,47 @@ export declare class JavaManagedAgentClient {
     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']>;
     getToolResult(sessionId: string, itemId: string, signal?: AbortSignal): Promise<{
         result: components["schemas"]["PublicToolResult"];
         access: components["schemas"]["ArtifactAccess"];
@@ -78,7 +118,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, onAlive?: () => 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';
@@ -9,6 +10,8 @@ export interface ManagedAgentSessionSummary {
     workspace?: {
         workspaceId: string;
         cwdRelative: string;
+        contextRevision?: number;
+        state?: 'ready' | 'changing' | 'recovery_blocked';
     };
     createdAt: number;
     admittedAt: number;
@@ -20,16 +23,18 @@ 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;
     };
     failure?: {
         code: string;
         message: string;
     };
 }
-export type ManagedAgentSessionEventType = 'accepted' | 'runtime_starting' | 'runtime_ready' | 'runtime_failed' | 'runtime_released' | 'agent_started' | 'assistant_thought' | 'assistant_delta' | 'tool_requested' | 'tool_started' | 'tool_completed' | 'tool_result_updated' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'action_updated' | 'stream_gap';
+export type ManagedAgentSessionEventType = 'accepted' | 'runtime_starting' | 'runtime_ready' | 'runtime_failed' | 'runtime_released' | 'agent_started' | 'assistant_thought' | 'assistant_delta' | 'tool_requested' | 'tool_started' | 'tool_completed' | 'tool_result_updated' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'action_updated' | 'context_changed' | 'stream_gap';
 export interface ManagedAgentSessionEvent {
     id: number;
     at: number;
@@ -60,6 +65,14 @@ export interface ManagedAgentRequestOptions {
 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';
+};
 /** A Hosted tool approval waiting for the Session owner's answer. */
 export interface ManagedAgentPendingAction {
     actionId: string;
@@ -75,6 +88,7 @@ export interface ManagedAgentPendingAction {
         id: string;
         label: string;
     }>;
+    inputPreview?: components['schemas']['WebShellActionInputPreview'];
 }
 export interface ManagedAgentProvider {
     readonly kind: 'daemon' | 'java';
@@ -87,6 +101,28 @@ 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;
+            expectedContextRevision: number;
+        }, options: ManagedAgentCommandOptions): Promise<ManagedCwdOperation>;
+        query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedCwdOperation>;
+    };
     readonly workspaceBinding?: {
         readonly agentId: string;
         list(options: ManagedAgentRequestOptions & {
@@ -130,6 +166,19 @@ 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;
+        /**
+         * Called for each complete heartbeat or comment frame the stream
+         * delivers. Heartbeats never decode into events, so on an idle
+         * Session this is the only sign of life an established stream gives.
+         */
+        onAlive?(): void;
     }): AsyncIterable<ManagedAgentSessionEvent>;
 }
 export interface ManagedAgentWorkspace {

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

@@ -12,3 +12,9 @@
  * are worth another attempt.
  */
 export declare function isNonRetryableClientError(error: unknown): boolean;
+/**
+ * A 401/403. This client re-derives its credentials on every request, so an
+ * expired short-lived token gets a fresh answer on the very next attempt
+ * once the host refreshes — never a terminal condition.
+ */
+export declare function isAuthFailure(error: unknown): boolean;

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/use-managed-actions.d.ts

@@ -12,11 +12,12 @@ export interface ManagedActionsState {
     /** Sending an answer failed; the approval is shown again. */
     answerError?: unknown;
     /**
-     * The service refused an answer as creator-only. That is a fact about the
-     * viewer and the Session, not about one Action, so it outlives the refused
-     * Action, covers every later approval the same Session raises, and survives
-     * leaving that Session and coming back. It is remembered per mount: a reload
-     * or reopening the panel starts clean.
+     * The service refused an answer under the owner-or-Workspace-operator
+     * rule. That refusal is a fact about the viewer's Workspace role row,
+     * which an operator can raise while the page stays open, so the latch
+     * covers every later approval the same Session raises and survives
+     * leaving that Session and coming back — but `retry()` drops it and
+     * re-probes instead of treating one 403 as permanent for the mount.
      */
     respondForbidden: boolean;
     respond(actionId: string, optionId: string): Promise<void>;

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

@@ -0,0 +1,21 @@
+import type { ManagedAgentProvider, ManagedAgentSessionSummary } from './managed-agent-provider';
+interface CwdIntent {
+    sessionId: string;
+    workspaceId: string;
+    cwdRelative: string;
+    expectedContextRevision: number;
+    idempotencyKey: string;
+    operationId?: string;
+}
+export declare function useManagedCwdChange(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>): {
+    blocked: boolean;
+    submit: (cwdRelative: string, expectedContextRevision: number) => Promise<true | undefined>;
+    confirm: () => Promise<void>;
+    isBlocked: () => boolean;
+    key: string;
+    pending?: CwdIntent;
+    busy: boolean;
+    errorCode?: string;
+    target?: string;
+};
+export {};

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

@@ -1,12 +1,26 @@
 import type { ManagedAgentProvider, ManagedAgentSessionEvent, ManagedAgentSessionSummary } from './managed-agent-provider';
+type SignalLeg = 'session' | 'transcript' | 'stream';
+interface SignalEntry {
+    readonly message: string;
+    readonly final: boolean;
+    readonly seq: number;
+    readonly leg: SignalLeg;
+    readonly stall?: boolean;
+}
+export declare function failureRetryDelayMs(failures: number): number;
 export declare function useManagedSession(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined): {
+    stoppedReason: string | undefined;
+    stoppedLeg: SignalLeg | undefined;
+    error: string | undefined;
     loadingOlder: boolean;
     loadOlder: () => Promise<void>;
     reload: () => void;
+    refreshSummary: (signal?: AbortSignal) => Promise<ManagedAgentSessionSummary | undefined>;
     sessionId?: string;
     summary?: ManagedAgentSessionSummary;
     events: ManagedAgentSessionEvent[];
     olderCursor?: string;
     loading: boolean;
-    error?: string;
+    signals?: Partial<Record<SignalLeg, SignalEntry>>;
 };
+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/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/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/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/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;

package/dist/types/components/messages/squad-tag.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * "This belongs to squad X": a small muted pill, the squad's counterpart to
+ * AuthorAvatar. Used on a leader's and a member's author line, the leader's
+ * no-action line and the live engagement bar, so a reader learns it once.
+ *
+ * Renders in exported transcripts: no collaboration strings here.
+ */
+export declare function SquadTag({ name, className, }: {
+    name: string;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

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/sidebar/WebShellSidebar.d.ts

@@ -58,8 +58,6 @@ export interface WebShellSidebarWorkspaceOverviewOptions {
 }
 export type { WorkspaceManagementTarget, WorkspaceOverviewItem };
 interface WebShellSidebarProps {
-    selectedCollaborationId?: string;
-    onOpenCollaboration?: (id: string, cwd: string) => void;
     collapsed: boolean;
     layout?: 'single' | 'rail';
     activePage?: string;
@@ -67,7 +65,7 @@ interface WebShellSidebarProps {
     onOpenHome?: () => void;
     onCollapsedChange: (collapsed: boolean) => void;
     onOpenSettings: () => void;
-    onOpenAgents?: (view?: 'agents' | 'tasks' | 'runtime') => void;
+    onOpenAgents?: (view?: 'agents' | 'squads' | 'runtime') => void;
     onOpenPlugins: () => void;
     onOpenChannels: () => void;
     onOpenLive?: () => void;
@@ -91,6 +89,12 @@ interface WebShellSidebarProps {
     onNewSession: (workspaceCwd?: string) => Promise<boolean> | boolean;
     onNewStandaloneSession?: () => Promise<boolean> | boolean;
     onLoadSession: (sessionId: string, workspaceCwd?: string) => Promise<void> | void;
+    /**
+     * Opens a session listed by a fan-out host group (#13727): the caller
+     * focuses that host in-app and loads the session there. When absent, the
+     * groups fall back to full navigation via `openHostedWorkspace`.
+     */
+    onOpenHostSession?: (origin: string, sessionId: string, workspaceCwd?: string) => void;
     onSelectCurrentSession?: () => void;
     onSessionRenameConfirmed?: (workspaceCwd: string | undefined, sessionId: string, displayName: string) => void;
     /**
@@ -158,4 +162,4 @@ interface WebShellSidebarProps {
     onLoadStandaloneSession?: (sessionId: string) => Promise<void> | void;
     onStandaloneNotice?: (message: string) => void;
 }
-export declare function WebShellSidebar({ selectedCollaborationId, onOpenCollaboration, collapsed, layout, activePage, containerWidth, onOpenHome, onCollapsedChange, onOpenSettings, onOpenAgents, onOpenPlugins, onOpenChannels, onOpenLive, onLiveVoiceSlotChange, onOpenManagedSessions, onOpenDaemonStatus, onOpenScheduledTasks, onOpenWorkflows, onOpenGoals, onOpenSessions, canOpenSessionsOverview, onOpenWorkspacesOverview, onOpenSplitView, canOpenSplitView, onNewSession, onNewStandaloneSession, onLoadSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;
+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;

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

@@ -9,8 +9,15 @@ export interface WorkspaceHeaderActionsContext {
     gitBranch: string | null | undefined;
 }
 interface WorkspaceSectionProps {
-    additionalSessions?: readonly DaemonSessionSummary[];
     workspace: DaemonWorkspaceCapability;
+    /**
+     * localStorage seed for the expansion/collapsed-group preferences,
+     * defaulting to the workspace id. Multi-host renderers pass an
+     * origin-prefixed id so two daemons hosting the same workspace id
+     * never share a preference; single-host callers leave it unset and
+     * keep the keys they always had.
+     */
+    storageKey?: string;
     remote?: boolean;
     renderHeader?: (expanded: boolean) => ReactNode;
     hideHeader?: boolean;
@@ -118,5 +125,5 @@ interface WorkspaceSectionProps {
     /** Commit entry for the same picker; the row still opens without it. */
     onOpenCommit?: (workspaceCwd: string) => void;
 }
-export declare function WorkspaceSection({ additionalSessions, workspace, remote, renderHeader, hideHeader, client, reloadToken, untrustedLabel, readOnlyLabel, trustToOpenLabel, noSessionsLabel, loadErrorLabel, organizationEnabled, sessionCatalogRequestsEnabled, sessionGroupCatalog, sessionLiveStateEnabled, sourceType, channelGroupingEnabled, ungroupedLabel, searchQuery, expanded: controlledExpanded, autoExpandKey, forceAutoExpand, onExpandedChange, renderSessions, renderSession, pendingSession, mapSession, showSessionDetails, headerActions, overviewEnabled, overviewMenuOpen, overviewItems, gitBranchWanted, sessionStats, onRenameGroup, onDeleteGroup, renameGroupLabel, deleteGroupLabel, groupActionsDisabled, excludePinned, limitSessions, isPinnedSectionMember, onOpenPathLocally, onOpenTerminalLocally, onOpenGitDiff, onOpenCommit, }: WorkspaceSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function WorkspaceSection({ workspace, storageKey, remote, renderHeader, hideHeader, client, reloadToken, untrustedLabel, readOnlyLabel, trustToOpenLabel, noSessionsLabel, loadErrorLabel, organizationEnabled, sessionCatalogRequestsEnabled, sessionGroupCatalog, sessionLiveStateEnabled, sourceType, channelGroupingEnabled, ungroupedLabel, searchQuery, expanded: controlledExpanded, autoExpandKey, forceAutoExpand, onExpandedChange, renderSessions, renderSession, pendingSession, mapSession, showSessionDetails, headerActions, overviewEnabled, overviewMenuOpen, overviewItems, gitBranchWanted, sessionStats, onRenameGroup, onDeleteGroup, renameGroupLabel, deleteGroupLabel, groupActionsDisabled, excludePinned, limitSessions, isPinnedSectionMember, onOpenPathLocally, onOpenTerminalLocally, onOpenGitDiff, onOpenCommit, }: WorkspaceSectionProps): import("react/jsx-runtime").JSX.Element;
 export {};