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

package/dist/types/daemon/session/actions.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Dispatch, SetStateAction } from 'react';
+import type { DaemonSessionClient, CreateSessionRequest, DaemonTranscriptStore, DaemonCapabilities } from '@qwen-code/sdk/daemon';
+import { type TimerRef } from '../timing.js';
+import type { ActivePrompt, AddDaemonSessionNotice, DaemonActivePromptState, DaemonConnectionState, DaemonPromptStatus, DaemonSessionActions, SettledPrompt, PendingSessionLoad, DaemonProductSessionContext } from './types.js';
+interface RefBox<T> {
+    current: T;
+}
+export declare function resolveSessionRestoreTimeouts(capabilities: DaemonCapabilities | undefined): {
+    requestTimeoutMs: number;
+    watchdogTimeoutMs: number | undefined;
+};
+export interface CreateDaemonSessionActionsArgs {
+    store: DaemonTranscriptStore;
+    sessionRef: RefBox<DaemonSessionClient | undefined>;
+    activePromptsRef: RefBox<Map<string, ActivePrompt>>;
+    settledPromptsRef: RefBox<Map<string, SettledPrompt>>;
+    pendingSessionLoadRef: RefBox<PendingSessionLoad | undefined>;
+    pendingSessionLoadIdRef: RefBox<number>;
+    sessionConfigGeneration: WeakMap<DaemonSessionClient, number>;
+    sessionRecoveryGeneration: WeakMap<DaemonSessionClient, number>;
+    heartbeatSupportedRef: RefBox<boolean>;
+    manualSessionClearRef: RefBox<boolean>;
+    skipNextCleanupDetachSessionRef: RefBox<DaemonSessionClient | undefined>;
+    passiveAssistantDoneTimerRef: TimerRef;
+    /**
+     * Daemon-authoritative "a prompt is in flight" state and its owner,
+     * published by the host through `setDaemonActivePrompt`.
+     * `undefined` means no authority is available (a daemon without
+     * `workspace_session_live_state`, or a host that never wires it) and the
+     * silence-based heuristics stay in charge.
+     */
+    daemonActivePromptRef: RefBox<DaemonActivePromptState | undefined>;
+    /**
+     * Settle the current session's restored-prompt snapshot (the `hasActivePrompt`
+     * flag `/load` returned). A restored prompt has no terminal handling in this
+     * browser — it can only be settled by the event stream — so the
+     * `setDaemonActivePrompt` backstop settles it when the daemon reports the
+     * turn finished. Returns whether a restored prompt was settled.
+     */
+    settleRestoredActivePrompt: () => boolean;
+    /**
+     * Apply the provider's buffered transcript batch (`TRANSCRIPT_DISPATCH_BATCH_MS`)
+     * so a read of the store sees every event delivered so far. Every
+     * provider-side settle path flushes first; an action that settles a turn has
+     * to do the same or it reads a store up to one batch window stale.
+     */
+    flushTranscript: () => void;
+    getCreateSessionRequest: () => CreateSessionRequest;
+    createDetachedSession: (workspaceCwd?: string, overrides?: Pick<CreateSessionRequest, 'approvalMode' | 'sourceType' | 'worktree' | 'branch'>) => Promise<DaemonSessionClient>;
+    createDetachedStandaloneSession: (overrides?: Pick<CreateSessionRequest, 'approvalMode' | 'modelServiceId'>) => Promise<DaemonSessionClient>;
+    getDefaultSessionContext: () => DaemonProductSessionContext | undefined;
+    getConnection: () => DaemonConnectionState;
+    getEventDetailMode: () => 'full' | 'summary';
+    hasSessionActivePrompt: () => boolean;
+    resetCurrentSessionActivePrompt: () => void;
+    restartEventStream: (sessionId: string) => void;
+    addNotice: AddDaemonSessionNotice;
+    setConnection: Dispatch<SetStateAction<DaemonConnectionState>>;
+    setPromptStatus: Dispatch<SetStateAction<DaemonPromptStatus>>;
+    setRestoreSessionId: Dispatch<SetStateAction<string | undefined>>;
+    setRestoreSessionContext: Dispatch<SetStateAction<DaemonProductSessionContext | undefined>>;
+    setRestoreMode: Dispatch<SetStateAction<'load' | 'resume'>>;
+    setRestoreSessionNonce: Dispatch<SetStateAction<number>>;
+    setAttachSessionNonce: Dispatch<SetStateAction<number>>;
+    setNewSessionNonce: Dispatch<SetStateAction<number>>;
+    clearLiveJournalRepair?: () => void;
+    onPromptAdmitted?: (owner: DaemonSessionClient, admission: {
+        promptId: string;
+        label: string;
+        blockId?: string;
+    }) => void;
+    onContinuationAdmitted?: (owner: DaemonSessionClient, promptId: string) => void;
+    onPromptRemoved?: (owner: DaemonSessionClient, promptId: string) => void;
+}
+export declare function getWorkspaceModelsAfterSessionClear(current: DaemonConnectionState): DaemonConnectionState['models'];
+export declare function getConnectionAfterSessionClear(current: DaemonConnectionState, clearedSessionId: string | undefined, preserveWorkspaceMetadata?: boolean): DaemonConnectionState;
+export declare function advanceSessionRecoveryGeneration(generations: WeakMap<DaemonSessionClient, number>, session: DaemonSessionClient): number;
+export declare function createDaemonSessionActions({ store, sessionRef, activePromptsRef, settledPromptsRef, pendingSessionLoadRef, pendingSessionLoadIdRef, sessionConfigGeneration, sessionRecoveryGeneration, heartbeatSupportedRef, manualSessionClearRef, skipNextCleanupDetachSessionRef, passiveAssistantDoneTimerRef, daemonActivePromptRef, settleRestoredActivePrompt, flushTranscript, getCreateSessionRequest, createDetachedSession, createDetachedStandaloneSession, getDefaultSessionContext, getConnection, getEventDetailMode, hasSessionActivePrompt, resetCurrentSessionActivePrompt, restartEventStream, addNotice, setConnection, setPromptStatus, setRestoreSessionId, setRestoreSessionContext, setRestoreMode, setRestoreSessionNonce, setAttachSessionNonce, setNewSessionNonce, clearLiveJournalRepair, onPromptAdmitted, onContinuationAdmitted, onPromptRemoved, }: CreateDaemonSessionActionsArgs): DaemonSessionActions;
+/**
+ * Key under which a shell command tracks its prompt in the active-prompt map.
+ * Shell commands run as their own prompt alongside a conversation turn, so they
+ * cannot share the plain session key.
+ */
+export declare function getShellPromptKey(sessionId: string): string;
+/**
+ * Whether this browser has a prompt of any kind in flight for `sessionId`.
+ *
+ * Every active-prompt key scheme lives here. Readers that hand-rolled the
+ * membership check would silently miss a new prompt kind, and a reader that
+ * answers "no local prompt" for one that is running lets a lagging live-state
+ * sample settle a turn this browser is still driving (#9487).
+ */
+export declare function hasLocallySubmittedPrompt(activePrompts: ReadonlyMap<string, ActivePrompt>, sessionId: string): boolean;
+export declare function getPromptSettledKey(sessionId: string, promptId: string): string;
+export {};

package/dist/types/daemon/session/clientLifecycle.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function getStableClientId(clientId: string | undefined, sessionId?: string): string;
+/**
+ * Read the client id persisted for `sessionId` without generating one. Returns
+ * `undefined` when nothing is stored (SSR, private-mode quota failure, or a
+ * session this client never attached). Callers use this to act on behalf of a
+ * NON-current session, where `getStableClientId`'s generate-on-miss would mint
+ * an unrelated id that is not attached to the target session.
+ */
+export declare function getPersistedClientId(sessionId: string): string | undefined;
+export declare function persistStableClientId(clientId: string | undefined, sessionId?: string): void;
+export declare function detachDaemonClient(opts: {
+    baseUrl: string;
+    token?: string;
+    sessionId: string;
+    clientId?: string;
+}): Promise<void>;

package/dist/types/daemon/session/httpErrors.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare function extractHttpStatus(error: unknown): number | undefined;
+export declare function isInvalidClientIdError(error: unknown): boolean;
+export declare function isAcpChildCapacityError(error: unknown): boolean;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/types/daemon/session/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { DaemonSessionProvider, DEFAULT_MAX_BLOCKS, useDaemonActions, useOptionalDaemonActions, useDaemonSessionOwnerGuard, useDaemonWorkspaceEventSignals, useDaemonActiveTodoList, useDaemonConnection, useDaemonPendingPermissions, useDaemonPromptStatus, useDaemonSessionNotices, useDaemonStreamingState, useDaemonSession, useDaemonTranscriptBlocks, useDaemonTranscriptHistory, useDaemonTranscriptState, useDaemonTranscriptStore, useDaemonTurnNavigationState, useDaemonTurnNavigationStore, } from './DaemonSessionProvider.js';
+export type { DaemonTranscriptHistory } from './DaemonSessionProvider.js';
+export { createDaemonTurnNavigationStore } from './turn-navigation-store.js';
+export type { CreateDaemonTurnNavigationStoreOptions, DaemonPromptAdmission, DaemonProvisionalTurn, DaemonSelectedTurnState, DaemonTurnIndexPage, DaemonTurnLocation, DaemonTurnNavigationClient, DaemonTurnNavigationError, DaemonTurnNavigationSession, DaemonTurnNavigationSnapshot, DaemonTurnNavigationStore, } from './turn-navigation-store.js';
+export type { HistoricalTranscriptPage, HistoricalTranscriptRange, TranscriptBoundary, } from './transcript-page-table.js';
+export type { DaemonCommandInfo, DaemonConnectionState, DaemonConnectionStatus, DaemonModelInfo, DaemonProductSessionContext, DaemonStandaloneConnectionState, DaemonNoticeCategory, DaemonNoticeOperation, DaemonNoticeSeverity, DaemonPromptFile, DaemonPromptImage, DaemonPromptStatus, DaemonReasoningControls, DaemonSessionActions, DaemonSessionContextValue, DaemonSessionNotice, DaemonSessionOwnerGuard, DaemonSessionOwnerSnapshot, DaemonSessionProviderProps, DaemonTokenUsage, DaemonTodoItem, DaemonTodoList, DaemonTodoPriority, DaemonTodoStatus, DaemonWorkspaceEventSignals, PendingPromptActionOptions, SendPromptOptions, SubmitPromptOptions, SubmitPromptResult, } from './types.js';
+export { extractDaemonTodosFromToolBlock, hasDaemonActiveTodos, isDaemonSubAgentToolBlock, parseDaemonTodoItemsFromEntries, selectDaemonActiveTodoList, selectDaemonLatestTodoList, selectDaemonPendingPermissions, selectDaemonSubAgentToolBlocks, selectDaemonStreamingState, selectDaemonTodoLists, selectDaemonTranscriptStreamingState, } from './selectors.js';
+export type { DaemonStreamingState } from './selectors.js';
+export { toDaemonPromptContent } from './promptContent.js';
+export { isMissingSessionHttpStatus } from './status.js';

package/dist/types/daemon/session/live-journal-repair.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonEvent } from '@qwen-code/sdk/daemon';
+export interface LiveJournalRepairTarget {
+    marker: DaemonEvent;
+    promptId: string;
+    signature: string;
+}
+export interface LiveJournalRepairSuffix {
+    events: DaemonEvent[];
+    terminal: DaemonEvent;
+}
+export declare function findLiveJournalRepairTarget(sessionId: string, liveJournal: readonly DaemonEvent[], lastEventId: number | undefined, replayDegraded: boolean): LiveJournalRepairTarget | undefined;
+export declare function findLiveJournalRepairSuffix(replayEvents: readonly DaemonEvent[], promptId: string): LiveJournalRepairSuffix | undefined;
+export declare function eventPromptId(event: DaemonEvent): string | undefined;
+export declare function isLiveJournalMarker(event: DaemonEvent): boolean;

package/dist/types/daemon/session/mappers.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Dispatch, SetStateAction } from 'react';
+import type { DaemonEvent, DaemonSessionContextStatus, DaemonSessionSupportedCommandsStatus, DaemonWorkspaceProvidersStatus, DaemonWorkspaceSkillsStatus, GoalSnapshotV2 } from '@qwen-code/sdk/daemon';
+import type { DaemonCommandInfo, DaemonConnectionState, DaemonModelInfo, DaemonReasoningControls, DaemonTokenUsage } from './types.js';
+export declare function mapProviderStatus(status: Pick<DaemonWorkspaceProvidersStatus, 'current' | 'approvalMode' | 'providers'> | undefined, preferredCurrentModel?: string): {
+    models: DaemonModelInfo[];
+    currentModel?: string;
+    currentMode?: string;
+    contextWindow?: number;
+};
+export declare function mapSessionContextModels(status: DaemonSessionContextStatus | undefined): {
+    models: DaemonModelInfo[];
+    currentModel?: string;
+    contextWindow?: number;
+} | undefined;
+export declare function mapReasoningControls(configOptions: unknown): DaemonReasoningControls | undefined;
+export declare function mapSessionContextReasoning(status: DaemonSessionContextStatus | undefined): DaemonReasoningControls | undefined;
+export declare function mapSupportedCommands(status: DaemonSessionSupportedCommandsStatus | undefined): {
+    commands: DaemonCommandInfo[];
+    skills: string[];
+};
+/**
+ * Maps the session-less `/workspace/skills` status into slash-command entries.
+ *
+ * Session creation is deferred until the first prompt, so before any session
+ * exists the only way to populate skill-backed slash commands (e.g. `/review`)
+ * is this workspace-level status, which the daemon answers from `Config`'s
+ * SkillManager without a live session. The shape mirrors the skills portion of
+ * {@link mapSupportedCommands} so the deferred bootstrap and the post-attach
+ * snapshot stay consistent — except workspace status carries real descriptions
+ * and argument hints, which we surface here.
+ */
+export declare function mapWorkspaceSkills(status: DaemonWorkspaceSkillsStatus | undefined): {
+    commands: DaemonCommandInfo[];
+    skills: string[];
+};
+export declare function mergeCommands(...groups: DaemonCommandInfo[][]): DaemonCommandInfo[];
+export declare function updateConnectionFromDaemonEvent(event: DaemonEvent, setConnection: Dispatch<SetStateAction<DaemonConnectionState>>): void;
+/**
+ * Reconcile a `goal()` READ against whatever landed while it was in flight.
+ *
+ * A read the daemon answered while goal-less carries no `clearedGoal`
+ * tombstone, so `selectGoalState` derives the clear target from the goal a
+ * concurrent create installed meanwhile — accepting the clear AND tombstoning
+ * that goal's identity, after which its own later frames at the same revision
+ * are rejected as superseded. Stamp the read with the goal observed when it was
+ * ISSUED: a bare-null response may only clear the goal it actually observed.
+ *
+ * Returns `current` unchanged when the read is stale, so callers can compare
+ * identity to skip the state write entirely.
+ */
+export declare function selectGoalStateFromRead(current: GoalSnapshotV2 | undefined, incoming: GoalSnapshotV2, observedGoalId: string | undefined): GoalSnapshotV2;
+export declare function selectGoalState(current: GoalSnapshotV2 | undefined, incoming: GoalSnapshotV2): GoalSnapshotV2;
+export declare function getSessionDisplayName(state: Record<string, unknown> | undefined): string | undefined;
+export declare function getCurrentMode(status: DaemonSessionContextStatus | undefined): string | undefined;
+export declare function getPlanExecutionMode(status: DaemonSessionContextStatus | undefined): string | undefined;
+export declare function getCurrentModel(status: DaemonSessionContextStatus | undefined): string | undefined;
+/**
+ * Latest usage token count carried in a replay snapshot, or undefined if
+ * no replayed event has one. Token usage is not part of the attach-time
+ * status fetches — it only arrives on streaming `session_update` events —
+ * so on session load the last usage-bearing replay event is the freshest
+ * count available.
+ */
+export declare function getReplayTokenCount(events: readonly DaemonEvent[]): number | undefined;
+export declare function getTokenCountFromUsage(usage: DaemonTokenUsage | undefined): number | undefined;
+export declare function getReplayTokenUsage(events: readonly DaemonEvent[]): DaemonTokenUsage | undefined;

package/dist/types/daemon/session/promptContent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { PromptContentBlock } from '@qwen-code/sdk/daemon';
+import type { DaemonPromptFile, DaemonPromptImage } from './types.js';
+export declare function attachmentUriForName(name: string): string;
+export declare function withAttachmentTokens(text: string, attachmentUris: readonly string[]): string;
+export declare function daemonPromptImageToBlob(image: DaemonPromptImage): Blob;
+export declare function toDaemonPromptContent(text: string, images?: readonly DaemonPromptImage[], files?: readonly DaemonPromptFile[]): PromptContentBlock[];

package/dist/types/daemon/session/selectors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonToolTranscriptBlock, DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
+import type { DaemonPromptStatus, DaemonTodoItem, DaemonTodoList } from './types.js';
+export type DaemonStreamingState = 'idle' | 'waiting' | 'responding' | 'thinking';
+export declare function selectDaemonPendingPermissions(blocks: readonly DaemonTranscriptBlock[]): ReadonlyArray<Extract<DaemonTranscriptBlock, {
+    kind: 'permission';
+}>>;
+export declare function selectDaemonTodoLists(blocks: readonly DaemonTranscriptBlock[]): DaemonTodoList[];
+export declare function selectDaemonLatestTodoList(blocks: readonly DaemonTranscriptBlock[]): DaemonTodoList | undefined;
+export declare function selectDaemonActiveTodoList(blocks: readonly DaemonTranscriptBlock[]): DaemonTodoList | undefined;
+export declare function extractDaemonTodosFromToolBlock(block: DaemonToolTranscriptBlock): DaemonTodoItem[] | undefined;
+export declare function parseDaemonTodoItemsFromEntries(entries: readonly unknown[]): DaemonTodoItem[];
+export declare function hasDaemonActiveTodos(items: readonly DaemonTodoItem[]): boolean;
+export declare function isDaemonSubAgentToolBlock(block: DaemonToolTranscriptBlock): boolean;
+export declare function selectDaemonSubAgentToolBlocks(blocks: readonly DaemonTranscriptBlock[]): DaemonToolTranscriptBlock[];
+export declare function selectDaemonTranscriptStreamingState(blocks: readonly DaemonTranscriptBlock[]): Exclude<DaemonStreamingState, 'waiting'>;
+export declare function selectDaemonStreamingState(blocks: readonly DaemonTranscriptBlock[], promptStatus?: DaemonPromptStatus): DaemonStreamingState;

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

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonCapabilities, DaemonSession } from '@qwen-code/sdk/daemon';
+import type { DaemonProductSessionContext, DaemonStandaloneConnectionState } from './types.js';
+export declare function resolveProviderSessionContext(sessionContext: DaemonProductSessionContext | undefined, workspaceCwd: string | undefined, inheritedWorkspaceCwd: string | undefined): DaemonProductSessionContext | undefined;
+export declare function resolveActionSessionContext(sessionContext: DaemonProductSessionContext | undefined, workspaceCwd: string | undefined, fallback: DaemonProductSessionContext | undefined): DaemonProductSessionContext | undefined;
+export declare function resolveLiveSessionWorkspaceCwd(capabilities: DaemonCapabilities): string;
+export declare function sessionContextKey(context: DaemonProductSessionContext | undefined): string;
+export declare function restoreSessionContextMatches(requested: DaemonProductSessionContext | undefined, active: DaemonProductSessionContext | undefined): boolean;
+export declare function getDaemonErrorCode(error: unknown): string | undefined;
+export declare function isSessionWriterBlockedCode(code: string | undefined): boolean;
+export declare function isDaemonErrorExplicitlyNonRetryable(error: unknown): boolean;
+export declare function getStandaloneConnectionState(session: DaemonSession | undefined): DaemonStandaloneConnectionState | undefined;

package/dist/types/daemon/session/status.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const MISSING_SESSION_HTTP_STATUSES: readonly [404, 410];
+export declare function isMissingSessionHttpStatus(status: number | undefined): boolean;
+/**
+ * Preserve 404/410 after heartbeat detects a missing session so a later
+ * status-less transport retry cannot hide the missing-session empty state.
+ */
+export declare function resolveConnectionErrorStatus(nextStatus: number | undefined, currentStatus: number | undefined): number | undefined;

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

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonEvent, type DaemonSessionTranscriptPage, type DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
+export type FrozenTranscriptBoundaryRequest = {
+    kind: 'older';
+    beforeRecordId: string;
+    snapshot: string;
+} | {
+    kind: 'cursor';
+    cursor: string;
+} | {
+    kind: 'gap';
+    anchorRecordId: string;
+    afterRecordId: string;
+    snapshot: string;
+    beforeAnchor?: true;
+};
+export interface TranscriptGapResolution {
+    excludedRecordIds: readonly string[];
+    fromAnchor: boolean;
+}
+export type TranscriptBoundary = {
+    kind: 'end';
+} | {
+    kind: 'live';
+} | {
+    kind: 'cached';
+    rangeId: string;
+} | {
+    kind: 'loadable';
+    request: FrozenTranscriptBoundaryRequest;
+} | {
+    kind: 'loading';
+    request: FrozenTranscriptBoundaryRequest;
+} | {
+    kind: 'error';
+    request: FrozenTranscriptBoundaryRequest;
+    retryable: boolean;
+};
+export interface HistoricalTranscriptPage {
+    id: string;
+    snapshot: string;
+    blocks: readonly DaemonTranscriptBlock[];
+    recordIds: ReadonlySet<string>;
+    firstRecordId?: string;
+    lastRecordId?: string;
+    retainedBytes: number;
+    turnBlockById: ReadonlyMap<string, string>;
+    newerRequest?: FrozenTranscriptBoundaryRequest;
+}
+export interface HistoricalTranscriptRange {
+    id: string;
+    anchorOrdinal: number;
+    anchorTurnId: string;
+    pageIds: readonly string[];
+    older: TranscriptBoundary;
+    newer: TranscriptBoundary;
+}
+export interface SequentialHistoricalTranscriptRange {
+    id: string;
+    beforeRecordId: string;
+    snapshot: string;
+    pageIds: readonly string[];
+    older: TranscriptBoundary;
+    newer: TranscriptBoundary;
+}
+export type HistoricalViewportRange = HistoricalTranscriptRange | SequentialHistoricalTranscriptRange;
+export interface HistoricalTranscriptPageTableSnapshot {
+    pages: ReadonlyMap<string, HistoricalTranscriptPage>;
+    ranges: readonly HistoricalViewportRange[];
+    retainedBytes: number;
+}
+export interface MaterializedTranscriptPage {
+    blocks: readonly DaemonTranscriptBlock[];
+    nextBlockOrdinal: number;
+    encounteredRecordIds: readonly string[];
+}
+export interface HistoricalTranscriptPageTableOptions {
+    maxPages: number;
+    maxRetainedBytes: number;
+    materialize(events: readonly DaemonEvent[], nextBlockOrdinal: number, excludedRecordIds: ReadonlySet<string>): MaterializedTranscriptPage;
+}
+export interface AdmittedHistoricalTarget {
+    rangeId: string;
+    pageId: string;
+    blockId: string;
+}
+export declare class HistoricalTranscriptPageTooLargeError extends Error {
+    constructor();
+}
+export declare class HistoricalTranscriptWindowFullError extends Error {
+    constructor();
+}
+type BoundaryDirection = 'older' | 'newer';
+export declare class HistoricalTranscriptPageTable {
+    private readonly options;
+    private snapshot;
+    private nextPageId;
+    private nextRangeId;
+    private nextBlockOrdinal;
+    private readonly rangeAccess;
+    private accessClock;
+    private selectedRangeId;
+    private selectedPageId;
+    private liveRecordIds;
+    private readonly viewportPins;
+    private readonly cachedBoundaryRequests;
+    constructor(options: HistoricalTranscriptPageTableOptions);
+    getSnapshot(): HistoricalTranscriptPageTableSnapshot;
+    reset(): void;
+    setLiveRecordIds(recordIds: Iterable<string>): void;
+    releaseLoadingBoundaries(): boolean;
+    findTurn(turnId: string): AdmittedHistoricalTarget | undefined;
+    select(rangeId: string, pageId: string): void;
+    clearSelection(): void;
+    setViewportAnchor(viewportId: string, pageId?: string): void;
+    admitBefore(beforeRecordId: string, snapshot: string, response: DaemonSessionTranscriptPage): AdmittedHistoricalTarget | undefined;
+    admitAnchor(ordinal: number, turnId: string, snapshot: string, response: DaemonSessionTranscriptPage): AdmittedHistoricalTarget;
+    private admitAnchorPage;
+    beginBoundaryLoad(rangeId: string, direction: BoundaryDirection): FrozenTranscriptBoundaryRequest | undefined;
+    reopenLiveBoundary(rangeId: string, beforeRecordId: string, snapshot: string): void;
+    failBoundaryLoad(rangeId: string, direction: BoundaryDirection, request: FrozenTranscriptBoundaryRequest, retryable: boolean): void;
+    cancelBoundaryLoad(rangeId: string, direction: BoundaryDirection, request: FrozenTranscriptBoundaryRequest): void;
+    admitBoundary(rangeId: string, direction: BoundaryDirection, snapshot: string, response: DaemonSessionTranscriptPage, recovery?: TranscriptGapResolution): void;
+    private admitBoundaryPage;
+    private materializePage;
+    private pageFromBlocks;
+    private assertPageFits;
+    private withNewerRequest;
+    private nextBoundary;
+    private finishBoundaryWithoutPage;
+    private allRecordIds;
+    private findOverlappingRange;
+    private cachedBoundary;
+    private boundaryKey;
+    private replaceRange;
+    private touch;
+    private evict;
+    private measureRetainedBytes;
+    private measureBoundaryBytes;
+    private restoreCachedBoundaries;
+    private restoreCachedBoundary;
+}
+export {};

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

@@ -0,0 +1,117 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonEvent, DaemonSessionTranscriptPage, DaemonSessionTranscriptPageOptions, DaemonSessionTurnIndexEntry, DaemonSessionTurnIndexPage, DaemonSessionTurnIndexPageOptions, DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
+import { type HistoricalTranscriptPage, type HistoricalTranscriptRange, type HistoricalViewportRange, type MaterializedTranscriptPage } from './transcript-page-table.js';
+export interface DaemonTurnIndexPage {
+    start: number;
+    end: number;
+    snapshot: string;
+    turns: readonly DaemonSessionTurnIndexEntry[];
+    retainedBytes: number;
+}
+export interface DaemonProvisionalTurn {
+    provisionalId: string;
+    promptId: string;
+    label: string;
+    blockId?: string;
+}
+export interface DaemonTurnLocation {
+    turnId: string;
+    blockId: string;
+    view: 'live' | 'historical';
+    rangeId?: string;
+    pageId?: string;
+}
+export interface DaemonSelectedTurnState {
+    ordinal: number;
+    turnId?: string;
+    status: 'loading' | 'ready' | 'unavailable';
+    location?: DaemonTurnLocation;
+}
+export interface DaemonTurnNavigationError {
+    operation: 'index' | 'locate' | 'older' | 'newer';
+    message: string;
+    retryable: boolean;
+    rangeId?: string;
+    ordinal?: number;
+}
+export interface DaemonTurnNavigationSnapshot {
+    sessionId?: string;
+    mode: 'legacy' | 'loading' | 'ready' | 'degraded';
+    fallbackReason?: 'unsupported' | 'too_large' | 'initial_error';
+    totalTurns: number;
+    effectiveTurnCount: number;
+    indexPages: ReadonlyMap<number, DaemonTurnIndexPage>;
+    provisionalTurns: readonly DaemonProvisionalTurn[];
+    historicalPages: ReadonlyMap<string, HistoricalTranscriptPage>;
+    historicalRanges: readonly HistoricalTranscriptRange[];
+    locations: ReadonlyMap<string, DaemonTurnLocation>;
+    selected?: DaemonSelectedTurnState;
+    error?: DaemonTurnNavigationError;
+}
+export interface DaemonTurnNavigationClient {
+    owner: object;
+    getTurnIndexPage(options: DaemonSessionTurnIndexPageOptions): Promise<DaemonSessionTurnIndexPage>;
+    getTranscriptPage(options: DaemonSessionTranscriptPageOptions): Promise<DaemonSessionTranscriptPage>;
+    materializeTranscriptEvents(events: readonly DaemonEvent[], nextBlockOrdinal: number, excludedRecordIds: ReadonlySet<string>): MaterializedTranscriptPage;
+}
+export interface DaemonTurnNavigationSession {
+    sessionId?: string;
+    supported: boolean;
+    client?: DaemonTurnNavigationClient;
+}
+export interface DaemonPromptAdmission {
+    promptId: string;
+    label: string;
+    blockId?: string;
+}
+export interface DaemonTurnNavigationStore {
+    getSnapshot(): DaemonTurnNavigationSnapshot;
+    subscribe(listener: () => void): () => void;
+    configure(session: DaemonTurnNavigationSession): void;
+    observeLiveBlocks(blocks: readonly DaemonTranscriptBlock[]): void;
+    recordPromptAdmitted(admission: DaemonPromptAdmission): void;
+    recordPromptRemoved(promptId: string): void;
+    handleSessionEvent(type: string): void;
+    loadOrdinal(ordinal: number): Promise<void>;
+    locateOrdinal(ordinal: number): Promise<DaemonTurnLocation>;
+    refreshHead(): Promise<void>;
+    loadOlder(rangeId: string): Promise<void>;
+    loadNewer(rangeId: string): Promise<void>;
+    retry(): Promise<void>;
+}
+export interface DaemonHistoryViewportSnapshot {
+    sessionId?: string;
+    revision: number;
+    connected: boolean;
+    pages: ReadonlyMap<string, HistoricalTranscriptPage>;
+    ranges: readonly HistoricalViewportRange[];
+}
+export interface HistoryViewportRequest {
+    isCurrent(): boolean;
+}
+export interface DaemonHistoryNavigationStore extends DaemonTurnNavigationStore {
+    locateViewportOrdinal(ordinal: number, request: HistoryViewportRequest, releaseAnchor: () => void): Promise<DaemonTurnLocation>;
+    getViewportSnapshot(): DaemonHistoryViewportSnapshot;
+    captureLiveBoundary(): LiveHistoryBoundary;
+    hasLiveOverlap(rangeId: string): boolean;
+    openBeforeLive(beforeRecordId: string, request: HistoryViewportRequest): Promise<string>;
+    setViewportAnchor(viewportId: string, pageId?: string): void;
+    loadViewportBoundary(rangeId: string, direction: 'older' | 'newer', request: HistoryViewportRequest, beforeAdmit?: () => void): Promise<void>;
+}
+export interface CreateDaemonTurnNavigationStoreOptions {
+    captureLiveBoundary?: () => LiveHistoryBoundary;
+    indexPageSize?: number;
+    maxIndexPages?: number;
+    maxIndexBytes?: number;
+    maxHistoricalPages?: number;
+    maxHistoricalBytes?: number;
+}
+export interface LiveHistoryBoundary extends HistoryViewportRequest {
+    beforeRecordId?: string;
+    reachable: boolean;
+}
+export declare function createDaemonTurnNavigationStore(options?: CreateDaemonTurnNavigationStoreOptions): DaemonHistoryNavigationStore;

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

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonEvent, DaemonTranscriptBlock } from '@qwen-code/sdk/daemon';
+import type { DaemonConnectionState, DaemonProductSessionContext } from './types.js';
+export interface TurnNotificationTarget {
+    sessionId: string;
+    sessionContext: DaemonProductSessionContext;
+}
+export declare const TurnNotificationNavigationContext: import("react").Context<EventTarget | undefined>;
+export interface TurnNotificationContent {
+    target?: TurnNotificationTarget;
+    sessionTitle?: string;
+    promptText?: string;
+    responseText?: string;
+}
+export interface TurnNotification extends TurnNotificationContent {
+    key: string;
+    outcome: 'completed' | 'failed' | 'ended' | 'cancelled';
+}
+export interface TurnNotificationObserver {
+    retain(scope: string): () => void;
+    admit(scope: string, promptId: string, label?: string): void;
+    remove(scope: string, promptId: string): void;
+    observe(scope: string, sessionId: string, event: DaemonEvent, replay?: boolean, content?: TurnNotificationContent | (() => TurnNotificationContent | undefined)): void;
+}
+export declare const TurnNotificationContext: import("react").Context<TurnNotificationObserver | undefined>;
+interface NotificationOwner {
+    sessionId: string;
+    workspaceCwd: string;
+}
+export declare function useTurnNotificationBinding(baseUrl: string | undefined, connection: DaemonConnectionState): {
+    remember<T extends NotificationOwner>(owner: T, context: DaemonProductSessionContext): T;
+    activate: (owner: NotificationOwner) => string | undefined;
+    admit(owner: NotificationOwner, promptId: string, label?: string): void;
+    remove(owner: NotificationOwner, promptId: string): void;
+    observe(owner: NotificationOwner, event: DaemonEvent, replay?: boolean, content?: TurnNotificationContent | (() => TurnNotificationContent | undefined)): void;
+};
+export declare function getTurnNotificationContent(event: DaemonEvent, blocks: readonly DaemonTranscriptBlock[], sessionTitle: string | undefined): TurnNotificationContent | undefined;
+export declare function createTurnNotificationObserver(notify: (notification: TurnNotification) => void): TurnNotificationObserver;
+export {};