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

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

@@ -3,9 +3,16 @@
  * 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;
 /**
- * Saved projects on the other hosts, grouped by host below the live list.
- * Only the connected host is live; choosing one of these reloads the page
- * against its host.
+ * 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(): import("react/jsx-runtime").JSX.Element | null;
+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

@@ -1,7 +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 }: {
+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

@@ -1,11 +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/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;
@@ -489,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/types.d.ts

@@ -82,6 +82,7 @@ export interface TrajectoryRequestRow extends TrajectoryRowBase {
     /** Folded from the round's assistant block; absent when none carried it. */
     usage?: DaemonTurnUsage;
     recordId?: string;
+    executionId?: string;
     responseId?: string;
     promptId?: string;
     /** Set when a subagent issued the request. */

package/dist/types/trajectory/useTrajectoryWindow.d.ts

@@ -59,55 +59,40 @@ export type TrajectoryWindowFailure = {
 } | {
     kind: 'unreadable';
     message: string;
+} | {
+    kind: 'expired' | 'protocol' | 'budget';
 };
+export declare const TRAJECTORY_BOOKMARK_LIMIT = 64;
+export declare const TRAJECTORY_CURSOR_BUDGET: number;
 export interface TrajectoryWindow {
     trajectory: Trajectory | undefined;
     status: 'idle' | 'loading' | 'ready' | 'error';
-    /**
-     * The newest page could not be read. The window already on screen, if any,
-     * is kept.
-     */
     error?: TrajectoryWindowFailure;
-    /**
-     * Pages read so far by the load under way, or held by the window once it
-     * is ready. What the placeholder counts while the walk back is running.
-     */
     loadedPages: number;
-    /**
-     * The session has history older than the window: the walk stopped at the
-     * page cap, at a page the daemon gave no cursor for, or at an older page it
-     * could not read.
-     */
+    windowPages: number;
     truncated: boolean;
-    /**
-     * An older page could not be read, so the window stops just after it. The
-     * newer pages are drawn; `refresh` is the retry.
-     */
     olderFailure?: TrajectoryWindowFailure;
-    /** Read the window again from the newest page. Also every retry. */
+    navigationError?: TrajectoryWindowFailure;
+    mode: 'latest' | 'history';
+    navigationVersion: number;
+    canRefresh: boolean;
+    canOlder: boolean;
+    canNewer: boolean;
+    historyReleased: boolean;
+    bookmarks: number;
     refresh: () => void;
+    older: () => void;
+    newer: () => void;
+    retry: () => void;
 }
 /**
- * Hold a window of one session's transcript and fold it into a trajectory.
- *
- * The pages are this view's own: paged replay is the only path that emits
- * timing frames, and the chat store is fed by the live stream and by bulk
- * replay, neither of which carries them. Reading here also keeps the window
- * contiguous by construction, which is what lets the projection pair a frame
- * with what it measured.
- *
- * A load walks back from the newest page by cursor, up to the page cap, and
- * the window lands once, whole, when the walk ends. Nothing is ever put in
- * front of rows already drawn: a list that grew upwards under the reader would
- * have to move its scroll offset, its keys, its selection and its focus in
- * step, and no part of that is observable outside a real browser.
- *
- * `refresh` rebuilds the window from the newest page rather than splicing into
- * it: page boundaries are chosen per request, so a fresh page and the held
- * ones overlap by an unknown amount and cannot be joined without dropping or
- * repeating records.
+ * Windows are contiguous cursor walks, committed whole. Only bookmarks survive
+ * a switch: replaying a saved cursor stays in its snapshot, whereas a read
+ * without one explicitly returns to the latest snapshot.
  */
 export declare function useTrajectoryWindow(loadPage: TrajectoryPageLoader | undefined, options?: {
     pageSize?: number;
     maxPages?: number;
+    bookmarkLimit?: number;
+    cursorBudget?: number;
 }): TrajectoryWindow;

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

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

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

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

package/dist/types/utils/workspace.d.ts

@@ -14,6 +14,16 @@ export declare function workspaceBasename(cwd: string): string;
 export declare function sshWorkspaceLabel(ssh: NonNullable<DaemonWorkspaceCapability['ssh']>): string;
 export declare function workspaceLabel(workspace: Pick<DaemonWorkspaceCapability, 'cwd' | 'displayName' | 'ssh'>): string;
 export declare function workspaceLabelForCwd(cwd: string, workspaces: readonly Pick<DaemonWorkspaceCapability, 'cwd' | 'displayName' | 'ssh'>[] | undefined): string;
+/**
+ * Suffix the parent directory onto labels that collide inside one list.
+ * Two daemons — or one daemon with two checkouts — frequently register the
+ * same basename (`qwen-code` everywhere); the menu must tell them apart by
+ * the workspace's own location, not only by tooltip or host badge.
+ */
+export declare function disambiguateWorkspaceLabels<T extends {
+    label: string;
+    cwd: string;
+}>(entries: readonly T[]): T[];
 /**
  * True when the daemon advertises more than one registered workspace — i.e. the
  * multi-workspace session surfaces (per-workspace labels/tags) should show.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/web-shell",
-  "version": "0.25.1-preview.1",
+  "version": "0.25.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/QwenLM/qwen-code.git",