@qwen-code/web-shell 0.24.1-preview.0

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

@@ -0,0 +1,47 @@
+import type { PromptFile, PromptImage } from '../adapters/promptTypes';
+export type ImageIngestionRejectionReason = 'unavailable' | 'too-large' | 'read-failed';
+export interface ImageIngestionRejection {
+    name?: string;
+    reason: ImageIngestionRejectionReason;
+}
+export interface ImageFileCandidate {
+    file: File;
+    mediaType: string;
+}
+export interface AttachmentFileCandidate {
+    file: File;
+    mediaType: string;
+}
+export interface ExtractedFileTransfer {
+    claimed: boolean;
+    imageCandidates: ImageFileCandidate[];
+    fileCandidates: AttachmentFileCandidate[];
+    rejected: ImageIngestionRejection[];
+}
+export interface ImageIngestionBatchResult {
+    accepted: PromptImage[];
+    rejected: ImageIngestionRejection[];
+}
+export interface FileIngestionBatchResult {
+    accepted: PromptFile[];
+    rejected: ImageIngestionRejection[];
+}
+interface ReaderLifecycle {
+    onReaderCreated?: (reader: FileReader) => void;
+    onReaderSettled?: (reader: FileReader) => void;
+    maxBytes?: number;
+}
+export declare const MAX_IMAGE_ATTACHMENT_DATA_BYTES: number;
+export declare const MAX_FILE_ATTACHMENT_DATA_BYTES: number;
+export declare function normalizeImageMediaType(mediaType: string, fileName?: string): string | undefined;
+export declare function normalizeTextMediaType(mediaType: string, fileName?: string): string | undefined;
+export declare function sanitizeAttachmentName(name: string): string;
+export declare function dedupeAttachmentName(name: string, taken: ReadonlySet<string>): string;
+export declare function hasFileTransferPayload(dataTransfer: DataTransfer): boolean;
+export declare function extractFiles(files: readonly File[]): ExtractedFileTransfer;
+export declare function extractFileTransfer(dataTransfer: DataTransfer, source: 'paste' | 'drop'): ExtractedFileTransfer;
+export declare function readImageTransfer(imageCandidates: readonly ImageFileCandidate[], lifecycle?: ReaderLifecycle): Promise<ImageIngestionBatchResult>;
+export declare function readFileTransfer(fileCandidates: readonly AttachmentFileCandidate[], options?: {
+    maxBytes?: number;
+}): Promise<FileIngestionBatchResult>;
+export {};

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

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PromptFile } from '../adapters/promptTypes';
+/**
+ * A paste at or above either threshold is folded into an attachment card
+ * instead of being inserted into the editor.
+ *
+ * The line count keeps the rule legible to a user; the character count keeps it
+ * honest, because one minified line can carry megabytes. A fragment left inline
+ * stays under the daemon's 16,384-character mid-turn insertion limit — that
+ * limit bounds one queued message, so a draft assembled from several sub-
+ * threshold pastes or from typing can still exceed it.
+ *
+ * These thresholds are deliberately larger than the terminal UI's
+ * `isLargePaste` thresholds (10 lines / 1,000 characters): the terminal folds
+ * into a placeholder inside a single-line prompt, while this folds into an
+ * attachment card. Neither consumer can import the other's module, so the two
+ * are separate policies by intent, not by oversight.
+ */
+export declare const PASTE_FOLD_MIN_LINES = 200;
+export declare const PASTE_FOLD_MIN_CHARS = 8000;
+/** How much of the paste the card shows as its title. */
+export declare const PASTE_TITLE_MAX_CHARS = 24;
+/**
+ * Titles a folded card with the beginning of the paste itself, and doubles as
+ * the attachment's name: line breaks and runs of whitespace collapse to single
+ * spaces, and characters a file name cannot carry become spaces too, so a paste
+ * whose first line is one word still yields a title that reads and a name the
+ * sanitizer will not rewrite. Falls back to the stem when there is no content.
+ */
+export declare function pastedTextTitle(text: string, fallbackName: string): string;
+export declare function countTextLines(text: string): number;
+export declare function shouldFoldPastedText(text: string): boolean;
+/**
+ * Builds the card for a folded paste. The name is the card's title with a
+ * `.txt` suffix, so the sent message shows what the card showed; the suffix is
+ * load-bearing, not cosmetic — the daemon derives a stored attachment's type
+ * from its stored name, so a name without it resolves the content as an opaque
+ * blob instead of text.
+ */
+export declare function createPastedTextFile(text: string, taken: ReadonlySet<string>): PromptFile;

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

@@ -0,0 +1,19 @@
+/**
+ * Split plain text into URL and non-URL segments so callers can render the URL
+ * parts as anchors. Only explicit `http://` / `https://` URLs match — bare
+ * domains and emails are left as text on purpose. The character set is an
+ * allowlist of the ASCII URL grammar, so anything else — whitespace, markup
+ * delimiters, CJK prose, emoji — terminates the match (`详情见https://a.com即可`
+ * splits at the boundary, `https://a.com👍` does not absorb the emoji).
+ * Trailing ASCII sentence punctuation, markdown emphasis delimiters (`*`,
+ * `_`, `~`), and closing brackets with no matching opener inside the URL are
+ * trimmed from it (so `https://en.wikipedia.org/wiki/Foo_(bar)` keeps its `)`
+ * while `(see https://example.com/foo)` drops it, and `**https://a.com**`
+ * sheds the asterisks). A match that trims down to the bare scheme
+ * (`https://`) is not a URL and stays text.
+ */
+export interface LinkifySegment {
+    type: 'text' | 'url';
+    value: string;
+}
+export declare function splitTextByUrls(text: string): LinkifySegment[];

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

@@ -0,0 +1,47 @@
+import type { PromptImage } from '../adapters/promptTypes';
+/**
+ * Single choke point for echoing a local slash command into the transcript.
+ *
+ * Some local commands "echo": they append a local user message
+ * (`store.appendLocalUserMessage`) and render their result inline. If one runs
+ * while a turn is streaming, the injected user row acts as a turn boundary in
+ * `applyTurnCollapse` (a turn spans one user message up to the next) and splits
+ * the active turn into two — its tool/thinking/token counters are then computed
+ * per fragment and come out wrong.
+ *
+ * Routing every echo through this helper means a command can never append to the
+ * transcript mid-turn. While a turn is in flight the command is suppressed
+ * instead of being added to the daemon pending-prompt queue, because local
+ * commands must not be replayed as model-facing prompt text.
+ *
+ * The only call sites that should bypass this and append mid-stream are the
+ * deliberate "busy acknowledgement" paths (e.g. clearing a goal while a turn
+ * runs), which opt in by calling `append` directly. Read-only display
+ * commands (/stats, /about, /context) go through the same helper but ignore
+ * its suppression signal: they skip the echo mid-turn and still run
+ * immediately.
+ */
+export interface LocalEchoSink {
+    /** Append the command as a local user message (renders inline immediately). */
+    append: (text: string) => void;
+}
+/**
+ * Append a local command's echo, or suppress it if a turn is streaming.
+ *
+ * @returns `true` if the command was suppressed — the caller must stop and not
+ *   run its inline side effects. `false` if it was appended and the caller
+ *   should proceed. Read-only display commands are the deliberate exception:
+ *   they ignore the signal and run mid-turn anyway (see the module docstring).
+ */
+export declare function appendOrDeferLocalUserMessage(isStreaming: boolean, text: string, _images: PromptImage[] | undefined, sink: LocalEchoSink): boolean;
+/**
+ * Whether a queued prompt is a slash (`/…`) or shell (`!…`) command rather than
+ * model-facing prose.
+ *
+ * The queue's "insert" action injects the raw text into the running turn via
+ * `enqueueMidTurnMessage` — it is NOT re-dispatched as a command, so a command
+ * inserted this way reaches the model as the literal string "/context …" and
+ * never runs. Callers use this to disable "insert" for command entries that may
+ * still exist from daemon/custom command paths or from older sessions.
+ */
+export declare function isCommandPrompt(text: string): boolean;

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

@@ -0,0 +1 @@
+export declare function getModelDisplayName(modelId: string): string;

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

@@ -0,0 +1,15 @@
+/**
+ * Encodes a model ID from ACP format (modelId(authType)) to storage format
+ * (authType:modelId). Core's resolveVisionModelSelection() expects this format.
+ * If the input is not in ACP format, returns it unchanged.
+ */
+export declare function encodeVisionModelForSetting(modelId: string): string;
+export declare function extractBareModelId(modelId: string): string;
+/**
+ * Decodes a stored model ID from authType:modelId format back to ACP format
+ * (modelId(authType)). Used for picker comparison where model IDs are in ACP
+ * format. Splits on the first colon — safe for colon-bearing model IDs
+ * (e.g., 'openai:gpt-4o:online' → 'gpt-4o:online(openai)').
+ * If the input has no colon, returns it unchanged.
+ */
+export declare function decodeVisionModelForPicker(storedValue: string): string;

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

@@ -0,0 +1,4 @@
+import type { Message, SystemMessage } from '../adapters/types';
+export declare function parseModelSwitchStatusModel(content: string): string | null;
+export declare function isModelSwitchSummaryMessage(message: Message): message is SystemMessage;
+export declare function filterModelSwitchMessages(messages: readonly Message[]): Message[];

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

@@ -0,0 +1,3 @@
+import type { DaemonSessionMonitorTaskStatus, DaemonSessionTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall } from '../adapters/types';
+export declare function findMonitorTaskForTool(tasks: readonly DaemonSessionTaskStatus[], tool: ACPToolCall): DaemonSessionMonitorTaskStatus | undefined;

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

@@ -0,0 +1,5 @@
+export declare const EXECUTION_APPROVAL_MODES: ("auto" | "default" | "auto-edit" | "yolo")[];
+export declare function parsePlanCommand(args: string, enabled: boolean): {
+    enabled: boolean;
+    prompt?: string;
+};

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

@@ -0,0 +1 @@
+export declare function isDefinitelyRejectedPromptAdmission(error: unknown): boolean;

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

@@ -0,0 +1,21 @@
+export interface QueueDrainGate {
+    /** A drain is already in flight this tick. */
+    draining: boolean;
+    /** Waiting for the previously drained prompt's turn to start. */
+    awaitingTurnStart: boolean;
+    /** The daemon connection is live. */
+    connected: boolean;
+    /** A turn is in flight (streamingState !== 'idle'). */
+    streaming: boolean;
+    /** Some interaction (dialog, catch-up) is blocking input. */
+    interactionBlocked: boolean;
+    /** A tool approval is pending. */
+    pendingApproval: boolean;
+    /** Number of prompts currently queued. */
+    queueLength: number;
+}
+/**
+ * Whether the next queued prompt may be auto-drained into a new turn right now.
+ * Every condition must hold; any one being unmet holds the queue.
+ */
+export declare function canDrainQueue(gate: QueueDrainGate): boolean;

package/dist/types/utils/remote-name-skeleton.d.ts

@@ -0,0 +1 @@
+export declare function remoteNameSkeleton(name: string): string;

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

@@ -0,0 +1,4 @@
+export declare function createSentinelSerializer<T>(sentinel: string): {
+    serialize(data: T): string;
+    parse(content: string): T | null;
+};

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

@@ -0,0 +1,2 @@
+export declare function isSessionDisconnectedError(error: unknown): boolean;
+export declare function isTransientSessionReadError(error: unknown): boolean;

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * 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
+ * `/app` instead of being reset to `/session/<id>`). With no session id,
+ * returns the base path (or `/` at the root).
+ */
+export declare function buildSessionPathname(currentPathname: string, sessionId: string | undefined): string;
+/**
+ * Extract the session id from a standalone pathname. Anchored to the last
+ * `/session/<id>` segment so it agrees with `buildSessionPathname`'s greedy
+ * writer; a first-match parse would read the literal `session` segment when
+ * the base path itself ends in `/session` (e.g. `/app/session/session/<id>`).
+ */
+export declare function parseSessionId(pathname: string): string | undefined;

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

@@ -0,0 +1,77 @@
+import { type DaemonApprovalMode, type DaemonProductSessionContext } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { ReasoningSelection } from '@qwen-code/sdk/daemon';
+type PromptSessionActions = {
+    createSession: (options?: {
+        workspaceCwd?: string;
+        sessionContext?: DaemonProductSessionContext;
+        modelServiceId?: string;
+        approvalMode?: DaemonApprovalMode;
+        sourceType?: string;
+        worktree?: {
+            slug?: string;
+        };
+        branch?: {
+            name: string;
+        };
+    }) => Promise<{
+        sessionId: string;
+        worktree?: {
+            slug: string;
+            path: string;
+            branch: string;
+        };
+        branch?: {
+            name: string;
+            baseBranch: string;
+        };
+        modelApplied?: boolean;
+    }>;
+    attachSession: () => Promise<void>;
+    clearSession: () => Promise<void>;
+    releaseSession: (sessionId: string) => Promise<void>;
+    setApprovalMode?: (mode: DaemonApprovalMode, opts?: {
+        planMode?: boolean;
+    }) => Promise<{
+        mode: string;
+    }>;
+    setModel: (modelId: string) => Promise<unknown>;
+    setReasoningEffort: (value: ReasoningSelection, opts?: {
+        persist?: boolean;
+    }) => Promise<void>;
+};
+export declare function isDaemonApprovalMode(mode: string): mode is DaemonApprovalMode;
+export declare function createAndAttachSessionForPrompt({ sessionActions, modelId, reasoningEffort, modeId, planMode, workspaceCwd, sessionContext, worktree, branch, sessionSourceType, onSessionCreated, onSessionAllocated, getCurrentSessionId, warn, }: {
+    sessionActions: PromptSessionActions;
+    modelId?: string;
+    reasoningEffort?: ReasoningSelection;
+    modeId?: string;
+    planMode?: boolean;
+    workspaceCwd?: string;
+    sessionContext?: DaemonProductSessionContext;
+    worktree?: {
+        slug?: string;
+    };
+    branch?: {
+        name: string;
+    };
+    /**
+     * Creator attribution recorded on the session. Embedded hosts pass their own
+     * value so their sessions stay distinguishable from browser Web Shell ones.
+     */
+    sessionSourceType?: string;
+    onSessionCreated?: (sessionId: string) => Promise<void> | void;
+    onSessionAllocated?: (sessionId: string) => void;
+    getCurrentSessionId: () => string | undefined;
+    warn?: (message?: unknown, ...optionalParams: unknown[]) => void;
+}): Promise<{
+    worktree?: {
+        slug: string;
+        path: string;
+        branch: string;
+    };
+    branch?: {
+        name: string;
+        baseBranch: string;
+    };
+}>;
+export {};

package/dist/types/utils/slash-command-action.d.ts

@@ -0,0 +1,3 @@
+import type { WebShellSlashCommandHandler } from '../App';
+export declare const SLASH_COMMAND_PATTERN: RegExp;
+export declare function invokeSlashCommandHandler(input: string, handler: WebShellSlashCommandHandler | undefined, reportError: (error: unknown, fallback: string) => void): boolean;

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

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Per-row rendering plan for the slash command panel's section grouping. */
+export interface SlashSectionRowPlan {
+    /** Render the category header above this row (group boundary). */
+    showHeader: boolean;
+    /** Render the divider above the header (every boundary except the first row). */
+    showDivider: boolean;
+    /** Number of rows in this row's section; 0 when no header is shown. */
+    count: number;
+}
+/**
+ * Decide, for each item, whether it starts a new section (and so needs a header,
+ * a divider, and the group count). Extracted as a pure function so the section
+ * boundary logic — headers at group boundaries, a header but no divider on the
+ * first row, and no redundant headers for adjacent duplicate sections — is unit
+ * testable without rendering the panel.
+ *
+ * Only 'command' menus are grouped; subcommand menus render flat (no headers).
+ */
+export declare function planSlashSectionRows(items: ReadonlyArray<{
+    section?: string;
+}>, kind: 'command' | 'subcommand'): SlashSectionRowPlan[];

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

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Max sessions shown side by side in the split view. Each pane is a full
+ * session (its own SSE + transcript), so this bounds live connections and keeps
+ * panes readable. Shared so the overview caps a selection to the same limit
+ * before it ever builds a `?split=` URL or opens the in-window split.
+ */
+export declare const MAX_SPLIT_PANES = 6;
+/**
+ * Build an absolute URL that opens the app straight into the split view for the
+ * given sessions. Derived from the current location so it inherits the origin
+ * and any `?daemon=`/`?token=` query a dev deployment relies on; the trailing
+ * `/session/<id>` deep-link is stripped while preserving any deployment base
+ * path, so no single session competes with the split.
+ */
+export declare function buildSplitUrl(sessionIds: string[], currentHref: string, token?: string): string;
+/** Read the session ids from a `?split=a,b,c` query string (empty when absent). */
+export declare function parseSplitSessionIds(search: string): string[];
+/**
+ * Persist the in-window split's session set so a refresh restores it. Uses
+ * `sessionStorage` (not `localStorage`) on purpose: it is scoped per browser
+ * tab, so a split opened in its own tab (via {@link buildSplitUrl}) and the
+ * in-window split never clobber each other, and a fresh unrelated tab restores
+ * nothing. It still survives a refresh of the same tab — the case this fixes.
+ */
+export declare function saveSplitSessions(sessions: readonly string[]): void;
+/**
+ * The persisted split session set, or `[]` when absent/unavailable/malformed —
+ * and when it was saved for a different daemon target than the live one.
+ */
+export declare function loadSplitSessions(): string[];
+/** Forget the persisted split (e.g. when the user leaves the split view). */
+export declare function clearSplitSessions(): void;

package/dist/types/utils/standalone-session-routing.d.ts

@@ -0,0 +1,2 @@
+import { type DaemonClient, type DaemonCapabilities } from '@qwen-code/sdk/daemon';
+export declare function keepWorkspaceSplitSessionIds(client: DaemonClient, capabilities: DaemonCapabilities | undefined, sessionIds: readonly string[]): Promise<string[]>;

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

@@ -0,0 +1,26 @@
+interface PreflightCell {
+    kind: string;
+    detail?: Record<string, unknown>;
+}
+interface EnvCell {
+    kind: string;
+    name: string;
+    present?: boolean;
+    value?: string;
+}
+export interface SystemInfo {
+    nodeVersion: string;
+    npmVersion: string;
+    authSource: string;
+    platform: string;
+    arch: string;
+    sandbox: string;
+    proxy: string;
+    memoryUsage: string;
+}
+export declare function collectSystemInfo(preflight: {
+    cells: PreflightCell[];
+} | null, env: {
+    cells: EnvCell[];
+} | null): SystemInfo;
+export {};

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

@@ -0,0 +1,18 @@
+import type { Message } from '../adapters/types';
+/**
+ * Change-detection key only. `callId` is unconstrained text, so the
+ * rendering is not injective and the key must never be parsed back —
+ * ask {@link hasActiveTaskActivity} for the activity fact instead.
+ */
+export declare function getTaskActivityKey(messages: readonly Message[]): string;
+/**
+ * Whether any background task tool call is still running.
+ *
+ * Derived from the same walk as the key rather than by re-parsing it: a
+ * callId containing `:in_progress|` renders a key that any such regex
+ * reads as active, which pins both polling stop conditions open for the
+ * life of the view.
+ */
+export declare function hasActiveTaskActivity(messages: readonly Message[], options?: {
+    workflowsEnabled?: boolean;
+}): boolean;

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

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Format an epoch-seconds timestamp as a localized relative time
+ * ("3 hours ago"). `now` is also epoch seconds.
+ */
+export declare function timeAgo(timestamp: number, now: number, language: string): string;

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

@@ -0,0 +1,165 @@
+import type { ACPToolCall, Message, PermissionRequest, TodoItem } from '../adapters/types.js';
+/**
+ * The todo tool is registered as `todo_write` on the wire, but older paths and
+ * the ACP plan bridge use `todowrite`. Match both so detection never hinges on
+ * the (unrelated) tool `kind`, which is `think` for this tool.
+ */
+export declare function isTodoWriteToolName(name: string): boolean;
+/**
+ * The full exit-plan approval rule: the switch_mode frame kind plus the
+ * exit_plan_mode wire name. Shared by App, ChatPane, and ToolApproval so the
+ * surfaces that gate the revision-bound approval UI never drift.
+ */
+export declare function isExitPlanApprovalRequest(request: Pick<PermissionRequest, 'toolKind' | 'toolName'> | null | undefined): boolean;
+export declare function parseTodoItemsFromEntries(entries: readonly unknown[]): TodoItem[];
+export declare function extractTodosFromToolCall(tool: ACPToolCall): TodoItem[] | undefined;
+export declare function hasActiveTodos(todos: readonly TodoItem[]): boolean;
+export declare function getTodoStatusIcon(status: TodoItem['status']): string;
+export interface FloatingTodosState {
+    todos: TodoItem[];
+    planId: string | null;
+    /** Every item is completed — the panel shows a transient "all done" state. */
+    allCompleted: boolean;
+    /** Transcript message the latest todo update came from. */
+    sourceMessageId: string | null;
+}
+export declare function getFloatingTodos(messages: readonly Message[]): FloatingTodosState;
+export declare function getSessionWorkflowTodos(messages: readonly Message[]): FloatingTodosState;
+export declare function getActiveTodosForPlanRevision(messages: readonly Message[], revision: {
+    planId: string;
+    sourceCallId: string;
+} | null | undefined): TodoItem[];
+export declare function getAgentToolsForPlan(messages: readonly Message[], plan: Pick<FloatingTodosState, 'planId' | 'sourceMessageId'>): ACPToolCall[];
+/** A status transition surfaced for a single todo snapshot. */
+export interface TodoEvent {
+    kind: 'started' | 'completed';
+    id: string;
+    content: string;
+}
+/** What changed in one todo snapshot relative to the conversation so far. */
+export interface TodoSnapshotDiff {
+    events: TodoEvent[];
+}
+/**
+ * Identity used to track an item across snapshots. Folds content into the key
+ * because todo ids are NOT globally unique. Modern Qwen plan metadata preserves
+ * the core id, but legacy ACP records fall back to positional ids (`plan-0`,
+ * `plan-1`, …), and models commonly restart numbering at `1, 2, 3` for a new
+ * `todo_write` plan. Keying on id alone would diff a new plan's items against a
+ * previous plan's stale terminal status; id+content keeps distinct tasks
+ * separate and, unlike a user-turn reset, still tracks a list correctly when it
+ * spans turns (a "continue" turn that completes an item carried over from
+ * before).
+ *
+ * Two rare cases this trades for, affecting the collapsed diff and the per-task
+ * detail ({@link computeTodoDetails}) but not the expanded list itself:
+ * - A todo reworded on a stable id reads as a new task. Reworded while still
+ *   `in_progress` it emits a spurious `started`; reworded straight to
+ *   `completed` (`1 "Write report"` → `1 "Write the final report" completed`)
+ *   the completion is treated as first-seen and dropped.
+ * - Two unrelated plans that reuse both the id AND the exact content (a generic
+ *   recurring todo like `"Run tests"`) still collide. computeTodoDetails resets
+ *   a task's window when a completed key restarts as `in_progress`, so the
+ *   common reuse keeps correct numbers; a reused id+content that goes *straight*
+ *   to `completed` (never observed `in_progress`) still shares the earlier
+ *   task's detail slot.
+ */
+export declare function todoStateKey(todo: TodoItem): string;
+/**
+ * Walk the todo snapshots in order and, for each one, derive what changed
+ * relative to the running state: which items just started and which just
+ * completed.
+ *
+ * Keyed by snapshot id (tool callId or plan message id) so a history row can
+ * look up its own diff. Only transitions actually witnessed produce events — an
+ * item first seen already completed (e.g. a restored session's opening
+ * snapshot) is recorded silently so its old completion is not replayed as if it
+ * just happened.
+ */
+export declare function computeTodoTimeline(messages: readonly Message[]): Map<string, TodoSnapshotDiff>;
+/**
+ * A cheap signature of the todo snapshots in a transcript: each snapshot's key
+ * plus its items' id, status, and content. App memoizes the timeline on this so
+ * the context provider value stays referentially stable across unrelated
+ * streaming ticks (which would otherwise re-render every todo/plan row that
+ * consumes the timeline).
+ */
+export declare function todoTimelineSignature(messages: readonly Message[]): string;
+/**
+ * Like {@link todoTimelineSignature} but folds in everything
+ * {@link computeTodoDetails} reads beyond item status: each snapshot's boundary
+ * timestamp and stamped stats, plus every tool span (non-todo spans feed tool
+ * time; todo spans supply snapshot boundaries). App memoizes the detail map on
+ * this so the TodoDetailContext value stays referentially stable across
+ * streaming ticks that touch none of it.
+ */
+export declare function todoDetailSignature(messages: readonly Message[]): string;
+export interface TodoWindow {
+    start: number;
+    end: number;
+}
+/**
+ * Natural-order window of up to maxVisible items anchored on the current
+ * item (first in_progress, else first pending): one item of completed
+ * context above the anchor, the rest of the budget below it.
+ */
+export declare function getTodoWindow(todos: readonly TodoItem[], maxVisible: number): TodoWindow;
+/**
+ * Cumulative-usage baseline the agent stamps onto each todo update
+ * (`_meta.stats`, surfaced via the tool call's rawOutput). The web-shell diffs
+ * consecutive snapshots to attribute a task's spend. `apiTimeMs` only advances
+ * live — replayed sessions carry tokens but not per-turn durations.
+ */
+export interface TodoStatsSnapshot {
+    promptTokens: number;
+    cachedTokens: number;
+    candidateTokens: number;
+    apiTimeMs: number;
+}
+/**
+ * Read the cumulative-usage snapshot the agent stamped onto a todo_write tool
+ * call's rawOutput. Absent for snapshots emitted by an agent that predates the
+ * stamping, or non-tool todo sources (plain plan messages).
+ */
+export declare function extractTodoStats(tool: ACPToolCall): TodoStatsSnapshot | undefined;
+/**
+ * Resource usage consumed during a single todo's [start, end] window. Every
+ * field is optional: tokens/API time come from the snapshot diff (absent on
+ * sessions whose agent didn't stamp snapshots; API time is also absent on
+ * replay), while tool time comes from transcript tool durations and is shown
+ * whenever any tool ran in the window.
+ */
+export interface TodoResources {
+    inputTokens?: number;
+    cachedTokens?: number;
+    outputTokens?: number;
+    apiTimeMs?: number;
+    toolTimeMs?: number;
+}
+/** Per-todo timing and resource breakdown. */
+export interface TodoDetail {
+    /** Wall-clock ms when the item first became in_progress. */
+    startTs?: number;
+    /** Wall-clock ms when the item became completed. */
+    endTs?: number;
+    /**
+     * Tokens and time spent while this item was the active task. Tokens and API
+     * time come from diffing the cumulative-usage snapshots stamped on its start
+     * and end todo boundaries; tool time is summed from the transcript's tool
+     * durations in the window. Undefined when nothing could be measured.
+     */
+    resources?: TodoResources;
+}
+/**
+ * Per-todo detail keyed by {@link todoStateKey}: when each item started and
+ * completed, plus the resources spent in that window.
+ *
+ * Mirrors {@link computeTodoTimeline}'s state machine — a todo's start is its
+ * first in_progress transition and its end the completed transition — but
+ * records timestamps, the snapshot diff (tokens + API time) between the start
+ * and end boundaries, and the transcript tool time in the window. An item first
+ * seen already completed (a restored opening snapshot) yields no detail, exactly
+ * as it produces no timeline event.
+ */
+export declare function computeTodoDetails(messages: readonly Message[]): Map<string, TodoDetail>;
+export declare function getTodoPlanId(tool: ACPToolCall): string | null;

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

@@ -0,0 +1 @@
+export declare const CONFUSABLE_PROTOTYPES: ReadonlyMap<string, string>;

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

@@ -0,0 +1,12 @@
+interface UnifiedDiffLine {
+    type: 'add' | 'del' | 'context' | 'header';
+    content: string;
+    oldLine?: number;
+    newLine?: number;
+}
+export declare function parseUnifiedDiff(diff: string): {
+    lines: UnifiedDiffLine[];
+    additions: number;
+    deletions: number;
+};
+export {};

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

@@ -0,0 +1,3 @@
+import type { DaemonSessionTaskWithWorkflowStatus, DaemonSessionWorkflowTaskStatus } from '@qwen-code/sdk/daemon';
+import type { ACPToolCall } from '../adapters/types';
+export declare function findWorkflowTaskForTool(tasks: readonly DaemonSessionTaskWithWorkflowStatus[], tool: ACPToolCall): DaemonSessionWorkflowTaskStatus | undefined;