@qwen-code/web-shell 0.24.4 → 0.24.5-nightly.20260925.c3a4058a0c

package/dist/types/components/dialogs/DeleteSessionDialog.d.ts

@@ -1,5 +1,13 @@
 interface DeleteSessionDialogProps {
-    onDeleted: (sessionIds: string[]) => void;
+    /**
+     * `attachedSessionId` is the session this client was attached to when the
+     * delete was confirmed. The daemon publishes the terminal `session_closed`
+     * frame before it answers the delete request, so by the time this fires the
+     * caller can no longer read the attachment off the connection (#12619).
+     */
+    onDeleted: (sessionIds: string[], meta?: {
+        attachedSessionId?: string;
+    }) => void;
     onError: (error: unknown) => void;
     onClose: () => void;
     workspaceCwd?: string;

package/dist/types/components/dialogs/GitDialog.d.ts

@@ -3,12 +3,16 @@
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-export type GitDialogView = 'diff' | 'log' | 'prs' | 'commit';
-export declare function GitDialog({ workspaceCwd, gitCwd, initialView, sessionId, resolveSessionForWorkspace, onClose, }: {
+export type GitDialogView = 'diff' | 'log' | 'prs' | 'worktrees' | 'commit';
+export declare function GitDialog({ workspaceCwd, gitCwd, initialView, sessionId, resolveSessionForWorkspace, onOpenSession, onNewWorktreeSession, onClose, }: {
     workspaceCwd: string;
     gitCwd?: string;
     initialView: GitDialogView;
     sessionId?: string;
     resolveSessionForWorkspace?: (cwd: string, forceCreate?: boolean) => Promise<string | undefined>;
+    /** Worktrees tab: switch to a session that lives in a worktree. */
+    onOpenSession?: (sessionId: string) => void;
+    /** Worktrees tab: start a new session in a fresh worktree. */
+    onNewWorktreeSession?: () => void;
     onClose: () => void;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/dialogs/GitWorktreesDialog.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function GitWorktreesContent({ workspaceCwd, onOpenSession, onNewWorktreeSession, onSubtitleChange, }: {
+    workspaceCwd: string;
+    onOpenSession?: (sessionId: string) => void;
+    onNewWorktreeSession?: () => void;
+    onSubtitleChange?: (subtitle: string | undefined) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/managed/ManagedSessionProgress.d.ts

@@ -0,0 +1,6 @@
+import type { ManagedAgentSessionSummary } from './managed-agent-provider';
+export declare function ManagedSessionProgress({ summary, submitting, loading, }: {
+    summary?: ManagedAgentSessionSummary;
+    submitting: boolean;
+    loading: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/managed/ManagedSessionsPage.d.ts

@@ -0,0 +1,7 @@
+import type { ManagedAgentProvider } from './managed-agent-provider';
+export declare function ManagedSessionsPage({ sessionId, onSelectSession, workspaceCwd, managedAgentProvider, }: {
+    sessionId?: string;
+    onSelectSession: (sessionId: string | undefined) => void;
+    workspaceCwd?: string;
+    managedAgentProvider?: ManagedAgentProvider;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/managed/java-managed-agent-client.d.ts

@@ -0,0 +1,140 @@
+export type JavaAgentDate = number | string;
+export interface JavaAgentTurn {
+    turnId: string;
+    sessionId: string;
+    status: string;
+    submittedAt: JavaAgentDate;
+    completedAt?: JavaAgentDate;
+    errorCode?: string;
+    usage?: Record<string, unknown>;
+}
+export interface JavaAgentEnvironment {
+    environmentId?: string;
+    state?: string;
+    errorCode?: string;
+}
+export interface JavaAgentSession {
+    sessionId: string;
+    title?: string;
+    agentId?: string;
+    status: string;
+    createdAt: JavaAgentDate;
+    updatedAt: JavaAgentDate;
+    activeTurn?: JavaAgentTurn;
+    environment?: JavaAgentEnvironment;
+    lastSequence: number;
+}
+export interface JavaAgentEvent {
+    sequence: number;
+    eventId: string;
+    sessionId: string;
+    turnId: string;
+    itemId?: string;
+    type: string;
+    createdAt: JavaAgentDate;
+    data?: Record<string, unknown>;
+    terminal: boolean;
+}
+export interface JavaAgentContentPart {
+    partId: string;
+    type: 'input_text' | 'output_text' | 'reasoning' | string;
+    text: string;
+    firstSequence: number;
+    lastSequence: number;
+}
+export interface JavaAgentItem {
+    itemId: string;
+    sessionId: string;
+    turnId: string;
+    type: 'message' | 'tool_call' | string;
+    role?: string;
+    status: string;
+    content: JavaAgentContentPart[];
+    attributes: Record<string, unknown>;
+    firstSequence: number;
+    lastSequence: number;
+    createdAt: JavaAgentDate;
+    updatedAt: JavaAgentDate;
+}
+export interface JavaAgentCommandAdmission {
+    sessionId: string;
+    turnId?: string;
+    status: string;
+    replayed: boolean;
+}
+export interface JavaAgentCursorPage<T> {
+    data: T[];
+    nextCursor?: string;
+    hasMore: boolean;
+}
+export interface JavaAgentTranscript {
+    items?: JavaAgentItem[];
+    events: JavaAgentEvent[];
+    coveredSequence?: number;
+    olderCursor?: string;
+    hasMore: boolean;
+    lastSequence: number;
+}
+export interface JavaManagedAgentClientOptions {
+    baseUrl: string;
+    getHeaders?: () => HeadersInit | Promise<HeadersInit>;
+    credentials?: RequestCredentials;
+    fetch?: typeof fetch;
+}
+export declare class JavaManagedAgentHttpError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare class JavaManagedAgentClient {
+    private readonly options;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly credentials;
+    constructor(options: JavaManagedAgentClientOptions);
+    listSessions(request: {
+        cursor?: string;
+        limit?: number;
+    }, signal?: AbortSignal): Promise<JavaAgentCursorPage<JavaAgentSession>>;
+    getSession(sessionId: string, signal?: AbortSignal): Promise<JavaAgentSession>;
+    getTranscript(request: {
+        sessionId: string;
+        cursor?: string;
+        limit?: number;
+    }, signal?: AbortSignal): Promise<JavaAgentTranscript>;
+    createSession(request: {
+        requestId: string;
+        idempotencyKey: string;
+        agentId: string;
+        environmentId?: string;
+        title?: string;
+        input: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        metadata?: Record<string, unknown>;
+    }, signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    submitTurn(request: {
+        requestId: string;
+        idempotencyKey: string;
+        sessionId: string;
+        input: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        metadata?: Record<string, unknown>;
+    }, signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    cancelTurn(request: {
+        requestId: string;
+        idempotencyKey: string;
+        sessionId: string;
+        turnId: string;
+    }, signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    streamEvents(request: {
+        sessionId: string;
+        afterSequence?: number;
+        limit?: number;
+    }, signal?: AbortSignal): AsyncGenerator<JavaAgentEvent>;
+    private post;
+    private request;
+}

package/dist/types/components/managed/java-managed-agent-event-projector.d.ts

@@ -0,0 +1,5 @@
+import type { JavaAgentDate, JavaAgentEvent, JavaAgentItem } from './java-managed-agent-client';
+import type { ManagedAgentSessionEvent } from './managed-agent-provider';
+export declare function projectJavaAgentEvent(event: JavaAgentEvent): ManagedAgentSessionEvent | undefined;
+export declare function projectJavaAgentItem(item: JavaAgentItem): ManagedAgentSessionEvent[];
+export declare function toTimestamp(value: JavaAgentDate | undefined): number;

package/dist/types/components/managed/java-managed-agent-provider.d.ts

@@ -0,0 +1,8 @@
+import { type JavaManagedAgentClientOptions } from './java-managed-agent-client';
+import type { ManagedAgentProvider } from './managed-agent-provider';
+export interface JavaManagedAgentProviderOptions extends JavaManagedAgentClientOptions {
+    agentId?: string;
+    environmentId?: string;
+    productScope?: string;
+}
+export declare function createJavaManagedAgentProvider(options: JavaManagedAgentProviderOptions): ManagedAgentProvider;

package/dist/types/components/managed/managed-agent-provider.d.ts

@@ -0,0 +1,77 @@
+export type ManagedAgentSessionPhase = 'admitted' | 'runtime_starting' | 'agent_running' | 'waiting_runtime' | 'tool_running' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
+export type ManagedAgentRuntimeState = 'unknown' | 'starting' | 'ready' | 'failed';
+export interface ManagedAgentSessionSummary {
+    sessionId: string;
+    activeTurnId?: string;
+    title: string;
+    workspaceCwd?: string;
+    createdAt: number;
+    admittedAt: number;
+    updatedAt: number;
+    phase: ManagedAgentSessionPhase;
+    runtimeReady: boolean;
+    runtimeState: ManagedAgentRuntimeState;
+    capabilities: {
+        canSend: boolean;
+        canCancel: boolean;
+    };
+    failure?: {
+        code: string;
+        message: string;
+    };
+}
+export type ManagedAgentSessionEventType = 'accepted' | 'runtime_starting' | 'runtime_ready' | 'runtime_failed' | 'runtime_released' | 'agent_started' | 'assistant_thought' | 'assistant_delta' | 'tool_requested' | 'tool_started' | 'tool_completed' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'stream_gap';
+export interface ManagedAgentSessionEvent {
+    id: number;
+    at: number;
+    type: ManagedAgentSessionEventType;
+    sessionId: string;
+    turnId: string;
+    data?: unknown;
+}
+export interface ManagedAgentSessionTranscript {
+    events: ManagedAgentSessionEvent[];
+    olderCursor?: string;
+    lastEventId: number;
+}
+export interface ManagedAgentTurnAdmission {
+    sessionId: string;
+    turnId: string;
+}
+export interface ManagedAgentRequestOptions {
+    clientId: string;
+    signal?: AbortSignal;
+}
+export interface ManagedAgentCommandOptions extends ManagedAgentRequestOptions {
+    idempotencyKey: string;
+}
+export interface ManagedAgentProvider {
+    readonly kind: 'daemon' | 'java';
+    readonly storageKey: string;
+    readonly canCancel: boolean;
+    readonly acceptsWorkspaceCwd: boolean;
+    listSessions(options: ManagedAgentRequestOptions & {
+        workspaceCwd?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        sessions: ManagedAgentSessionSummary[];
+        nextCursor?: string;
+    }>;
+    getSession(sessionId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentSessionSummary>;
+    getTranscript(sessionId: string, options: ManagedAgentRequestOptions & {
+        before?: string;
+        limit?: number;
+    }): Promise<ManagedAgentSessionTranscript>;
+    createSession(request: {
+        text: string;
+        workspaceCwd?: string;
+    }, options: ManagedAgentCommandOptions): Promise<ManagedAgentTurnAdmission>;
+    submitPrompt(sessionId: string, request: {
+        text: string;
+    }, options: ManagedAgentCommandOptions): Promise<ManagedAgentTurnAdmission>;
+    cancel(sessionId: string, turnId: string, options: ManagedAgentCommandOptions): Promise<void>;
+    subscribeEvents(sessionId: string, options: ManagedAgentRequestOptions & {
+        lastEventId?: number;
+    }): AsyncIterable<ManagedAgentSessionEvent>;
+}

package/dist/types/components/managed/managed-session-messages.d.ts

@@ -0,0 +1,4 @@
+import type { Message } from '../../adapters/types';
+import type { ManagedAgentSessionEvent } from './managed-agent-provider';
+export declare function mergeManagedEvents(current: readonly ManagedAgentSessionEvent[], incoming: readonly ManagedAgentSessionEvent[]): ManagedAgentSessionEvent[];
+export declare function managedEventsToMessages(events: readonly ManagedAgentSessionEvent[], truncatedLabel: string): Message[];

package/dist/types/components/managed/managed-session-storage.d.ts

@@ -0,0 +1,7 @@
+export declare function managedRequestId(): string;
+export declare function getManagedClientId(baseUrl: string): string;
+export declare function managedSelectionFromUrl(): {
+    open: boolean;
+    sessionId?: string;
+};
+export declare function saveManagedSelection(open: boolean, sessionId?: string): void;

package/dist/types/components/managed/use-managed-session.d.ts

@@ -0,0 +1,12 @@
+import type { ManagedAgentProvider, ManagedAgentSessionEvent, ManagedAgentSessionSummary } from './managed-agent-provider';
+export declare function useManagedSession(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined): {
+    loadingOlder: boolean;
+    loadOlder: () => Promise<void>;
+    reload: () => void;
+    sessionId?: string;
+    summary?: ManagedAgentSessionSummary;
+    events: ManagedAgentSessionEvent[];
+    olderCursor?: string;
+    loading: boolean;
+    error?: string;
+};

package/dist/types/components/messages/AuthMessage.d.ts

@@ -1,6 +1,7 @@
 interface AuthMessageProps {
+    allowAdd?: boolean;
     onMessage: (text: string, type?: 'status' | 'error') => void;
     onClose: () => void;
 }
-export declare function AuthMessage({ onMessage, onClose }: AuthMessageProps): import("react/jsx-runtime").JSX.Element;
+export declare function AuthMessage({ onMessage, onClose, allowAdd, }: AuthMessageProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/messages/LinkifiedText.d.ts

@@ -1,6 +1,6 @@
 /**
  * Plain-text renderer that turns explicit http(s) URLs into anchors. Mirrors
- * MarkdownLink's safety (`isSafeHref`) and desktop-shell routing
+ * MarkdownLink's safety (`isSafeHref`) and desktop-host routing
  * (`useExternalLinkOpener`); text without URLs passes through untouched.
  */
 export declare const LinkifiedText: import("react").NamedExoticComponent<{

package/dist/types/components/messages/ModelManagementSection.d.ts

@@ -1,3 +1,4 @@
+import type { WebShellModelManagementOptions } from '../../modelManagement';
 import type { DaemonModelConfiguration, DaemonModelConfigurationUpdateResult } from '@qwen-code/sdk/daemon';
 import type { DaemonWorkspaceProviderStatus } from '@qwen-code/web-shell/daemon-react-sdk';
 export interface ModelDeleteTarget {
@@ -6,7 +7,7 @@ export interface ModelDeleteTarget {
     modelId: string;
     baseUrl?: string;
 }
-export interface ModelManagementProps {
+export interface ModelManagementProps extends WebShellModelManagementOptions {
     providers: DaemonWorkspaceProviderStatus[];
     configurations?: DaemonModelConfiguration[];
     onUpdateContextWindow?: (key: string, size: number | null) => Promise<DaemonModelConfigurationUpdateResult>;
@@ -20,4 +21,4 @@ export interface ModelManagementProps {
     onDeleteModel: (target: ModelDeleteTarget) => void;
     onAddModel: () => void;
 }
-export declare function ModelManagementSection({ providers, configurations, onUpdateContextWindow, currentModelId, loading, error, busy, onSelectModel, onDeleteModel, onAddModel, }: ModelManagementProps): import("react/jsx-runtime").JSX.Element;
+export declare function ModelManagementSection({ allowAdd, allowDelete, providers, configurations, onUpdateContextWindow, currentModelId, loading, error, busy, onSelectModel, onDeleteModel, onAddModel, }: ModelManagementProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/PlanExecutionView.d.ts

@@ -1,6 +1,9 @@
-import type { DaemonSessionAgentTaskStatus, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
 import type { ACPToolCall, TodoItem } from '../../adapters/types';
-export type PlanNodeStatus = 'running' | 'paused' | 'completed' | 'blocked' | 'in_progress' | 'ready';
+import { type PlanNodeStatus } from './taskExecutionIndex';
+import type { SessionWorkflowProjection } from '../workflow/session-workflow-model';
+export { createTaskExecutionIndex, getActiveAgents, getActiveAgentsFromIndex, getAttentionAgentStatuses, getAttentionAgentTool, getPlanNodeState, getPlanNodeStateFromIndex, nestedAgentToolsForTool, nestedTasksFromIndex, nestedTasksForTool, todoIdOf, } from './taskExecutionIndex';
+export type { PlanNodeStatus, TaskExecutionIndex } from './taskExecutionIndex';
 /**
  * Status is carried by a glyph as well as a colour so the graph survives
  * colour-blindness, high-contrast mode, and a greyscale screenshot. Every
@@ -8,73 +11,18 @@ export type PlanNodeStatus = 'running' | 'paused' | 'completed' | 'blocked' | 'i
  */
 export declare const PLAN_STATUS_GLYPH: Record<PlanNodeStatus, string>;
 export declare function layerPlanTodos(todos: readonly TodoItem[]): TodoItem[][];
-export interface TaskExecutionIndex {
-    rootByToolCallId: ReadonlyMap<string, DaemonSessionAgentTaskStatus>;
-    childrenByParentId: ReadonlyMap<string, DaemonSessionAgentTaskStatus[]>;
-    nestedByRootId: Map<string, Array<{
-        task: DaemonSessionAgentTaskStatus;
-        depth: number;
-    }>>;
-}
-export declare function createTaskExecutionIndex(tasks: readonly DaemonSessionTaskStatus[]): TaskExecutionIndex;
-export declare function nestedTasksFromIndex(tool: ACPToolCall, taskIndex: TaskExecutionIndex): Array<{
-    task: DaemonSessionAgentTaskStatus;
-    depth: number;
-}>;
-export declare function nestedTasksForTool(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): Array<{
-    task: DaemonSessionAgentTaskStatus;
-    depth: number;
-}>;
-/**
- * Deliberately uncached. Keying on the tool object would be wrong the moment
- * a reused object gains a sub-tool — `appendSubTool` mutates `subTools` in
- * place — and the only thing standing between that and a stale render is
- * `useMessages`' prefix-reuse rule in another module. The callers' own
- * derivations are memoized, so the repetition this would remove is bounded to
- * a single derivation; a silent wrong subtree is not worth that.
- */
-export declare function nestedAgentToolsForTool(tool: ACPToolCall): Array<{
-    tool: ACPToolCall;
-    depth: number;
-}>;
-/**
- * Same agent-status walk as {@link attentionAgentStatuses}, for callers that
- * hold the raw task list instead of a prebuilt index (the cockpit's stats
- * strip, which must tally exactly what the attention queue shows).
- */
-export declare function getAttentionAgentStatuses(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): string[];
-/**
- * One entry per agent the overview strip reports as active, and the single
- * source the workflow inspector summary counts: the live daemon task when
- * one exists, otherwise a transcript-derived stand-in for an in-flight tool
- * call with no live task (the replay shape). The walk mirrors the node
- * badges (executionStatus), so the strip, the badges, and the inspector can
- * never contradict each other. An agent observed through BOTH a live task
- * and a persisted transcript tool counts once (dedup by toolUseId).
- */
-export declare function getActiveAgents(tools: readonly ACPToolCall[], tasks: readonly DaemonSessionTaskStatus[]): DaemonSessionAgentTaskStatus[];
-/**
- * {@link getActiveAgents} for callers that already hold an index. Building the
- * index is O(tasks); doing it per todo and per tool — as the workflow
- * projection used to — makes the walk O((todos + tools) x tasks) for a result
- * that never varies with the todo or the tool.
- */
-export declare function getActiveAgentsFromIndex(tools: readonly ACPToolCall[], taskIndex: TaskExecutionIndex): DaemonSessionAgentTaskStatus[];
-export declare function getPlanNodeStateFromIndex(todo: TodoItem, todosById: ReadonlyMap<string, TodoItem>, tools: readonly ACPToolCall[], taskIndex: TaskExecutionIndex): {
-    status: PlanNodeStatus;
-    attention: boolean;
-};
-export declare function getPlanNodeState(todo: TodoItem, todosById: ReadonlyMap<string, TodoItem>, tools: readonly ACPToolCall[], tasks: readonly DaemonSessionTaskStatus[]): {
-    status: PlanNodeStatus;
-    attention: boolean;
-};
-/** The plan step a tool call was issued for, when it declares one. */
-export declare function todoIdOf(tool: ACPToolCall): string | undefined;
-export declare function getAttentionAgentTool(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): ACPToolCall | undefined;
-export declare function PlanExecutionView({ todos, tools, tasks, onOpenSubagent, hideTitle, selection, showStepDetails, }: {
+export declare function PlanExecutionView({ todos, tools, tasks, projection: sharedProjection, onOpenSubagent, hideTitle, selection, showStepDetails, }: {
     todos: readonly TodoItem[];
     tools: readonly ACPToolCall[];
     tasks: readonly DaemonSessionTaskStatus[];
+    /**
+     * A host that already derives the workflow projection (the cockpit, which
+     * mounts this graph beside the inspector) passes its own, so the whole
+     * surface shares one projection — and one task-execution index — per
+     * render instead of each component privately rebuilding both. Standalone
+     * mounts derive it from `todos` / `tools` / `tasks` here.
+     */
+    projection?: SessionWorkflowProjection;
     onOpenSubagent?: (tool: ACPToolCall) => void;
     /**
      * Drop the "Plan execution" caption when the host already titles the region.

package/dist/types/components/messages/SettingsMessage.d.ts

@@ -15,7 +15,7 @@ interface SettingsMessageProps {
     chatWidthMode: ChatWidthMode;
     onChatWidthModeChange: (mode: ChatWidthMode) => void;
     /** Model list/add/delete/select, rendered inside the Model category. */
-    modelManagement?: ModelManagementProps;
+    modelManagementSectionProps?: ModelManagementProps;
     /** Browser-local remote computer catalog and connection controls. */
     connections?: ReactNode;
     embedded?: boolean;
@@ -45,5 +45,5 @@ export type FlatRow = {
     localKey: 'chatWidth' | 'browserNotifications';
 };
 export declare function nextSettingIdx(rows: FlatRow[], current: number, dir: 1 | -1): number;
-export declare function SettingsMessage({ settingsState, presentation, onLanguageChange, onSubDialog, onThemeChange, chatWidthMode, onChatWidthModeChange, modelManagement, connections, embedded, initialCategory, }: SettingsMessageProps): import("react/jsx-runtime").JSX.Element;
+export declare function SettingsMessage({ settingsState, presentation, onLanguageChange, onSubDialog, onThemeChange, chatWidthMode, onChatWidthModeChange, modelManagementSectionProps, connections, embedded, initialCategory, }: SettingsMessageProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/messages/ToolFilePreviewButton.d.ts

@@ -1,7 +1,8 @@
 import type { ACPToolCall } from '../../adapters/types';
 import type { TurnOutputOpenRequest } from '../artifacts/TurnOutputs';
-export declare function ToolFilePreviewButton({ tool, workspaceCwd, onOpen, }: {
+export declare function ToolFilePreviewButton({ tool, workspaceCwd, onOpen, iconOnly, }: {
     tool: ACPToolCall;
     workspaceCwd?: string;
     onOpen?: (request: TurnOutputOpenRequest) => void;
+    iconOnly?: boolean;
 }): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/messages/ToolGroup.d.ts

@@ -43,6 +43,9 @@ export declare function getToolHeaderKind(tool: ACPToolCall): ToolHeaderKind;
 export declare function getActiveTool(tools: ACPToolCall[]): ACPToolCall;
 export declare function formatToolGroupSummary(tools: ACPToolCall[], t: ReturnType<typeof useI18n>['t'], workspaceCwd?: string, summarizeAgents?: boolean): string;
 export declare function formatSingleToolSummary(tool: ACPToolCall, t: ReturnType<typeof useI18n>['t'], workspaceCwd?: string): string;
+export declare function ToolSummaryIcon({ tool }: {
+    tool: ACPToolCall;
+}): import("react/jsx-runtime").JSX.Element;
 export declare function isWebFetchToolName(toolName: string): boolean;
 export declare const ToolLine: import("react").NamedExoticComponent<ToolLineProps>;
 export declare const ToolGroup: import("react").NamedExoticComponent<ToolGroupProps>;

package/dist/types/components/messages/codeHighlighter.d.ts

@@ -23,3 +23,10 @@ export declare function isTooLargeToHighlight(code: string): boolean;
 export declare function highlightToHtmlSync(code: string, lang: string, theme: string, persist?: boolean): string | null;
 /** Resets all module-level highlighter state (incl. the HTML cache). Tests only. */
 export declare function __resetForTesting(): void;
+export interface CodeHighlightRequest {
+    code: string;
+    language: string;
+    theme: 'light' | 'dark';
+}
+/** Uses the same engine and cache as transcript code blocks. Null means plain text. */
+export declare function highlightCode({ code, language, theme, }: CodeHighlightRequest): Promise<string | null>;

package/dist/types/components/messages/taskExecutionIndex.d.ts

@@ -0,0 +1,80 @@
+import type { DaemonSessionAgentTaskStatus, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall, TodoItem } from '../../adapters/types';
+/**
+ * Shared task-execution lookups for the plan surfaces. Extracted from
+ * `PlanExecutionView` so the workflow projection (`session-workflow-model`)
+ * and the graph (`PlanExecutionView`) both depend on this module instead of
+ * on each other, and so one build of the index can be threaded from the
+ * projection into every consumer in a single render.
+ */
+export type PlanNodeStatus = 'running' | 'paused' | 'completed' | 'blocked' | 'in_progress' | 'ready';
+export interface TaskExecutionIndex {
+    rootByToolCallId: ReadonlyMap<string, DaemonSessionAgentTaskStatus>;
+    childrenByParentId: ReadonlyMap<string, DaemonSessionAgentTaskStatus[]>;
+    nestedByRootId: Map<string, Array<{
+        task: DaemonSessionAgentTaskStatus;
+        depth: number;
+    }>>;
+}
+export declare function createTaskExecutionIndex(tasks: readonly DaemonSessionTaskStatus[]): TaskExecutionIndex;
+export declare function taskForTool(tool: ACPToolCall, taskIndex: TaskExecutionIndex): DaemonSessionAgentTaskStatus | undefined;
+export declare function executionStatus(tool: ACPToolCall, taskIndex: TaskExecutionIndex): string;
+export declare function nestedTasksFromIndex(tool: ACPToolCall, taskIndex: TaskExecutionIndex): Array<{
+    task: DaemonSessionAgentTaskStatus;
+    depth: number;
+}>;
+export declare function nestedTasksForTool(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): Array<{
+    task: DaemonSessionAgentTaskStatus;
+    depth: number;
+}>;
+/**
+ * Deliberately uncached. Keying on the tool object would be wrong the moment
+ * a reused object gains a sub-tool — `appendSubTool` mutates `subTools` in
+ * place — and the only thing standing between that and a stale render is
+ * `useMessages`' prefix-reuse rule in another module. The callers' own
+ * derivations are memoized, so the repetition this would remove is bounded to
+ * a single derivation; a silent wrong subtree is not worth that.
+ */
+export declare function nestedAgentToolsForTool(tool: ACPToolCall): Array<{
+    tool: ACPToolCall;
+    depth: number;
+}>;
+/**
+ * Same agent-status walk as {@link attentionAgentStatuses}, for callers that
+ * hold the raw task list instead of a prebuilt index (the cockpit's stats
+ * strip, which must tally exactly what the attention queue shows).
+ */
+export declare function getAttentionAgentStatuses(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): string[];
+/**
+ * One entry per agent the overview strip reports as active, and the single
+ * source the workflow inspector summary counts: the live daemon task when
+ * one exists, otherwise a transcript-derived stand-in for an in-flight tool
+ * call with no live task (the replay shape). The walk mirrors the node
+ * badges (executionStatus), so the strip, the badges, and the inspector can
+ * never contradict each other. An agent observed through BOTH a live task
+ * and a persisted transcript tool counts once (dedup by toolUseId).
+ */
+export declare function getActiveAgents(tools: readonly ACPToolCall[], tasks: readonly DaemonSessionTaskStatus[]): DaemonSessionAgentTaskStatus[];
+/**
+ * {@link getActiveAgents} for callers that already hold an index. Building the
+ * index is O(tasks); doing it per todo and per tool — as the workflow
+ * projection used to — makes the walk O((todos + tools) x tasks) for a result
+ * that never varies with the todo or the tool.
+ */
+export declare function getActiveAgentsFromIndex(tools: readonly ACPToolCall[], taskIndex: TaskExecutionIndex): DaemonSessionAgentTaskStatus[];
+export declare function getPlanNodeStateFromIndex(todo: TodoItem, todosById: ReadonlyMap<string, TodoItem>, tools: readonly ACPToolCall[], taskIndex: TaskExecutionIndex): {
+    status: PlanNodeStatus;
+    attention: boolean;
+};
+export declare function getPlanNodeState(todo: TodoItem, todosById: ReadonlyMap<string, TodoItem>, tools: readonly ACPToolCall[], tasks: readonly DaemonSessionTaskStatus[]): {
+    status: PlanNodeStatus;
+    attention: boolean;
+};
+/** The plan step a tool call was issued for, when it declares one. */
+export declare function todoIdOf(tool: ACPToolCall): string | undefined;
+/**
+ * A clickable stand-in for a live agent task that has no transcript tool
+ * call, so the graph's nested execution rows can still open its panel.
+ */
+export declare function toolForNestedTask(task: DaemonSessionAgentTaskStatus): ACPToolCall | undefined;
+export declare function getAttentionAgentTool(tool: ACPToolCall, tasks: readonly DaemonSessionTaskStatus[]): ACPToolCall | undefined;

package/dist/types/components/messages/toolFormatting.d.ts

@@ -20,6 +20,7 @@ export declare function formatToolDisplayName(toolName: string): string;
  */
 export declare function localizeToolDisplayName(toolName: string, t: (key: string, vars?: Record<string, string | number>) => string): string;
 export declare function isAskUserQuestionToolName(toolName: string): boolean;
+export declare function isAdvisorToolName(toolName: string): boolean;
 export declare function isCompletedAskUserQuestion(tool: ACPToolCall): boolean;
 export declare function getQuestionAnswerResult(tool: ACPToolCall): {
     text: string;
@@ -33,6 +34,7 @@ export declare function getToolDescription(tool: ACPToolCall, workspaceCwd?: str
 export declare function getToolSummaryDescription(tool: ACPToolCall, workspaceCwd?: string): string;
 export declare function getShellToolSemanticDescription(tool: ACPToolCall): string;
 export declare function extractText(tool: ACPToolCall): string | null;
+export declare function getAdvisorDisplayText(tool: ACPToolCall): string | null;
 export declare function getToolResultSummary(tool: ACPToolCall): string;
 /**
  * Like every other is*ToolName helper, normalizes case so callers can pass
@@ -61,3 +63,4 @@ export declare function isDefaultAgentType(agentType: string): boolean;
 export declare function localizeAgentTypeName(agentType: string, t: (key: string, vars?: Record<string, string | number>) => string): string;
 export declare function getAgentDescription(agent: ACPToolCall): string;
 export declare function getAgentCurrentToolHint(agent: ACPToolCall, t: (key: string, vars?: Record<string, string | number>) => string): string;
+export declare function extractRawOutputText(rawOutput: unknown): string | null;

package/dist/types/components/panels/EnvironmentPanel.d.ts

@@ -26,6 +26,7 @@ interface EnvironmentPanelProps {
     items?: readonly WebShellEnvironmentPanelItem[];
     onOpenGitDiff?: () => void;
     onOpenGitCommit?: () => void;
+    onOpenGitWorktrees?: () => void;
     onOpenGitLog?: () => void;
     onOpenAgent?: (task: DaemonSessionAgentTaskStatus) => void;
     onOpenAgentWorkflow?: () => void;
@@ -42,5 +43,5 @@ export type EnvironmentAgentTask = DaemonSessionAgentTaskStatus & {
     color?: string;
     lineageState?: 'complete' | 'orphaned' | 'cycle';
 };
-export declare function EnvironmentPanel({ sources, onOpenSource, retrySourceRegistration, floating, hidden, workspaceCwd, gitWorkspaceCwd, gitCwd, branch, gitStatus, tasks, agentTasks, attachments, attachmentsLoading, attachmentsError, onRetryAttachments, artifacts, artifactsLoading, items, onOpenGitDiff, onOpenGitCommit, onOpenGitLog, onOpenAgent, onOpenAgentWorkflow, onOpenTask, onReadImage, onImagePreview, onAttachmentPreview, onAttachmentPreviewError, onOpenArtifact, onDismiss, }: EnvironmentPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function EnvironmentPanel({ sources, onOpenSource, retrySourceRegistration, floating, hidden, workspaceCwd, gitWorkspaceCwd, gitCwd, branch, gitStatus, tasks, agentTasks, attachments, attachmentsLoading, attachmentsError, onRetryAttachments, artifacts, artifactsLoading, items, onOpenGitDiff, onOpenGitCommit, onOpenGitWorktrees, onOpenGitLog, onOpenAgent, onOpenAgentWorkflow, onOpenTask, onReadImage, onImagePreview, onAttachmentPreview, onAttachmentPreviewError, onOpenArtifact, onDismiss, }: EnvironmentPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};