@qwen-code/web-shell 0.24.3 → 0.24.4-nightly.20260923.d0cd622a68

package/dist/types/components/workflow/SessionWorkflowInspector.d.ts

@@ -1,9 +1,16 @@
 import type { DaemonSessionArtifact, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
 import type { ACPToolCall, TodoItem } from '../../adapters/types';
+import { type SessionWorkflowProjection } from './session-workflow-model';
 export interface SessionWorkflowInspectorProps {
     todos: readonly TodoItem[];
     tools: readonly ACPToolCall[];
     tasks: readonly DaemonSessionTaskStatus[];
+    /**
+     * The projection shared by every workflow surface for this render. The app
+     * derives it once and hands the same object to the cockpit, the embedded
+     * graph and this inspector; when absent it is derived from the raw props.
+     */
+    projection?: SessionWorkflowProjection;
     artifacts: readonly DaemonSessionArtifact[];
     selectedTodoId?: string;
     onSelectedTodoIdChange: (todoId: string | undefined) => void;
@@ -12,4 +19,4 @@ export interface SessionWorkflowInspectorProps {
     onOpenArtifact?: (artifactId: string) => void;
     canvasMode?: boolean;
 }
-export declare function SessionWorkflowInspector({ todos, tools, tasks, artifacts, selectedTodoId, onSelectedTodoIdChange, onExpandGraph, onOpenSubagent, onOpenArtifact, canvasMode, }: SessionWorkflowInspectorProps): import("react/jsx-runtime").JSX.Element;
+export declare function SessionWorkflowInspector({ todos, tools, tasks, projection: sharedProjection, artifacts, selectedTodoId, onSelectedTodoIdChange, onExpandGraph, onOpenSubagent, onOpenArtifact, canvasMode, }: SessionWorkflowInspectorProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workflow/session-workflow-model.d.ts

@@ -1,10 +1,18 @@
 import type { DaemonSessionAgentTaskStatus, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
 import type { ACPToolCall, TodoItem } from '../../adapters/types';
-import { type PlanNodeStatus } from '../messages/PlanExecutionView';
+import { type PlanNodeStatus, type TaskExecutionIndex } from '../messages/taskExecutionIndex';
 export interface SessionWorkflowProjection {
+    /**
+     * The task execution index this projection was built from, so a surface
+     * rendering per-tool live status (the graph's executions) reuses the one
+     * build instead of raising its own.
+     */
+    taskIndex: TaskExecutionIndex;
     todosById: ReadonlyMap<string, TodoItem>;
     toolsByTaskId: ReadonlyMap<string, ACPToolCall>;
     toolsByTodo: ReadonlyMap<string, readonly ACPToolCall[]>;
+    /** Tool calls whose `todo_id` is missing or points outside the plan. */
+    unassignedTools: readonly ACPToolCall[];
     agentToolsByTodo: ReadonlyMap<string, readonly ACPToolCall[]>;
     tasksByTool: ReadonlyMap<ACPToolCall, DaemonSessionAgentTaskStatus>;
     states: ReadonlyMap<string, {

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

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function exchangePairingCode(baseUrl: string): Promise<{
+    token?: string;
+    failed?: boolean;
+} | undefined>;

package/dist/types/config/remote-workspace-add.d.ts

@@ -1,3 +1,28 @@
+export interface RemotePathSuggestions {
+    dir: string;
+    sep: string;
+    suggestions: {
+        name: string;
+        path: string;
+    }[];
+    truncated: boolean;
+}
+/**
+ * Fetches directory suggestions from an arbitrary daemon origin without
+ * navigating the page. Used by the Add-workspace dialog's location switcher
+ * so the user can browse a remote daemon's folders in place.
+ *
+ * Goes through the current daemon's proxy route to avoid CSP issues.
+ */
+export declare function fetchRemotePathSuggestions(daemonOrigin: string, prefix: string): Promise<RemotePathSuggestions>;
+/**
+ * Registers a workspace on an arbitrary daemon origin without navigating the
+ * page. Used by the Add-workspace dialog when the user browsed a remote
+ * daemon's folders in place and then confirms the add.
+ *
+ * Goes through the current daemon's proxy route to avoid CSP issues.
+ */
+export declare function addWorkspaceToDaemon(daemonOrigin: string, cwd: string, persist: boolean, displayName?: string): Promise<void>;
 export declare function isRemoteWorkspaceAddActive(): boolean;
 export declare function clearRemoteWorkspaceAddStep(): void;
 export declare function startRemoteWorkspaceAdd(daemonOrigin: string, token?: string): boolean;

package/dist/types/customization.d.ts

@@ -10,6 +10,12 @@ import type { WebShellTheme } from './themeContext';
 export type MarkdownContentSource = 'assistant' | 'thinking';
 export interface MarkdownRenderContext {
     source: MarkdownContentSource;
+    /**
+     * 当前消息的生成态；历史或静态内容为 false。所属 MessageList 空闲
+     * （isResponding=false）时，恢复 replay 中残留的 streaming 标记也会被
+     * 收口为 false，且已收口的行在会话重新响应时、内容不变的前提下保持收口。
+     */
+    isStreaming: boolean;
 }
 export interface WebShellCodeBlockRenderInfo {
     /**

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

@@ -7,6 +7,17 @@ import type { DaemonCapabilities, DaemonSession } from '@qwen-code/sdk/daemon';
 import type { DaemonProductSessionContext, DaemonStandaloneConnectionState } from './types.js';
 export declare function resolveProviderSessionContext(sessionContext: DaemonProductSessionContext | undefined, workspaceCwd: string | undefined, inheritedWorkspaceCwd: string | undefined): DaemonProductSessionContext | undefined;
 export declare function resolveActionSessionContext(sessionContext: DaemonProductSessionContext | undefined, workspaceCwd: string | undefined, fallback: DaemonProductSessionContext | undefined): DaemonProductSessionContext | undefined;
+/**
+ * The Live workspace is the daemon's own, and it announces it by tagging that
+ * entry `kind: 'live'` — a tag no daemon old enough to lack Live session
+ * routing has ever sent. That tag is therefore the whole precondition.
+ *
+ * It deliberately does not ask for `multi_workspace_sessions`. That feature
+ * counts *user* workspaces (`listEntries()` drops the Live entry as internal),
+ * so a daemon serving a single project withholds it while still advertising
+ * the Live workspace in the very same payload — and a Live session could not
+ * be opened at all. The checks below are what actually keep this safe.
+ */
 export declare function resolveLiveSessionWorkspaceCwd(capabilities: DaemonCapabilities): string;
 export declare function sessionContextKey(context: DaemonProductSessionContext | undefined): string;
 export declare function restoreSessionContextMatches(requested: DaemonProductSessionContext | undefined, active: DaemonProductSessionContext | undefined): boolean;

package/dist/types/daemon/session/transcript-page-table.d.ts

@@ -118,7 +118,7 @@ export declare class HistoricalTranscriptPageTable {
     clearSelection(): void;
     setViewportAnchor(viewportId: string, pageId?: string): void;
     admitBefore(beforeRecordId: string, snapshot: string, response: DaemonSessionTranscriptPage): AdmittedHistoricalTarget | undefined;
-    admitAnchor(ordinal: number, turnId: string, snapshot: string, response: DaemonSessionTranscriptPage): AdmittedHistoricalTarget;
+    admitAnchor(ordinal: number, turnId: string, snapshot: string, response: DaemonSessionTranscriptPage, targetRecordId?: string): AdmittedHistoricalTarget;
     private admitAnchorPage;
     beginBoundaryLoad(rangeId: string, direction: BoundaryDirection): FrozenTranscriptBoundaryRequest | undefined;
     reopenLiveBoundary(rangeId: string, beforeRecordId: string, snapshot: string): void;

package/dist/types/daemon/session/turn-navigation-store.d.ts

@@ -5,6 +5,35 @@
  */
 import type { DaemonEvent, DaemonSessionTranscriptPage, DaemonSessionTranscriptPageOptions, DaemonSessionTurnIndexEntry, DaemonSessionTurnIndexPage, DaemonSessionTurnIndexPageOptions, DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
 import { type HistoricalTranscriptPage, type HistoricalTranscriptRange, type HistoricalViewportRange, type MaterializedTranscriptPage } from './transcript-page-table.js';
+export interface ConversationSearchHit {
+    sessionId: string;
+    snapshot: string;
+    revision: number;
+    recordId: string;
+    liveBlockId?: string;
+    turnId: string;
+    turnOrdinal: number;
+    role: 'user' | 'assistant';
+    snippet: string;
+    matchStart: number;
+    matchEnd: number;
+}
+export interface ConversationSearchResult {
+    hits: ConversationSearchHit[];
+    messageCount: number;
+    matchCount: number;
+    complete: boolean;
+    truncated: boolean;
+}
+export interface ConversationSearchOptions extends HistoryViewportRequest {
+    onProgress?: (result: ConversationSearchResult) => void;
+    stopAfterMessages?: number;
+}
+export declare function createConversationSearchSnippet(text: string, query: string): {
+    snippet: string;
+    matchStart: number;
+    matchEnd: number;
+} | undefined;
 export interface DaemonTurnIndexPage {
     start: number;
     end: number;
@@ -94,6 +123,9 @@ export interface HistoryViewportRequest {
     isCurrent(): boolean;
 }
 export interface DaemonHistoryNavigationStore extends DaemonTurnNavigationStore {
+    scanConversation(query: string, options: ConversationSearchOptions): Promise<ConversationSearchResult>;
+    resolveMessageRecord(recordId: string, request: HistoryViewportRequest): Promise<ConversationSearchHit | undefined>;
+    locateViewportSearchHit(hit: ConversationSearchHit, request: HistoryViewportRequest, releaseAnchor: () => void): Promise<DaemonTurnLocation>;
     locateViewportOrdinal(ordinal: number, request: HistoryViewportRequest, releaseAnchor: () => void): Promise<DaemonTurnLocation>;
     getViewportSnapshot(): DaemonHistoryViewportSnapshot;
     captureLiveBoundary(): LiveHistoryBoundary;

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

@@ -0,0 +1,12 @@
+import { type RefObject } from 'react';
+import type { MessageListHandle } from '../components/MessageList';
+export interface WebShellMessageNavigationRequest {
+    sessionId: string;
+    /** JSONL 持久化记录 ID，不是渲染块 ID、摘要或时间戳。 */
+    recordId: string;
+    signal?: AbortSignal;
+}
+export type WebShellMessageNavigationResult = {
+    status: 'located' | 'not_found' | 'not_ready' | 'session_mismatch' | 'unsupported' | 'cancelled' | 'error';
+};
+export declare function useMessageNavigation(messageListRef: RefObject<MessageListHandle | null>, active?: boolean): ({ sessionId, recordId, signal, }: WebShellMessageNavigationRequest) => Promise<WebShellMessageNavigationResult>;

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

@@ -13,6 +13,9 @@ interface RefBox<T> {
     current: T;
 }
 interface UseQueuedPromptsArgs {
+    /** Synchronous caller policy, checked again immediately before SDK dispatch.
+     * Return a message to reject locally; undefined permits dispatch. */
+    getPromptDispatchError?: (text: string) => string | undefined;
     connected: boolean;
     writeBlocked?: boolean;
     runtimeStopped?: boolean;
@@ -71,5 +74,5 @@ export interface UseQueuedPromptsResult {
     editLastQueuedPrompt: () => boolean;
     clearQueuedPrompts: () => boolean;
 }
-export declare function useQueuedPrompts({ connected, writeBlocked, runtimeStopped, sessionId, workspaceCwd, clientId, canMutateMidTurn, canQueryMidTurn, canInjectMidTurnMedia, workspaceFileActions, streamingState, sessionHasActivePrompt, holdQueuedPromptsLocally, sessionActions, store, editorRef, reportError, t, }: UseQueuedPromptsArgs): UseQueuedPromptsResult;
+export declare function useQueuedPrompts({ getPromptDispatchError, connected, writeBlocked, runtimeStopped, sessionId, workspaceCwd, clientId, canMutateMidTurn, canQueryMidTurn, canInjectMidTurnMedia, workspaceFileActions, streamingState, sessionHasActivePrompt, holdQueuedPromptsLocally, sessionActions: unguardedSessionActions, store, editorRef, reportError, t, }: UseQueuedPromptsArgs): UseQueuedPromptsResult;
 export {};

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

@@ -5,6 +5,7 @@
  */
 import { type Translator } from '../adapters/localizedMessages';
 import type { Message } from '../adapters/types';
+import type { ConversationSearchHit } from '../daemon/session/turn-navigation-store';
 export declare function useTranscriptViewport(liveMessages: Message[], t: Translator): {
     navigation: import("..").DaemonTurnNavigationSnapshot;
     store: import("../daemon/session/turn-navigation-store").DaemonHistoryNavigationStore;
@@ -12,7 +13,8 @@ export declare function useTranscriptViewport(liveMessages: Message[], t: Transl
         blockId: string;
         token: number;
     } | undefined;
-    selectOrdinal: (ordinal: number) => Promise<void>;
+    selectOrdinal: (ordinal: number, hit?: ConversationSearchHit, isCurrent?: () => boolean) => Promise<boolean | "cancelled">;
+    selectSearchHit: (hit: ConversationSearchHit, isCurrent?: () => boolean) => Promise<boolean | "cancelled">;
     cancelSelection: () => void;
     continueLive: (blockId?: string) => void;
     messages: import("../adapters/messageTypes").DaemonMessage[];

package/dist/types/index.d.ts

@@ -1,3 +1,5 @@
+import type { WebShellUrlNavigationOptions } from './navigation';
+export type { WebShellUrlNavigationOptions, WebShellPage } from './navigation';
 import { type DaemonProductSessionContext } from '@qwen-code/web-shell/daemon-react-sdk';
 import { type WebShellProps } from './App';
 import { type WebShellBrowserNotificationsOptions } from './browser-turn-notifications';
@@ -6,6 +8,12 @@ export type { WebShellTranscriptProps } from './components/WebShellTranscript';
 export * from './daemon-react-sdk';
 export type { WebShellBrowserNotificationsOptions } from './browser-turn-notifications';
 export interface WebShellWithProvidersProps extends WebShellProps {
+    /**
+     * Opt in to URL routing. Explicit initial session target props override the
+     * URL; later target prop changes replace it. Stop host history writes when
+     * enabled. Omit to keep host-owned navigation. basePath defaults to root.
+     */
+    urlNavigation?: WebShellUrlNavigationOptions;
     /** Connect browser notifications with optional branding and an initial preference (off by default). */
     browserNotifications?: WebShellBrowserNotificationsOptions;
     /** Daemon API base URL. Defaults to the browser origin when omitted. */
@@ -67,3 +75,5 @@ export { ECHARTS_FULLDATA_LANGUAGE, EchartsFullDataBlock, createMarkdownChartReg
 export type { DatasetCell, EchartsFullDataBlockProps, EchartsFullDataOption, EchartsFullDataRefMeta, EchartsFullDataRefResolver, EchartsFullDataResolvedDataset, EchartsFullDataRendererOptions, EchartsInstance, EchartsRuntime, EchartsRuntimeLoader, } from './components/messages/MarkdownChartRenderer';
 export { WEB_SHELL_SETTING_ITEM_IDS } from './settings';
 export type { WebShellSettingItemId, WebShellSettingsOptions, } from './settings';
+export type { WebShellModelManagementOptions } from './modelManagement';
+export type { WebShellMessageNavigationRequest, WebShellMessageNavigationResult, } from './hooks/useMessageNavigation';

package/dist/types/modelManagement.d.ts

@@ -0,0 +1,16 @@
+/** WebShell interaction controls only; daemon APIs and external provisioning remain available. */
+export interface WebShellModelManagementOptions {
+    /** Allow provider/model setup, including /auth. Defaults to true. */
+    allowAdd?: boolean;
+    /** Allow model deletion. Defaults to true. */
+    allowDelete?: boolean;
+}
+export declare function resolveModelManagement(options?: WebShellModelManagementOptions): Required<WebShellModelManagementOptions>;
+/** The command identity a session's command snapshot carries per entry. */
+export interface ModelSetupCommandInfo {
+    name: string;
+    source?: string;
+    altNames?: readonly string[];
+}
+export declare function isModelCommandSnapshotReady(commands?: readonly ModelSetupCommandInfo[]): boolean;
+export declare function isModelSetupCommand(input: string, commands?: readonly ModelSetupCommandInfo[]): boolean;

package/dist/types/navigation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ReactNode } from 'react';
+import type { DaemonProductSessionContext } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { WebShellProps } from './App';
+import { type WebShellPage, type WebShellRoute } from './utils/navigationUrl';
+export type { WebShellPage } from './utils/navigationUrl';
+export interface WebShellUrlNavigationOptions {
+    /** URL pathname containing the shell, e.g. /agentic-code. Defaults to root. */
+    basePath?: string;
+}
+export interface NavigationSessionProps {
+    sessionId?: string;
+    workspaceId?: string;
+    workspaceCwd?: string;
+    sessionContext?: DaemonProductSessionContext;
+}
+interface NavigationController {
+    route: WebShellRoute;
+    revision: number;
+    openPage: (page: WebShellPage) => void;
+    returnToChat: () => void;
+    reconcilePage: (page: WebShellPage | undefined) => void;
+    beginSessionNavigation: (sessionId?: string, workspaceId?: string, sessionContext?: DaemonProductSessionContext) => void;
+    cancelSessionNavigation: () => void;
+    finishNewChat: (context?: DaemonProductSessionContext) => void;
+}
+export declare const useWebShellNavigation: () => NavigationController | undefined;
+export declare function WebShellNavigationBoundary({ options, externalTarget, onSessionIdChange, children, }: {
+    options?: WebShellUrlNavigationOptions;
+    externalTarget: NavigationSessionProps;
+    onSessionIdChange?: WebShellProps['onSessionIdChange'];
+    children: (target: NavigationSessionProps, onChange: NonNullable<WebShellProps['onSessionIdChange']>) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Trajectory, TrajectoryRow } from './types';
+/** 0 main-session requests · 1 tool calls · 2 subagent requests. */
+export type TimelineLane = 0 | 1 | 2;
+export interface TimelineSpan {
+    /** The table row this span draws; selecting a span selects this row. */
+    rowKey: string;
+    row: TrajectoryRow;
+    lane: TimelineLane;
+    /** Offset into the compressed domain, ms. */
+    start: number;
+    end: number;
+    /** Requests with a recorded TTFT only: where the first token landed. */
+    ttftEnd?: number;
+    error: boolean;
+}
+export interface TimelineTurnMark {
+    turnIndex: number;
+    at: number;
+}
+export interface TimelineModel {
+    /** Ascending by start, then lane, then row key. */
+    spans: TimelineSpan[];
+    turnMarks: TimelineTurnMark[];
+    /**
+     * Length of the domain. Idle gaps are cut out, so this is the time during
+     * which at least one request or tool was running — not wall-clock time.
+     */
+    total: number;
+    /**
+     * Rows with a recorded duration but no recorded start — tool calls from a
+     * session written before tools recorded one. Not drawn, never estimated.
+     */
+    droppedRows: number;
+}
+/**
+ * Project the rows that recorded both a start and a duration onto one time
+ * axis, with the idle stretches between them cut out.
+ *
+ * Only measured values are drawn. A row without a start is left off rather
+ * than placed next to its neighbours: a bar in the wrong place reads as a fact.
+ * Returns `undefined` when nothing in the window can be drawn.
+ */
+export declare function buildTimeline(trajectory: Trajectory): TimelineModel | undefined;

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

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TimelineModel } from './buildTimeline';
+/**
+ * A stretch of the overview's domain, in the same compressed milliseconds as
+ * the spans. Always ordered: `start <= end`.
+ */
+export interface TimelineRange {
+    start: number;
+    end: number;
+}
+/**
+ * Rows whose span was running at any point in the range, ends included.
+ *
+ * With idle time cut out of the domain, spans cover it end to end, so any
+ * range finds at least one row. That stops holding once a mode draws real
+ * clock time with its gaps left in.
+ *
+ * Closed on both sides so a zero-length span sitting on an edge — a tool that
+ * reported 0 ms, or a range made by a drag that stopped exactly on a bar's
+ * end — still counts as inside rather than vanishing from both sides.
+ */
+export declare function rowKeysInRange(model: TimelineModel, range: TimelineRange): Set<string>;

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

@@ -12,6 +12,7 @@ export interface TrajectoryTranscriptClient {
     getSessionTranscriptPage(sessionId: string, opts: {
         direction?: 'backward';
         limit?: number;
+        cursor?: string;
     }): Promise<TrajectoryPageResult>;
 }
 /**
@@ -20,8 +21,9 @@ export interface TrajectoryTranscriptClient {
  * Identity matters: the loader is the window hook's effect dependency, so a
  * fresh function on every render would refetch the newest page on every render.
  *
- * Reads ask for the newest page, which is the one the reader wants — the newest
- * turn is the one they just watched run. It deliberately goes through the raw
+ * Reads walk backward from the newest page, which is the one the reader wants —
+ * the newest turn is the one they just watched run — following the cursor each
+ * page hands back. It deliberately goes through the raw
  * client rather than
  * `DaemonSessionClient.getTranscriptPage`, which hydrates attachments and would
  * fetch image bytes this table never shows, and it never asks for the

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

@@ -42,9 +42,9 @@ export type TrajectoryEntry = {
 export interface TrajectoryTiming {
     durationMs: number;
     /**
-     * Requests only. Tool calls are logged in one loop after their whole batch
-     * settles, so the recorded timestamp is the batch's end for every tool in it
-     * and no honest per-tool start can be derived.
+     * Epoch ms. Requests have one whenever their end was recorded; tool calls
+     * only when the session recorded the call's start, which older sessions did
+     * not.
      */
     startedAt?: number;
     /** Requests only: dispatch to first user-visible content. */

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

@@ -11,6 +11,18 @@ import type { Trajectory } from './types';
  * shorter than this — `truncated` is what says so, never the count.
  */
 export declare const TRAJECTORY_PAGE_SIZE = 250;
+/**
+ * Pages read, newest first, before the window is drawn. The window is
+ * re-projected whole on every change and each page is a full replay of its
+ * records, so this is what bounds the retained bytes and the per-change work —
+ * and holding four pages where the table held one raises both by four, to 1000
+ * records nominally. The true worst case is nearer 3000: a backward page can
+ * exceed the limit it was asked for, because the daemon extends it to keep
+ * turns and tool pairs whole, up to `3 * limit` records and its own 4 MB
+ * ceiling. Four is where that ceiling stays defensible while still reaching a
+ * useful way back.
+ */
+export declare const TRAJECTORY_MAX_PAGES = 4;
 /**
  * The fields of a transcript page this view reads. Narrower than the daemon's
  * own page type on purpose: the client's page satisfies it structurally, and a
@@ -19,11 +31,14 @@ export declare const TRAJECTORY_PAGE_SIZE = 250;
 export interface TrajectoryPageResult {
     events: readonly DaemonEvent[];
     hasMore: boolean;
+    /** Where the next older page starts; absent when there is none to ask for. */
+    nextCursor?: string;
     partial?: true;
     replayError?: string;
 }
 /**
- * Fetches the newest page of the session's transcript.
+ * Fetches one page of the session's transcript: the newest without a cursor,
+ * the one older than a previous page with that page's `nextCursor`.
  *
  * Supplied by the host rather than called here so the panel never reaches for
  * a daemon client of its own. There is no cancellation: the daemon client
@@ -32,11 +47,12 @@ export interface TrajectoryPageResult {
  */
 export type TrajectoryPageLoader = (opts: {
     limit: number;
+    cursor?: string;
 }) => Promise<TrajectoryPageResult>;
 /**
- * Why the last read failed. `partial` is not a message — the daemon reports it
- * as a flag — so it is carried as a kind for the view to name, rather than as
- * a word that would end up quoted at the reader.
+ * Why a read failed. `partial` is not a message — the daemon reports it as a
+ * flag — so it is carried as a kind for the view to name, rather than as a
+ * word that would end up quoted at the reader.
  */
 export type TrajectoryWindowFailure = {
     kind: 'partial';
@@ -47,29 +63,51 @@ export type TrajectoryWindowFailure = {
 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;
     /**
-     * The session has history older than what this page carries. Nothing here
-     * can reach it yet, so the view says so rather than offering an action.
+     * 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.
      */
     truncated: boolean;
-    /** Re-read the newest page. Also how a failed read is retried. */
+    /**
+     * 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. */
     refresh: () => void;
 }
 /**
- * Hold the newest page of one session's transcript and fold it into a
- * trajectory.
+ * 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.
  *
- * The page is 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` replaces the page rather than splicing into it: page boundaries
- * are chosen per request, so a fresh page and the held one overlap by an
- * unknown amount and cannot be joined without dropping or repeating records.
+ * `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.
  */
 export declare function useTrajectoryWindow(loadPage: TrajectoryPageLoader | undefined, options?: {
     pageSize?: number;
+    maxPages?: number;
 }): TrajectoryWindow;

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const WEB_SHELL_PAGES: readonly ["plugins", "channels", "scheduled-tasks", "goals", "settings"];
+export type WebShellPage = (typeof WEB_SHELL_PAGES)[number];
+export interface SessionUrlTarget {
+    sessionId?: string;
+    workspaceId?: string;
+    context?: 'standalone' | 'live';
+}
+export type WebShellRoute = {
+    page: WebShellPage;
+} | ({
+    page: 'chat';
+} & SessionUrlTarget);
+export declare function normalizeNavigationBasePath(basePath?: string): string;
+export declare function isWebShellPage(value: string): value is WebShellPage;
+export declare function readNavigationUrl(url: URL, basePath?: string): WebShellRoute | undefined;
+export declare function buildNavigationUrl(current: URL, route: WebShellRoute, basePath?: string): URL;

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

@@ -0,0 +1,22 @@
+/**
+ * The top clearance a host declares for upward-opening popovers through
+ * `--web-shell-popover-safe-top`, or `undefined` when it declares none. A
+ * declared `0px` stays 0 instead of falling back to a default.
+ */
+export declare function readPopoverSafeTop(element: Element): number | undefined;
+export declare const POPOVER_MIN_HEIGHT = 96;
+/**
+ * The highest viewport y at which a popover positioned inside `anchor` is still
+ * painted: below the top edge of every ancestor that clips its overflow, and
+ * below the host's declared safe top.
+ *
+ * With no declared safe top the bound starts at 0, because an in-flow popover
+ * is already bounded by the clipping ancestors this walk measures. A popover
+ * portaled out of that chain has no clipping ancestor to measure and needs a
+ * numeric allowance instead — see AtMentionPanel's
+ * `readPopoverSafeTop(anchor) ?? 48`. Keep the two defaults distinct: folding
+ * the 48 in here would steal room from in-flow popovers, and folding the 0
+ * into AtMentionPanel would let it rise under a host header that declares
+ * nothing.
+ */
+export declare function popoverTopEdge(anchor: Element): number;

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

@@ -3,6 +3,7 @@
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+export declare function inferStandaloneBasePath(pathname: string): string;
 /**
  * Build the pathname for a standalone session URL while preserving any base
  * path the app is deployed under (e.g. `/app/session/<id>` stays under

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

@@ -1,3 +1,4 @@
+export declare function buildUnifiedDiff(oldText: string, newText: string): string;
 interface UnifiedDiffLine {
     type: 'add' | 'del' | 'context' | 'header';
     content: string;

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

@@ -10,8 +10,9 @@ import type { DaemonCapabilities, DaemonSessionSummary, DaemonWorkspaceCapabilit
  * it has no segments.
  */
 export declare function workspaceBasename(cwd: string): string;
-export declare function workspaceLabel(workspace: Pick<DaemonWorkspaceCapability, 'cwd' | 'displayName'>): string;
-export declare function workspaceLabelForCwd(cwd: string, workspaces: readonly Pick<DaemonWorkspaceCapability, 'cwd' | 'displayName'>[] | undefined): 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;
 /**
  * True when the daemon advertises more than one registered workspace — i.e. the
  * multi-workspace session surfaces (per-workspace labels/tags) should show.