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

package/dist/types/components/workspace-agents/squads-section.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionSquadView } from '@qwen-code/sdk/daemon';
+import type { WorkspaceAgentSummaryView } from './ThreadsPage';
+import type { SquadInput } from './threads-api';
+export interface SquadsSectionProps {
+    squads: readonly SessionSquadView[];
+    agents: readonly WorkspaceAgentSummaryView[];
+    pending?: boolean;
+    /** The New squad form is open (its button is in the page header). */
+    creating: boolean;
+    onCreatingChange: (creating: boolean) => void;
+    onCreate: (input: SquadInput) => Promise<boolean>;
+    onUpdate: (squadId: string, input: SquadInput) => Promise<boolean>;
+    onRetire: (squadId: string) => void;
+    /** Puts `@name ` into the chat composer; absent hides the button. */
+    onMention?: (name: string) => void;
+}
+/** No squads (or a daemon without squad routes). */
+export declare function SquadsEmpty(): import("react/jsx-runtime").JSX.Element;
+/**
+ * The Agents page's Squads view: list, create, edit, retire. A squad is
+ * addressed by `@name` in a chat, which wakes its leader (session-multi-agent design §11.5).
+ */
+export declare function SquadsSection({ squads, agents, pending, creating, onCreatingChange, onCreate, onUpdate, onRetire, onMention, }: SquadsSectionProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/threads-api.d.ts

@@ -3,61 +3,50 @@
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { AgentCapabilitiesView, AgentConfigPatch, NewThread, NewWorkspaceAgent, WorkspaceAgentRuntimeView, WorkspaceAgentSummaryView } from './ThreadsPage';
-import type { ThreadDetailView } from './ThreadView';
-import type { RoutingPreviewTarget, ThreadSummaryView } from './agents-view-logic';
-import { type AgentLiveEvent, type AgentStreamState } from './agent-events';
-import type { JoinToken } from './add-runtime-dialog';
+import type { AgentConfigPatch, NewWorkspaceAgent, WorkspaceAgentRuntimeView, WorkspaceAgentSummaryView } from './ThreadsPage';
+import type { ConnectExistingInput, JoinCoordinatorInput, JoinToken } from './add-runtime-dialog';
 import type { AgentShare, AgentShareSummary } from './share-agent-dialog';
-interface CreateThreadResult {
-    id: string;
+import type { SessionSquadView } from '@qwen-code/sdk/daemon';
+/** Body of a squad create; on update, `null` clears a text field. */
+export interface SquadInput {
+    name: string;
+    description: string | null;
+    instructions: string | null;
+    leaderAgentId: string;
+    members: Array<{
+        agentId: string;
+        role?: string;
+    }>;
 }
+/** Agent roster, runtimes, enrollment and sharing for one workspace. */
 export interface ThreadsApi {
-    connectRemoteHost?(input: {
-        remoteUrl: string;
-        remoteToken: string;
-        remoteCwd: string;
-        serverUrl: string;
-        provider: 'qwen';
-        allowHttp: boolean;
-    }): Promise<unknown>;
+    connectRemoteHost?(input: ConnectExistingInput): Promise<unknown>;
+    /** Makes this daemon a runtime of another coordinator. */
+    joinCoordinator?(input: JoinCoordinatorInput): Promise<unknown>;
     listAgents(): Promise<{
         agents: WorkspaceAgentSummaryView[];
         runtime?: WorkspaceAgentRuntimeView;
         runtimes?: WorkspaceAgentRuntimeView[];
-        capabilities?: AgentCapabilitiesView;
     }>;
     /** A single-use token for `qwen serve --join` on another machine. */
-    createJoinToken?(): Promise<JoinToken>;
+    createJoinToken?(supersedesHostId?: string): Promise<JoinToken>;
     removeHost?(hostId: string): Promise<unknown>;
     createShare?(agentId: string): Promise<AgentShare>;
     listShares?(agentId: string): Promise<{
         shares: AgentShareSummary[];
     }>;
     revokeShare?(agentId: string, callerId: string): Promise<unknown>;
-    listThreads(): Promise<{
-        threads: ThreadSummaryView[];
-    }>;
-    getThread(id: string): Promise<ThreadDetailView>;
     createAgent(input: NewWorkspaceAgent): Promise<unknown>;
     deleteAgent(id: string): Promise<unknown>;
     setAgentEnabled(id: string, enabled: boolean): Promise<unknown>;
     updateAgent(id: string, patch: AgentConfigPatch): Promise<unknown>;
-    createThread(input: NewThread): Promise<CreateThreadResult>;
-    previewThread(assignee?: string): Promise<{
-        targets: RoutingPreviewTarget[];
-    }>;
-    assignThread(id: string, assignee?: string): Promise<unknown>;
-    previewReply(id: string, text: string): Promise<{
-        targets: RoutingPreviewTarget[];
+    /** Squads; absent on a daemon without them. */
+    listSquads?(): Promise<{
+        squads: SessionSquadView[];
     }>;
-    postReply(id: string, text: string): Promise<unknown>;
-    markDone(id: string): Promise<unknown>;
-    cancelRun(threadId: string, runId: string): Promise<unknown>;
-    /** Live events; absent in tests and older daemons, which then poll. */
-    subscribe?(onEvent: (event: AgentLiveEvent) => void, onState: (state: AgentStreamState) => void): () => void;
-    /** Answers a tool approval an agent is waiting on. */
-    respondToPermission?(sessionId: string, requestId: string, optionId: string): Promise<unknown>;
+    createSquad?(input: SquadInput): Promise<unknown>;
+    updateSquad?(id: string, input: Partial<SquadInput>): Promise<unknown>;
+    /** Retires the squad (it keeps its name and history). */
+    retireSquad?(id: string): Promise<unknown>;
 }
 export declare function createThreadsHttpApi(baseUrl: string, token: string | undefined, workspaceCwd: string): ThreadsApi;
-export {};

package/dist/types/components/workspace-agents/use-session-agent-runs.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonTranscriptBlock, type SessionAgentRunFrame, type SessionAgentRunStatus } from '@qwen-code/sdk/daemon';
+import type { SessionAgentsApi } from './session-agents-api';
+export declare function isTerminalRunStatus(status: SessionAgentRunStatus): boolean;
+/**
+ * The runs whose `agent_message` is already in the transcript, as one string
+ * (run ids joined by newlines) so a caller can memoize a Set on it: the blocks
+ * change on every streamed delta, the answer almost never.
+ */
+export declare function settledAgentRunKey(blocks: readonly DaemonTranscriptBlock[]): string;
+interface TrackedFrame {
+    frame: SessionAgentRunFrame;
+    /** Arrival order, so the list does not reshuffle as frames update. */
+    order: number;
+    /**
+     * The run is off the screen for good: its record is in the transcript, or
+     * none will be written. Kept, slimmed, so that a stale snapshot cannot put
+     * the card back.
+     */
+    settled?: true;
+}
+export type RunFrameMap = ReadonlyMap<string, TrackedFrame>;
+/**
+ * Whether a frame ends the run's card (contract `recorded`): a terminal frame
+ * keeps it only while `recorded` is `false` (record pending, or the run is
+ * retryable). `true` means the record now renders; absent means none will be
+ * written (cancelled while queued, dismissed, retried).
+ */
+export declare function isSettledRunFrame(frame: SessionAgentRunFrame): boolean;
+/**
+ * Folds one frame into the map. A frame seen twice (the stream opens with a
+ * snapshot that a GET may already have delivered) is harmless; an older frame
+ * never overwrites a newer one, a terminal run never comes back to life, and
+ * a settled run stays settled (a snapshot polled before the record landed can
+ * arrive after the frame that settled it).
+ */
+export declare function applyRunFrame(current: RunFrameMap, frame: SessionAgentRunFrame, order: number): RunFrameMap;
+/**
+ * Settles runs whose `agent_message` the transcript already shows (it can
+ * land before the frame that says so). Returns `current` when nothing
+ * changed.
+ */
+export declare function pruneRunFrames(current: RunFrameMap, settledRunIds: ReadonlySet<string>): RunFrameMap;
+/**
+ * Live agent runs of one chat session: the `runs` snapshot, then the
+ * `session-events` stream. A run keeps its card, finished or not, until a
+ * frame settles it (see {@link isSettledRunFrame}) or its `agent_message`
+ * shows up in the transcript (`settledRunIds`), which is what replaces it on
+ * screen. A finished run whose record waits behind a main-model turn, or a
+ * run a daemon restart cut short, stays until then.
+ */
+export declare function useSessionAgentRuns({ api, sessionId, settledRunIds, }: {
+    api: SessionAgentsApi | undefined;
+    sessionId: string | undefined;
+    settledRunIds: ReadonlySet<string>;
+}): {
+    runs: SessionAgentRunFrame[];
+    anyLive: boolean;
+    /** Runs a `retryable` run again; rejects when the daemon refuses. */
+    retry: (runId: string) => Promise<void>;
+};
+export {};

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

@@ -2,27 +2,90 @@ import { type ComponentProps } from 'react';
 import type { ChatEditor } from '../ChatEditor';
 import type { WebShellAtProvider } from '../../customization';
 import type { useI18n } from '../../i18n';
+import { type SessionAgentsApi } from './session-agents-api';
+import type { WorkspaceAgentSummaryView } from './ThreadsPage';
+import { type DaemonTranscriptBlock, type SessionSquadView } from '@qwen-code/sdk/daemon';
 type Submit = ComponentProps<typeof ChatEditor>['onSubmit'];
 /**
- * The tail of the conversation an agent was mentioned from, so a thread
- * started mid-conversation does not begin blind.
+ * The @tokens of a message, lowercased. Same rules as core's parseMentions: no
+ * ASCII word character before `@`, so "请@迁移助手" counts and "a@b.dev" does
+ * not; a token followed by `/` is a path, not a mention.
  */
-export declare function conversationContext(messages: readonly {
-    role: string;
-    content?: unknown;
-}[]): string;
-export declare function useAgentChatEntry({ enabled, cwd, baseUrl, token, onSubmit, onOpen, onError, getContext, onCreateAgent, t, }: {
+export declare function mentionTokens(text: string): string[];
+/**
+ * The agents a message addresses, in mention order. A name may run into the
+ * next word in scripts without spaces ("@迁移助手看一下"); the longest name the
+ * token starts with wins. Same addressability predicate as the picker: an
+ * agent the server would skip must not divert the message.
+ */
+export declare function resolveMentionedAgents(tokens: readonly string[], agents: readonly WorkspaceAgentSummaryView[]): WorkspaceAgentSummaryView[];
+/** A 32px "people" mask: squads get an icon in the picker, agents none. */
+export declare const SQUAD_PICKER_ICON = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAVklEQVR42u2TMQ4AIAgD+f+ncXXRgKFWTC/pai8CZkKIJvgi1PKdRKlgRgDyU20ETkb1lwD0WqIPU88VdoaCOlsPhlo+S5QJOijU8rAEXeDGrggh3mEAQPbbJbEAqj0AAAAASUVORK5CYII=";
+/**
+ * The squads a message addresses, by the same token rules as
+ * {@link resolveMentionedAgents}. A token that names an agent exactly is the
+ * agent's, as on the daemon.
+ */
+export declare function resolveMentionedSquads(tokens: readonly string[], squads: readonly SessionSquadView[]): SessionSquadView[];
+/** The chat session an @-mention goes to, and the workspace it lives in. */
+export interface AgentMentionSession {
+    sessionId: string;
+    /** Unset: the hook's own `cwd`. */
+    workspaceCwd?: string;
+}
+/**
+ * An @-mention the daemon accepted but deferred behind a running main-model
+ * turn (`deferred: true`): its record, and so the user's message, only lands
+ * once that turn settles. Shown as the user's message until then.
+ */
+export interface PendingAgentMention {
+    /** The post's `clientMessageId`. */
+    id: string;
+    sessionId: string;
+    text: string;
+    /**
+     * Recorded mentions with this text the session already had, plus earlier
+     * pending ones, when it was posted: the record that settles this one is
+     * the next.
+     */
+    recordedBefore: number;
+}
+/**
+ * The text of each recorded @-mention (`agent_mention` user message) in the
+ * transcript, in order. Compare with {@link isPendingMentionRecorded}.
+ */
+export declare function recordedAgentMentionTexts(blocks: readonly DaemonTranscriptBlock[]): string[];
+/** True once the record of `mention` is among the recorded mention texts. */
+export declare function isPendingMentionRecorded(mention: PendingAgentMention, recordedTexts: readonly string[]): boolean;
+export declare function useAgentChatEntry({ enabled, cwd, baseUrl, token, sessionApi, sessionApiFor, ensureSession, onSubmit, onError, onCreateAgent, sessionId, recordedMentionTexts, t, }: {
     enabled: boolean;
     cwd?: string;
     baseUrl: string;
     token?: string;
+    /** The session routes of the same workspace (`cwd`). */
+    sessionApi?: SessionAgentsApi;
+    /**
+     * The session routes of another workspace, for a session that lives
+     * elsewhere. Defaults to the HTTP routes of that workspace.
+     */
+    sessionApiFor?: (workspaceCwd: string) => SessionAgentsApi;
+    /**
+     * The current chat session, creating it first when this is a new chat (the
+     * same lazy creation an ordinary first prompt goes through), with the
+     * workspace it was created in.
+     */
+    ensureSession: () => Promise<AgentMentionSession | string | undefined>;
     onSubmit: Submit;
-    onOpen: (id: string, cwd: string) => void;
     onError: (message: string) => void;
-    /** The conversation so far, when mentioning from a chat that has one. */
-    getContext?: () => string;
     /** Offered as the picker's last item: open the New agent page. */
     onCreateAgent?: () => void;
+    /** The session the chat shows; only its pending @-mentions are returned. */
+    sessionId?: string;
+    /**
+     * {@link recordedAgentMentionTexts} of that session's transcript, memoized:
+     * a pending @-mention is dropped once its record shows up here.
+     */
+    recordedMentionTexts?: readonly string[];
     /**
      * The caller's translator. App calls this hook above its I18nProvider, where
      * useI18n() would hand back the default that echoes keys.
@@ -32,5 +95,6 @@ export declare function useAgentChatEntry({ enabled, cwd, baseUrl, token, onSubm
     providers: WebShellAtProvider[];
     submit: (text: string, images?: import("../../adapters/promptTypes").PromptImage[], files?: import("../../adapters/promptTypes").PromptFile[], commitAccepted?: import("../../hooks/useComposerCore").ComposerSubmitCommit, metadata?: import("../../hooks/useComposerCore").ComposerSubmitMetadata) => boolean | void;
     pending: boolean;
+    pendingMentions: PendingAgentMention[];
 };
 export {};

package/dist/types/components/workspaces/HostLabel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Icon + short name for one daemon host: the page origin reads as "Local",
+ * anything else shows its URL host. Shared by the sidebar host groups and
+ * the composer workspace picker so every surface names hosts identically.
+ */
+export declare function HostLabel({ origin }: {
+    origin: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspaces/WorkspaceHostProjects.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Names the connected host above its live project list. Until another host is
+ * saved there is nothing to tell apart, so the plain list stays unlabeled.
+ */
+export declare function WorkspaceHostHeading(): import("react/jsx-runtime").JSX.Element | null;
+export type OpenHostSessionHandler = (origin: string, sessionId: string, workspaceCwd?: string) => void;
+/**
+ * Live projects on the other hosts, grouped by host among the focused one's
+ * rank (#13727): when `rankOf` is provided, every group carries its own
+ * flex order inside the sidebar's host container, so a focused switch keeps
+ * all groups in place. Each group polls its own daemon; a host that drops
+ * offline or rejects the saved credential keeps its last known projects
+ * with a muted status hint.
+ */
+export declare function OtherHostProjects({ onOpenHostSession, rankOf, }: {
+    onOpenHostSession?: OpenHostSessionHandler;
+    rankOf?: (origin: string) => number;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/workspaces/WorkspaceLocation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compact label naming the host a chat runs on, with the working directory in
+ * its tooltip. Hidden until a project can live on more than one host.
+ * `hostOrigin` names the ACTIVE session's host on multi-daemon pages; without
+ * it the page daemon (the behavior before fan-out) decides.
+ */
+export declare function WorkspaceLocation({ cwd, hostOrigin, }: {
+    cwd?: string;
+    hostOrigin?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/config/daemon-target.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ReactNode } from 'react';
+export interface FocusHostTarget {
+    origin: string;
+    /** Preselect this workspace on the new host (by id), or clear otherwise. */
+    workspaceId?: string;
+}
+/**
+ * One-shot intent carried across a focused-host switch: the remounted app
+ * performs it against the NEW host's provider (composer create on a picked
+ * workspace, or open an existing session). Kept here because this provider
+ * sits outside the interactive provider's remount boundary.
+ */
+export interface HostHandoff {
+    kind: 'create' | 'open';
+    /** The focused host this intent belongs to — stale intents are dropped. */
+    origin: string;
+    workspaceCwd?: string;
+    sessionId?: string;
+    /** Composer text to restore on the new host (attachments cannot carry). */
+    draftText?: string;
+}
+export interface DaemonTargetController {
+    /** The focused daemon origin (page origin when no `?daemon=` is active). */
+    activeOrigin: string;
+    /** Origins the current document may open network connections to. */
+    coveredOrigins: ReadonlySet<string>;
+    coversOrigin(origin: string): boolean;
+    /**
+     * Focus another CSP-covered host: remounts the interactive provider at the
+     * new origin and rewrites `?daemon=` (+ optional `?workspace=`) in place.
+     * Never navigates; throws on an uncovered origin — callers must route those
+     * through the navigation-based connect flow instead.
+     */
+    focusHost(target: FocusHostTarget): void;
+    /** Token for the focused host, refreshed when the focused origin (or any
+     * controller dependency) changes; a token edit alone does not re-key it. */
+    activeToken: string | undefined;
+    /**
+     * Focus another host and hand an intent to the remounted app. The app
+     * drains it via `takePendingHandoff` once the new provider is connected
+     * (create a session in that workspace / open that session there).
+     */
+    focusHostWithHandoff(target: FocusHostTarget, handoff: HostHandoff): void;
+    /** Pending intent from the latest focus switch; consumed exactly once. */
+    pendingHandoff: HostHandoff | undefined;
+    takePendingHandoff(): HostHandoff | undefined;
+}
+export declare function DaemonTargetProvider({ children, }: {
+    children: ReactNode;
+}): ReactNode;
+export declare function useDaemonTarget(): DaemonTargetController;
+/** Optional-context variant for components rendered both inside and outside
+ * the standalone tree (tests, embedded shells without the provider). */
+export declare function useDaemonTargetOptional(): DaemonTargetController | undefined;
+/**
+ * Intercept same-origin anchor clicks that point at another connected host
+ * (#13727): a transcript/session link with `?daemon=B` would otherwise
+ * hard-reload the document, losing all sidebar and composer state. When the
+ * target is inside the CSP-covered set the click becomes an in-app focus
+ * switch (open that session there); anything uncovered keeps the default
+ * navigation, which still re-serves the shell widened for the host.
+ */
+export declare function useInterceptHostLinks(): void;
+/**
+ * Keep the URL's `fanout` params equal to the saved-host set minus the
+ * focused daemon (which `?daemon=` already covers). Runs on mount, on host
+ * catalog changes, on focus switches, on cross-tab storage writes, and when
+ * the tab regains focus (settings flows that edited catalogs in place).
+ * `replaceState` only — the current document's CSP is unaffected.
+ */
+export declare function useFanoutUrlSync(): void;

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

@@ -1,4 +1,20 @@
 export declare function getDaemonBaseUrl(): string;
+/**
+ * Repeated `?fanout=` values validated into daemon origins. Fanout params
+ * name the hosts this page connects to simultaneously (multi-daemon view,
+ * #13727): the served CSP covers exactly the `daemon` + `fanout` set, so a
+ * focused-host switch inside that set never reloads the document. The page
+ * origin is dropped — `'self'` already covers it.
+ */
+export declare function getFanoutOrigins(): string[];
+/**
+ * Point the URL's `fanout` params at exactly `origins`, preserving every
+ * other param. `replaceState` only: this cannot widen the CURRENT document's
+ * CSP (the header is fixed at load) — it keeps the NEXT load in sync, so the
+ * host set stays covered without a reload. A newly-connected host therefore
+ * navigates once before it can be used; every switch after that is in-app.
+ */
+export declare function syncFanoutParams(origins: readonly string[]): void;
 /**
  * Whether host-local affordances are safe to offer here: true only when this
  * page was served from a loopback host AND the shell is not pointed at a

package/dist/types/config/host-fanout.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DaemonClient } from '@qwen-code/sdk/daemon';
+import type { DaemonCapabilities } from '@qwen-code/sdk/daemon';
+export type HostConnectionStatus = 'connecting' | 'online' | 'offline' | 'unauthorized';
+/**
+ * Stable read-only client for `origin`. Recreated only when the stored
+ * per-origin token changed; a client whose daemon vanished stays online as an
+ * instance (its next request fails) and its entry is dropped when the host
+ * loses its last subscriber.
+ */
+export declare function getHostClient(origin: string): DaemonClient;
+export declare const HOST_FANOUT_POLL_MS = 30000;
+export interface HostCapabilitiesState {
+    workspaces: DaemonCapabilities['workspaces'];
+    status: HostConnectionStatus;
+    /** Bumps on every content-changed refresh so poll consumers resubscribe. */
+    generation: number;
+}
+/**
+ * Live `capabilities().workspaces` + connection status for one fan-out host.
+ * Shares the store's single poll round with every other consumer; the last
+ * successful payload survives later failures (status flips to
+ * offline/unauthorized but the rows keep rendering) and hosts are always
+ * polled with their own per-origin client.
+ */
+export declare function useHostCapabilities(origin: string): HostCapabilitiesState & {
+    refresh: () => void;
+};
+/**
+ * The single ordered host set both the sidebar fan-out and App composers
+ * render from: every saved workspace host and connected remote origin, minus
+ * the focused daemon (its own UI comes from the interactive provider), plus
+ * the page origin when focused remote — the "way back" group. Memoized on
+ * content so consumers can pass it straight into `useHostFanout`.
+ */
+export declare function useFanoutOrigins(): string[];
+/**
+ * Live connection state + a client for every `origins` entry, drawn from the
+ * shared per-origin store: subscribing here never adds a second poller — the
+ * composer picker and the sidebar groups observe the same rounds. Failed
+ * hosts keep their last-known snapshot; hosts that lose their last
+ * subscriber are dropped from the client pool.
+ */
+export declare function useHostFanout(origins: readonly string[]): {
+    clientsByOrigin: ReadonlyMap<string, DaemonClient>;
+    statusByOrigin: ReadonlyMap<string, HostConnectionStatus>;
+    workspacesByOrigin: ReadonlyMap<string, DaemonCapabilities['workspaces'] | undefined>;
+    refreshAll: () => void;
+};

package/dist/types/config/remote-connections.d.ts

@@ -1,7 +1,10 @@
+export declare const REMOTE_CONNECTIONS_CHANGE_EVENT = "qwen-remote-connections";
 export declare function formatOriginHost(origin: string): string;
 export declare function readRemoteConnections(): string[];
 export declare function rememberRemoteConnection(origin: string): void;
 export declare function forgetRemoteConnection(origin: string): string[];
+/** Saved connection origins, kept in sync with catalog updates. */
+export declare function useRemoteConnections(): string[];
 export declare function isRemoteConnectionKnown(origin: string): boolean;
 /**
  * Remote computers offered as a workspace location: the persisted catalog plus

package/dist/types/config/workspace-hosts.d.ts

@@ -0,0 +1,18 @@
+import type { DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
+export declare const WorkspaceHostsEnabled: import("react").Context<boolean>;
+export declare const WORKSPACE_HOSTS_CHANGE_EVENT = "qwen-workspace-hosts";
+export interface WorkspaceHost {
+    origin: string;
+    workspaces: Pick<DaemonWorkspaceCapability, 'id' | 'cwd' | 'displayName'>[];
+}
+export declare function readWorkspaceHosts(): WorkspaceHost[];
+export declare function rememberWorkspaceHost(origin: string, workspaces: WorkspaceHost['workspaces']): void;
+/**
+ * Drop a host from the saved workspace catalog, e.g. when its connection is
+ * removed from Settings: the fan-out group must disappear in the same tab,
+ * not just on the next load.
+ */
+export declare function forgetWorkspaceHost(origin: string): void;
+/** Saved hosts, kept in sync with catalog updates from this and other tabs. */
+export declare function useWorkspaceHosts(): WorkspaceHost[];
+export declare function openHostedWorkspace(origin: string, workspaceId?: string): void;

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

@@ -7,3 +7,4 @@
 export declare const AGENT_TOOL_NAME = "agent";
 /** Whether a tool name identifies the Agent (sub-agent) tool. */
 export declare function isAgentTool(toolName: string | undefined): boolean;
+export declare function isAskUserQuestionToolName(toolName: string): boolean;

package/dist/types/daemon/session/turn-notification-context.d.ts

@@ -15,10 +15,11 @@ export interface TurnNotificationContent {
     sessionTitle?: string;
     promptText?: string;
     responseText?: string;
+    attention?: 'approval' | 'question';
 }
 export interface TurnNotification extends TurnNotificationContent {
     key: string;
-    outcome: 'completed' | 'failed' | 'ended' | 'cancelled';
+    outcome: 'completed' | 'failed' | 'ended' | 'cancelled' | 'approval' | 'question';
 }
 export interface TurnNotificationObserver {
     retain(scope: string): () => void;

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { ReactNode } from 'react';
-import type { CreateSessionRequest, DaemonBranchSessionRequest, DaemonCapabilities, DaemonBackgroundTurn, DaemonEvent, DaemonApprovalMode, DaemonApprovalModeResult, DaemonAvailableCommand, DaemonForkSessionResult, DaemonInputAnnotation, DaemonSessionBtwResult, DaemonSessionGenerationEvent, DaemonSessionAttachmentReference, DaemonSessionAttachmentData, DaemonMidTurnMessageResult, DaemonMidTurnMessagesResult, DaemonRemoveMidTurnMessageResult, DaemonPendingPromptsResult, DaemonRemovePendingPromptResult, DaemonSessionContextStatus, DaemonSessionSavedWorkflowDetail, DaemonSessionContextUsageStatus, DaemonSessionRecapResult, DaemonRewindResult, DaemonRewindSnapshotInfo, DaemonSession, DaemonSessionSummary, DaemonSessionSupportedCommandsStatus, DaemonSessionTaskWithWorkflowStatus, DaemonSessionTasksStatus, DaemonSessionWorkflowTaskStatus, DaemonSessionWorkflowTasksStatus, DaemonSessionStatsStatus, DaemonSessionArtifactsEnvelope, DaemonSessionArtifactInput, DaemonSessionArtifactMutationResult, SessionSourceInput, SessionSourcesResult, SessionSourceUpsertResult, SessionSourceRemoveResult, DaemonSkillToggleMutation, DaemonShellCommandResult, DaemonTranscriptBlock, DaemonTranscriptStore, DaemonWorkspaceGitStatus, DaemonWorkspaceProvidersStatus, DaemonStandaloneCreationRecovery, DaemonStandaloneWorkingDirectory, HeartbeatResult, GoalControlRequest, GoalSnapshotV2, GoalStateResponse, PermissionResponse, PromptContentBlock, PromptResult, ReasoningSelection, SessionMetadataResult, SetModelResult } from '@qwen-code/sdk/daemon';
+import type { CreateSessionRequest, DaemonBranchSessionRequest, DaemonCapabilities, DaemonBackgroundTurn, DaemonEvent, DaemonApprovalMode, DaemonApprovalModeResult, DaemonAvailableCommand, DaemonForkSessionResult, DaemonInputAnnotation, DaemonSessionBtwResult, DaemonSessionGenerationEvent, DaemonSessionAttachmentReference, DaemonSessionAttachmentData, DaemonMidTurnMessageResult, DaemonMidTurnMessagesResult, DaemonRemoveMidTurnMessageResult, DaemonSendMidTurnMessagesNowResult, DaemonPendingPromptsResult, DaemonRemovePendingPromptResult, DaemonSessionContextStatus, DaemonSessionSavedWorkflowDetail, DaemonSessionContextUsageStatus, DaemonSessionRecapResult, DaemonRewindResult, DaemonRewindSnapshotInfo, DaemonSession, DaemonSessionSummary, DaemonSessionSupportedCommandsStatus, DaemonSessionTaskWithWorkflowStatus, DaemonSessionTasksStatus, DaemonSessionWorkflowTaskStatus, DaemonSessionWorkflowTasksStatus, DaemonSessionStatsStatus, DaemonSessionArtifactsEnvelope, DaemonSessionArtifactInput, DaemonSessionArtifactMutationResult, SessionSourceInput, SessionSourcesResult, SessionSourceUpsertResult, SessionSourceRemoveResult, DaemonSkillToggleMutation, DaemonShellCommandResult, DaemonTranscriptBlock, DaemonTranscriptStore, DaemonWorkspaceGitStatus, DaemonWorkspaceProvidersStatus, DaemonStandaloneCreationRecovery, DaemonStandaloneWorkingDirectory, HeartbeatResult, GoalControlRequest, GoalSnapshotV2, GoalStateResponse, PermissionResponse, PromptContentBlock, PromptResult, ReasoningSelection, SessionMetadataResult, SetModelResult } from '@qwen-code/sdk/daemon';
 export type DaemonConnectionStatus = 'idle' | 'connecting' | 'connected' | 'disconnected' | 'error';
 export interface DaemonSessionOwnerSnapshot {
     isCurrent(): boolean;
@@ -202,6 +202,12 @@ export interface DaemonPromptSettledEvent {
     sessionId: string;
     promptId: string;
     outcome: DaemonPromptSettlementOutcome;
+    /**
+     * The client that submitted the prompt, from the terminal frame's
+     * envelope. Lets a submitter recognise its own turn when the admission
+     * response never reached it.
+     */
+    originatorClientId?: string;
     /** Daemon terminal reason. Present for completed and cancelled turns. */
     stopReason?: string;
     error?: {
@@ -277,9 +283,12 @@ export interface SendPromptOptions {
      * runs to completion. Lets a caller act on "the prompt reached the session"
      * without waiting for the whole turn — e.g. the scheduled-tasks "run now",
      * which records the run at admission so a long/stalled turn or a closed tab
-     * can't lose the record.
+     * can't lose the record. Carries the daemon's id for the prompt, the key
+     * its terminal `turn_complete` / `turn_error` settles under.
      */
-    onAdmitted?: () => void;
+    onAdmitted?: (admission: {
+        promptId: string;
+    }) => void;
 }
 export interface SubmitPromptOptions extends SendPromptOptions {
     sessionId?: string;
@@ -440,11 +449,18 @@ export interface DaemonSessionActions {
     generateSessionContent(prompt: string, opts?: {
         signal?: AbortSignal;
     }): AsyncGenerator<DaemonSessionGenerationEvent>;
-    getRewindSnapshots(): Promise<{
+    getRewindSnapshots(opts?: {
+        /** Rethrow failures raw instead of recording a notice; for best-effort
+         * callers that fall back on their own. */
+        silent?: boolean;
+    }): Promise<{
         snapshots: DaemonRewindSnapshotInfo[];
     }>;
     rewindSession(promptId: string, opts?: {
         rewindFiles?: boolean;
+        /** Rethrow failures raw instead of recording a notice; for best-effort
+         * callers that fall back on their own. */
+        silent?: boolean;
     }): Promise<DaemonRewindResult>;
     btwSession(question: string, opts?: {
         signal?: AbortSignal;
@@ -473,6 +489,14 @@ export interface DaemonSessionActions {
         onAdmissionStarted?: () => void;
     }): Promise<DaemonMidTurnMessageResult>;
     removeMidTurnMessage(messageId: string, opts?: PendingPromptActionOptions): Promise<DaemonRemoveMidTurnMessageResult>;
+    /**
+     * Ask the daemon to deliver the queued mid-turn messages now, cutting short
+     * a model response that a foreground turn is streaming, unless it has
+     * started a tool call.
+     * Pre-flight the daemon's `session_mid_turn_send_now` capability: older
+     * daemons lack the route.
+     */
+    sendMidTurnMessagesNow(opts?: PendingPromptActionOptions): Promise<DaemonSendMidTurnMessagesNowResult>;
     /**
      * Best-effort reconciliation snapshot (queue + delivery-state rings) from the
      * daemon. Resolves `undefined` (never throws/raises a notice) when there

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

@@ -70,6 +70,8 @@ export interface UseQueuedPromptsResult {
     enqueuePrompt: (text: string, images?: PromptImage[], files?: PromptFile[], onComplete?: () => void, inputAnnotations?: DaemonInputAnnotation[], onAdmitted?: () => void, submittedPrompt?: string) => boolean;
     removeQueuedPrompt: (id: number) => void;
     insertQueuedPrompt: (id: number) => Promise<void>;
+    /** Ask the daemon to deliver the queued mid-turn messages now. */
+    sendQueuedPromptNow: (id: number) => Promise<void>;
     editQueuedPrompt: (id: number) => Promise<void>;
     editLastQueuedPrompt: () => boolean;
     clearQueuedPrompts: () => boolean;

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

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

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

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