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

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,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/WorkspaceHostProjects.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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;
+/**
+ * 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.
+ */
+export declare function OtherHostProjects(): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export declare function WorkspaceLocation({ cwd }: {
+    cwd?: string;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,11 @@
+import type { DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
+export declare const WorkspaceHostsEnabled: import("react").Context<boolean>;
+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;
+/** 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

@@ -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;

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: {};

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

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Trajectory, TrajectoryRow } from './types';
+export interface TrajectoryFilter {
+    query: string;
+    type: 'all' | TrajectoryRow['kind'];
+    status: 'all' | 'success' | 'error' | 'cancelled' | 'running' | 'unknown';
+}
+export interface TrajectorySearchIndex {
+    rows: Array<{
+        key: string;
+        kind: TrajectoryRow['kind'];
+        status?: Exclude<TrajectoryFilter['status'], 'all'>;
+        fields: string[];
+    }>;
+    truncatedCount: number;
+}
+export declare function buildTrajectorySearchIndex(trajectory: Trajectory): TrajectorySearchIndex;
+export declare function filterTrajectory(index: TrajectorySearchIndex, filter: TrajectoryFilter): string[];

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

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
+/**
+ * Whether everything a cancelled turn left behind its prompt can go with it.
+ * Thoughts count as nothing: cancelling mid-reasoning is exactly when taking
+ * the prompt back matters, and the TUI's restore-on-cancel treats them the
+ * same way. An answer, a tool call, shell output, a permission request or a
+ * later user message all keep the turn.
+ *
+ * Only meaningful once the daemon has settled the turn: until its terminal
+ * event arrives, "nothing received yet" is not "nothing produced".
+ */
+export declare function cancelledTurnProducedNothing(blocksAfterPrompt: readonly DaemonTranscriptBlock[]): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/web-shell",
-  "version": "0.25.0",
+  "version": "0.25.1-preview.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/QwenLM/qwen-code.git",
@@ -72,6 +72,7 @@
   },
   "devDependencies": {
     "@playwright/test": "1.61.1",
+    "@qwen-code/acp-bridge": "file:../acp-bridge",
     "@qwen-code/sdk": "file:../sdk-typescript",
     "@tailwindcss/vite": "^4.3.2",
     "@types/hast": "^3.0.5",