@qwen-code/web-shell 0.25.1-preview.0 → 0.25.1-preview.2

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

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionAgentPermissionPrompt, SessionAgentRunFrame } from '@qwen-code/sdk/daemon';
+import type { PermissionRequest } from '../../adapters/types';
+import { useI18n } from '../../i18n';
+type Translate = ReturnType<typeof useI18n>['t'];
+/** No agent activity for this long: say it may be stuck. */
+export declare const STALL_NOTICE_MS: number;
+/**
+ * One line saying where a live run is. Returns `attention` for the states the
+ * user should notice (stuck, failed, offline).
+ */
+export declare function describeRun(run: SessionAgentRunFrame, now: number, t: Translate): {
+    text?: string;
+    attention: boolean;
+};
+/** Client-side cap on a tool input preview (the daemon bounds it too). */
+export declare const INPUT_PREVIEW_MAX_CHARS = 4000;
+/**
+ * The run's permission prompt as the main chat's approval card reads it. A
+ * shell tool shows its command as the main chat's shell approval does; any
+ * other tool shows its input preview in the card's monospace content block.
+ */
+export declare function toApprovalRequest(permission: SessionAgentPermissionPrompt, agent: string, t: Translate): PermissionRequest;
+/**
+ * A finished run the daemon offers to run again (`retryable`): failed by a
+ * restart, offline, or one whose record a restart lost. Never a stopped one.
+ */
+export declare function canRetryRun(run: SessionAgentRunFrame): boolean;
+/** A delegated member in a squad engagement. */
+export interface SquadMemberView {
+    name: string;
+    /** The agent's color, tinting its avatar as on its replies. */
+    color?: string;
+    /** `replied`: its run completed and its reply is on the way to the leader. */
+    state: 'working' | 'replied';
+}
+/** One squad engagement as the live runs show it. */
+export interface SquadEngagementView {
+    squadId: string;
+    squadName: string;
+    /** The leader, while its squad-mode run is queued or running. */
+    leader?: string;
+    leaderColor?: string;
+    /** Delegated members, in arrival order. */
+    members: SquadMemberView[];
+}
+/**
+ * Squad engagements under way in this session, derived from live run frames
+ * carrying `squadId`: a leader run names its squad on its author; a member
+ * run the leader waits on carries the squad id (and name) on the frame. A
+ * member's completed frame keeps them while its record is pending, which is
+ * the only time a finished run is still in the list: that member `replied`.
+ */
+export declare function squadEngagements(runs: readonly SessionAgentRunFrame[]): SquadEngagementView[];
+/**
+ * A small bar per active squad engagement: the squad's tag, then one entry per
+ * participant (avatar, name, state): the leader "deciding", a member working
+ * (spinner) or replied (check).
+ */
+export declare function SquadEngagementBar({ runs, }: {
+    runs: readonly SessionAgentRunFrame[];
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The session's live agent runs, rendered at the bottom of the message list as
+ * the agents' messages-in-progress. Each is replaced by the agent's recorded
+ * reply once that lands in the transcript.
+ *
+ * Mounted only by App (through MessageList's `tailContent`), never by the
+ * exported transcript, so it may use the collaboration dictionary.
+ */
+export declare function SessionAgentLiveRuns({ runs, onCancel, onRespond, onRetry, }: {
+    runs: readonly SessionAgentRunFrame[];
+    onCancel: (runId: string) => Promise<void>;
+    onRespond: (runId: string, requestId: string, optionId: string) => Promise<void>;
+    /** Offered on a failed run the daemon marked retryable. */
+    onRetry?: (runId: string) => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The user's @-mentions the daemon holds until the running main-model turn
+ * settles, shown as their messages until the recorded ones replace them.
+ */
+export declare function PendingAgentMentions({ mentions, }: {
+    mentions: ReadonlyArray<{
+        id: string;
+        text: string;
+    }>;
+}): import("react/jsx-runtime").JSX.Element | null;
+/** Shown near the composer while any agent in this session is working. */
+export declare function StopAllAgentsButton({ onStopAll, }: {
+    onStopAll: () => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionAgentEventFrame, SessionAgentRunFrame, SessionAgentRunStatus } from '@qwen-code/sdk/daemon';
+import { type AgentStreamState } from './agent-events';
+/** 202 body of `POST sessions/:sessionId/mentions`. */
+export interface SessionMentionResult {
+    recordId: string;
+    deferred?: boolean;
+    runs: Array<{
+        runId: string;
+        agentId: string;
+        status: SessionAgentRunStatus;
+    }>;
+    /** Why some mentioned squads were not started (the others were). */
+    squadError?: string;
+}
+/**
+ * The session-scoped collaboration routes: agents answering @-mentions inside
+ * an ordinary chat session.
+ */
+export interface SessionAgentsApi {
+    listRuns(sessionId: string): Promise<{
+        frames: SessionAgentRunFrame[];
+    }>;
+    mention(sessionId: string, input: {
+        text: string;
+        clientMessageId: string;
+    }): Promise<SessionMentionResult>;
+    cancelRun(sessionId: string, runId: string): Promise<unknown>;
+    /** Runs a failed run marked `retryable` again. */
+    retryRun(sessionId: string, runId: string): Promise<unknown>;
+    stopAll(sessionId: string): Promise<unknown>;
+    respondToPermission(sessionId: string, runId: string, requestId: string, optionId: string): Promise<unknown>;
+    subscribe(sessionId: string, onEvent: (event: SessionAgentEventFrame) => void, onState: (state: AgentStreamState) => void): () => void;
+}
+export declare function createSessionAgentsHttpApi(baseUrl: string, token: string | undefined, workspaceCwd: string): SessionAgentsApi;

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,29 +3,30 @@
  * 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?(supersedesHostId?: string): Promise<JoinToken>;
@@ -35,29 +36,17 @@ export interface ThreadsApi {
         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;