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

package/dist/types/local-files/local-directory.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Path-safe filesystem facade over one user-granted directory.
+ *
+ * Every path is relative to the granted root: the File System Access API gives
+ * no way to reach outside it, and the checks here exist so a model-supplied
+ * path cannot even *ask* for that (no absolute paths, no `..`, no backslashes).
+ *
+ * The handle types are structural rather than the DOM interfaces so this module
+ * is testable with an in-memory tree; a real `FileSystemDirectoryHandle`
+ * satisfies them as-is.
+ */
+export interface LocalFileLike {
+    readonly size: number;
+    readonly lastModified: number;
+    readonly type: string;
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+export interface LocalFileWriterLike {
+    write(data: string): Promise<void>;
+    close(): Promise<void>;
+}
+export interface LocalFileHandleLike {
+    readonly kind: 'file';
+    readonly name: string;
+    getFile(): Promise<LocalFileLike>;
+    createWritable(): Promise<LocalFileWriterLike>;
+}
+export interface LocalDirectoryHandleLike {
+    readonly kind: 'directory';
+    readonly name: string;
+    getDirectoryHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<LocalDirectoryHandleLike>;
+    getFileHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<LocalFileHandleLike>;
+    values(): AsyncIterableIterator<unknown>;
+}
+export type LocalDirectoryErrorCode = 'invalid_path' | 'not_found' | 'not_a_directory' | 'not_a_file' | 'too_large' | 'binary_content' | 'permission_denied' | 'failed';
+export declare class LocalDirectoryError extends Error {
+    readonly code: LocalDirectoryErrorCode;
+    constructor(code: LocalDirectoryErrorCode, message: string);
+}
+export interface LocalDirectoryLimits {
+    maxListEntries: number;
+    maxReadBytes: number;
+    maxWriteBytes: number;
+    maxSearchFiles: number;
+    maxSearchBytes: number;
+    maxSearchHits: number;
+    maxSearchDirs: number;
+}
+export declare const DEFAULT_LOCAL_DIRECTORY_LIMITS: LocalDirectoryLimits;
+export interface LocalDirectoryEntry {
+    name: string;
+    path: string;
+    kind: 'file' | 'directory';
+    size?: number;
+    lastModified?: number;
+}
+export interface LocalReadResult {
+    path: string;
+    content: string;
+    totalLines: number;
+    returnedLines: number;
+    /** True when more lines remain below the returned window. */
+    truncated: boolean;
+}
+export interface LocalWriteResult {
+    path: string;
+    bytes: number;
+    created: boolean;
+}
+export interface LocalSearchHit {
+    path: string;
+    line: number;
+    text: string;
+}
+export interface LocalSearchResult {
+    pattern: string;
+    hits: LocalSearchHit[];
+    filesScanned: number;
+    bytesScanned: number;
+    /** Files seen but not searched: over the read cap, binary, or unreadable. */
+    filesSkipped: number;
+    /** Directory skeletons walked; bounded by its own cap, not maxFiles. */
+    dirsScanned: number;
+    truncated: boolean;
+    truncatedBy: 'hits' | 'files' | 'bytes' | 'directories' | null;
+}
+export interface LocalListResult {
+    entries: LocalDirectoryEntry[];
+    /** True when the listing stopped at the cap and more entries exist. */
+    truncated: boolean;
+    limit: number;
+}
+/**
+ * Split a caller-supplied path into segments under the granted root. Throws
+ * `invalid_path` for anything that could escape it or that the API cannot
+ * address: absolute paths, drive letters, backslashes, `..`, empty segments,
+ * and control characters.
+ *
+ * Resolution is verbatim (no whole-input trim): `list()` and `search()` echo
+ * entry names as-is, and a name with leading or trailing whitespace is legal
+ * on POSIX — trimming here would resolve ` draft.md` to `draft.md` and let a
+ * read-modify-write cycle clobber the wrong file.
+ */
+export declare function splitRelativePath(path: unknown): string[];
+export declare class LocalDirectory {
+    private readonly root;
+    private readonly limits;
+    constructor(root: LocalDirectoryHandleLike, limits?: LocalDirectoryLimits);
+    /** Display name of the granted root (the directory's own name). */
+    get name(): string;
+    private resolveDirectory;
+    list(path: string, limit?: number): Promise<LocalListResult>;
+    read(path: string, offset?: number, limit?: number): Promise<LocalReadResult>;
+    write(path: string, content: string): Promise<LocalWriteResult>;
+    /**
+     * Literal substring search (case-sensitive) over text files. Not a regex:
+     * a model-supplied pattern is untrusted input, and a literal scan has no
+     * catastrophic-backtracking failure mode.
+     */
+    search(pattern: string, options?: {
+        path?: string;
+        maxFiles?: number;
+        maxBytes?: number;
+    }): Promise<LocalSearchResult>;
+}

package/dist/types/local-files/mcp-server.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The browser side of the local-files bridge: a minimal MCP server that answers
+ * the daemon's reverse-channel JSON-RPC and executes every call against the
+ * user-granted directory.
+ *
+ * Hand-rolled rather than the MCP SDK — the daemon's client only drives
+ * initialize / tools/list / tools/call (plus prompts/resources probes, which
+ * get empty answers), and pulling the SDK into the browser bundle for four
+ * methods is not a trade worth making.
+ *
+ * The handshake must be idempotent: one `mcp_register` drives a full discovery
+ * pass per registration target, so a session-bound bridge is initialized more
+ * than once (measured: 2 handshakes for one session).
+ */
+import type { LocalListResult, LocalReadResult, LocalSearchResult, LocalWriteResult } from './local-directory.js';
+export declare const LOCAL_FILES_SERVER_NAME = "local-files";
+export declare const LOCAL_FILES_SERVER_VERSION = "1.0.0";
+/** Fallback when the client does not state one; we echo whatever it sends. */
+export declare const LOCAL_FILES_PROTOCOL_VERSION = "2024-11-05";
+export interface JsonRpcRequest {
+    jsonrpc?: string;
+    id?: number | string | null;
+    method?: string;
+    params?: unknown;
+}
+export interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+/** The slice of {@link LocalDirectory} this server drives. */
+export interface LocalFilesFs {
+    readonly name: string;
+    list(path: string, limit?: number): Promise<LocalListResult>;
+    read(path: string, offset?: number, limit?: number): Promise<LocalReadResult>;
+    write(path: string, content: string): Promise<LocalWriteResult>;
+    search(pattern: string, options?: {
+        path?: string;
+        maxFiles?: number;
+        maxBytes?: number;
+    }): Promise<LocalSearchResult>;
+}
+export declare class LocalFilesMcpServer {
+    private readonly fs;
+    constructor(fs: LocalFilesFs);
+    /**
+     * Answer one inbound JSON-RPC message. Returns `undefined` for notifications,
+     * which must not be replied to.
+     */
+    handle(message: JsonRpcRequest): Promise<JsonRpcResponse | undefined>;
+    private dispatch;
+    private callTool;
+}

package/dist/types/local-files/pick-directory.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Grant acquisition and recovery for the local-files bridge.
+ *
+ * Two paths, because the browser splits them: `pickDirectoryHandle` needs a
+ * user gesture and opens the native picker; `ensureReadwritePermission` reports
+ * whether an already-stored handle can be used silently. Chrome may answer
+ * `granted` after a reload (persistent permission) or `prompt`, and `prompt`
+ * can only be cleared by another real gesture — `requestPermission()` consumes
+ * the activation that a page load does not have. The UI therefore needs a
+ * reconnect affordance even though the common case is silent.
+ */
+import { type LocalFilesBlocker, type LocalFilesWindowLike } from './capabilities.js';
+export type PickResult = {
+    kind: 'picked';
+    handle: FileSystemDirectoryHandle;
+} | {
+    kind: 'cancelled';
+} | {
+    kind: 'unavailable';
+    blocker: Exclude<LocalFilesBlocker, null>;
+}
+/** The picker existed and was invoked, but the grant itself failed. */
+ | {
+    kind: 'failed';
+    message: string;
+};
+export interface DirectoryPickerLike {
+    (options?: {
+        id?: string;
+        mode?: 'read' | 'readwrite';
+    }): Promise<FileSystemDirectoryHandle>;
+}
+export declare function pickDirectoryHandle(win: LocalFilesWindowLike): Promise<PickResult>;
+export interface PermissionResult {
+    state: PermissionState;
+    /**
+     * True when `requestPermission` ran and consumed the click's transient
+     * activation — including when it ended in denial, in which case a picker
+     * opened in the same click would fail gesture-less.
+     */
+    requested: boolean;
+}
+/**
+ * Report — and optionally ask for — readwrite access to a stored handle. Pass
+ * `allowRequest: true` only from inside a real click handler.
+ */
+export declare function ensureReadwritePermission(handle: FileSystemDirectoryHandle, options?: {
+    allowRequest?: boolean;
+}): Promise<PermissionResult>;

package/dist/types/local-files/useLocalFilesBridge.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 4d — React wiring for the local-files bridge.
+ *
+ * Owns the whole lifecycle the design doc describes: probe the context, restore
+ * a stored grant silently when the browser allows it, otherwise wait for a real
+ * click, then run {@link LocalFilesBridge} bound to the active session.
+ *
+ * Three rules here come from measurement, not preference:
+ *  - `requestPermission()` consumes user activation, so a `prompt` state can
+ *    only be cleared from inside a click handler — never from an effect.
+ *  - Session-scoped registration emits no workspace event, so nothing outside
+ *    this hook will report that the bridge came or went; this status is the
+ *    only source of truth.
+ *  - Registration needs a live session AND a live ACP channel, so a granted
+ *    handle is kept even when no session exists yet, and the bridge starts the
+ *    moment one appears.
+ */
+import { type AcpWorkspaceSelector, type LockManagerLike, type OpenSocket } from './bridge-client.js';
+import { type LocalFilesBlocker, type LocalFilesWindowLike } from './capabilities.js';
+import { type DirectoryHandleStore } from './directory-handle-store.js';
+export type LocalFilesPhase = 'unavailable' | 'needs-session' | 'idle' | 'needs-gesture' | 'held-elsewhere' | 'connecting' | 'registering' | 'connected' | 'reconnecting' | 'failed';
+export interface LocalFilesStatus {
+    phase: LocalFilesPhase;
+    /** Set when `phase` is 'unavailable'. */
+    blocker: LocalFilesBlocker;
+    /** Granted directory name, once known. */
+    rootName?: string;
+    toolCount?: number;
+    /** Reason for 'failed' / 'reconnecting', or a picker error. */
+    message?: string;
+}
+export interface UseLocalFilesBridgeOptions {
+    /** The session the bridge binds to; undefined until one exists. */
+    sessionId: string | undefined;
+    baseUrl: string;
+    token?: string;
+    /** Re-warm the ACP child before a registration retry. */
+    rewarm?: () => Promise<void>;
+    openSocket?: OpenSocket;
+    locks?: LockManagerLike | null;
+    store?: DirectoryHandleStore | null;
+    win?: LocalFilesWindowLike;
+    /** Test seam for the bridge's backoff delays. */
+    delay?: (ms: number) => Promise<void>;
+    /** The session's workspace when not the primary one; see the bridge. */
+    workspaceSelector?: AcpWorkspaceSelector;
+    /**
+     * Deployment-level blocker the browser probe cannot see (the session's
+     * workspace is untrusted or live): withholds the bridge entirely.
+     */
+    withheldBlocker?: LocalFilesBlocker;
+}
+export declare function useLocalFilesBridge(options: UseLocalFilesBridgeOptions): {
+    status: LocalFilesStatus;
+    capability: {
+        blocker: "unsupported-browser" | "insecure-context" | "cross-origin-frame" | "workspace-ineligible" | "workspace-resolving" | "unsupported-daemon" | null;
+        pickerAvailable: boolean;
+        secureContext: boolean;
+        frame: import("./capabilities.js").LocalFilesFrame;
+    };
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    restore: () => Promise<void>;
+};

package/dist/types/main.d.ts

@@ -0,0 +1,6 @@
+import './styles/globals.css';
+import 'katex/dist/katex.min.css';
+import './styles/standalone.css';
+export declare function StandaloneApp({ daemonToken }: {
+    daemonToken?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/mcpAppHostContext.d.ts

@@ -0,0 +1 @@
+export declare const McpAppHostContext: import("react").Context<string | undefined>;

package/dist/types/midTurnDedup.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface MidTurnQueueItem {
+    text: string;
+    images?: unknown[];
+    files?: unknown[];
+    midTurnState?: 'submitting' | 'queued';
+    midTurnMessageId?: string;
+    isInserting?: boolean;
+}
+export interface MidTurnInjectedBatch {
+    sessionId: string;
+    messages: readonly string[];
+    messageIds?: readonly string[];
+    /** Trusted client id that queued the messages (from the SSE envelope). */
+    originatorClientId?: string;
+}
+/**
+ * Reconcile injected mid-turn messages against the local pending queue: remove
+ * the entry matching each injected message for `sessionId`, across ALL `batches`
+ * (a multi-batch turn drains once per tool batch, so the consumer must process
+ * every accumulated batch, not just the latest).
+ *
+ * Each injected message is matched in two passes. The first pass is a strict
+ * `midTurnMessageId` match (the daemon mints an id at admission and echoes it on
+ * injection); it wins regardless of array position, so two same-text sends can't
+ * steal each other's removal when their admission responses arrive out of order.
+ * Image rows are only matched here — the id proves the daemon owns them, while
+ * a text comparison can't verify their attachments. File rows are never
+ * matched — files are not pushed mid-turn, so they stay queued for the next
+ * turn. Only when no id match exists does the second pass fall back to the
+ * first text-only entry with matching text — any mid-turn row when the batch
+ * carries no ids (older daemon), or a still-`submitting` row that hasn't
+ * received its id yet. Matching stays count-based — one removal per injected
+ * message — so a queue that holds the same text twice loses one entry per
+ * matching injection. An entry that already fell back to the ordinary path
+ * (`midTurnState === undefined`) is never matched.
+ *
+ * Text fallback skips batches from another originator so coincidentally equal
+ * messages are not removed. In strict-id mode, an exact id still wins because
+ * a refreshed client can adopt a session-wide daemon-owned row.
+ *
+ * Returns a NEW array when something was removed, or `null` when nothing matched
+ * (so the caller can skip a redundant state update). `strictMessageIds`
+ * disables the submitting-row text fallback for daemons that accept the
+ * client-generated ids used by reconciliation; older daemons still need the
+ * fallback because they mint their id after the request arrives.
+ */
+export declare function removeInjectedFromQueue<T extends MidTurnQueueItem>(prompts: readonly T[], batches: readonly MidTurnInjectedBatch[], sessionId: string, clientId?: string, strictMessageIds?: boolean): T[] | null;

package/dist/types/monitorDetailsContext.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import type { ACPToolCall } from './adapters/types';
+export type OpenMonitorDetails = (tool: ACPToolCall) => Promise<boolean>;
+interface MonitorDetailsContextValue {
+    onOpen: OpenMonitorDetails;
+}
+export declare function MonitorDetailsProvider({ onOpen, children, }: {
+    onOpen: OpenMonitorDetails;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useMonitorDetails(): MonitorDetailsContextValue | undefined;
+export {};

package/dist/types/notification-text.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const MAX_NOTIFICATION_SOURCE_LENGTH = 4096;
+export declare function notificationTextLines(text: string): string[];
+export declare function notificationExcerpt(text: string, limit: number): string;

package/dist/types/portalRoot.d.ts

@@ -0,0 +1,2 @@
+export declare const WebShellPortalRootContext: import("react").Context<HTMLElement | null>;
+export declare function useWebShellPortalRoot(): HTMLElement | null;

package/dist/types/pwa-registration.d.ts

@@ -0,0 +1,10 @@
+interface ServiceWorkerRegistrationOptions {
+    production: boolean;
+    root?: Pick<HTMLElement, 'hasAttribute'>;
+    serviceWorker?: Pick<ServiceWorkerContainer, 'register'>;
+    addLoadListener?: (listener: () => void) => void;
+    warn?: (...args: unknown[]) => void;
+}
+/** Schedule standalone PWA registration after the initial document load. */
+export declare function scheduleServiceWorkerRegistration({ production, root, serviceWorker, addLoadListener, warn, }: ServiceWorkerRegistrationOptions): void;
+export {};

package/dist/types/session-catalog/session-catalog-hooks.d.ts

@@ -0,0 +1,121 @@
+import type { DaemonClient, DaemonBackgroundTurn, DaemonSessionArchiveState, DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+import { type SessionCatalogQuery, type SessionCatalogSnapshot } from './session-catalog-store';
+interface SessionCatalogHookOptions {
+    autoLoad?: boolean;
+    enabled?: boolean;
+    maxAgeMs?: number;
+    pollIntervalMs?: number;
+}
+export interface WebShellSessionsOptions extends SessionCatalogHookOptions {
+    pageSize?: number;
+    cursor?: string;
+    archiveState?: DaemonSessionArchiveState;
+    view?: 'organized';
+    group?: string;
+    sourceType?: string;
+    sourceId?: string;
+    parentSessionId?: string;
+}
+export declare function useSessionCatalogQuery(client: DaemonClient, query: SessionCatalogQuery | undefined, options?: SessionCatalogHookOptions): {
+    sessions: DaemonSessionSummary[];
+    nextCursor: string | undefined;
+    liveMergeFailed: boolean;
+    truncated: boolean;
+    reload: (options?: {
+        interactive?: boolean;
+    }) => Promise<import("@qwen-code/sdk/daemon").DaemonSessionListPage> | Promise<undefined>;
+    page?: import("@qwen-code/sdk/daemon").DaemonSessionListPage;
+    loading: boolean;
+    stale: boolean;
+    error?: Error;
+    updatedAt?: number;
+};
+export declare function useSessionCatalogQueries(client: DaemonClient, queries: readonly SessionCatalogQuery[], options?: SessionCatalogHookOptions): readonly SessionCatalogSnapshot[];
+/**
+ * Whether the daemon reports a prompt in flight for `sessionId`, together with
+ * whether that answer is allowed to *settle* a running turn.
+ *
+ * Only a live-state response observed after this session became the target is
+ * `authoritative`. A cached response can still light the indicator, but cannot
+ * settle a newer `/load` snapshot. The catalog-page fallback cannot settle
+ * either: the page is bounded, so a running session may simply have fallen off
+ * a fresher first page (#9487).
+ */
+export declare function useSessionActivePromptState(client: DaemonClient, workspaceCwd: string | undefined, sessionId: string | undefined): {
+    hasActivePrompt: boolean;
+    activeWorkState: DaemonSessionSummary['activeWorkState'];
+    backgroundTurn?: DaemonBackgroundTurn;
+    authoritative: boolean;
+    observationRevision: number | undefined;
+    requestStartedAt?: number;
+};
+/**
+ * Read the daemon's live prompt state for the surrounding
+ * `DaemonSessionProvider`'s session, and publish it back into that provider.
+ *
+ * Every view that owns a provider needs its own bridge: a split pane and a
+ * side task each mount one (via ChatPane), and each is an observer of a turn
+ * it did not submit — the case where the event stream alone cannot tell a long
+ * silent tool call from a finished turn (#9487). Publishing `undefined` while
+ * the answer is unknown leaves that provider's pre-existing heuristics alone.
+ *
+ * Returns both live facts for callers that need them; the boolean wrapper
+ * below preserves the existing prompt-only API.
+ */
+export declare function useDaemonSessionActivityBridge(client: DaemonClient, workspaceCwd: string | undefined, sessionId: string | undefined): {
+    hasActivePrompt: boolean;
+    activeWorkState: DaemonSessionSummary['activeWorkState'];
+};
+export declare function useDaemonActivePromptBridge(client: DaemonClient, workspaceCwd: string | undefined, sessionId: string | undefined): boolean;
+export declare function useSessionCatalogPolling(client: DaemonClient, query: SessionCatalogQuery | undefined, pollIntervalMs: number | undefined): void;
+export declare function useSessionCatalogController(client: DaemonClient): {
+    refreshQueries(queries: readonly SessionCatalogQuery[]): void;
+    invalidateWorkspace(workspaceCwd: string): void;
+    refreshWorkspace(workspaceCwd: string): void;
+    sessionCreated(workspaceCwd: string, _sessionId: string): void;
+    promptAdmitted(workspaceCwd: string, sessionId: string): void;
+    promptAdmissionUncertain(workspaceCwd: string): void;
+    renamed(workspaceCwd: string, sessionId: string, displayName: string): void;
+    toggleSessionPinned(workspaceCwd: string, session: DaemonSessionSummary, toggle: {
+        pinned: boolean;
+        pinnedAt?: string;
+    }): void;
+    turnCompleted(workspaceCwd: string, sessionId: string): void;
+};
+export declare function useWebShellSessions(options?: WebShellSessionsOptions): {
+    data: DaemonSessionSummary[] | undefined;
+    sessions: DaemonSessionSummary[];
+    loading: boolean;
+    error: Error | undefined;
+    reload: (reloadOptions?: {
+        interactive?: boolean;
+    }) => Promise<DaemonSessionSummary[] | undefined>;
+    nextCursor: string | undefined;
+    liveMergeFailed: boolean;
+    truncated: boolean;
+    loadSession: ((sessionId: string, options?: {
+        workspaceCwd?: string;
+        sessionContext?: import("@qwen-code/web-shell/daemon-react-sdk").DaemonProductSessionContext;
+    }) => Promise<void>) | undefined;
+    resumeSession: ((sessionId: string, options?: {
+        workspaceCwd?: string;
+        sessionContext?: import("@qwen-code/web-shell/daemon-react-sdk").DaemonProductSessionContext;
+    }) => Promise<void>) | undefined;
+    newSession: (() => Promise<void>) | undefined;
+    releaseSession: ((sessionId: string) => Promise<void>) | undefined;
+    releaseSessionAction: ((sessionId: string) => Promise<void>) | undefined;
+    deleteSession: (sessionId: string) => Promise<boolean>;
+    deleteSessions: (sessionIds: string[]) => Promise<{
+        removed: string[];
+        notFound: string[];
+        errors: Array<{
+            sessionId: string;
+            error: string;
+        }>;
+    }>;
+    exportSession: (sessionId: string, format?: import("@qwen-code/sdk/daemon").DaemonSessionExportFormat) => Promise<import("@qwen-code/sdk/daemon").DaemonSessionExportResult>;
+    archiveSession: (sessionId: string) => Promise<boolean>;
+    unarchiveSession: (sessionId: string) => Promise<boolean>;
+    catalogQuery: SessionCatalogQuery | undefined;
+};
+export {};

package/dist/types/session-catalog/session-catalog-store.d.ts

@@ -0,0 +1,143 @@
+import type { DaemonClient, DaemonSessionLiveState, DaemonSessionListPage, DaemonSessionListPageOptions, DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+export type SessionCatalogRouteKind = 'legacy' | 'qualified';
+export interface SessionCatalogQuery {
+    routeKind: SessionCatalogRouteKind;
+    workspaceCwd: string;
+    options: DaemonSessionListPageOptions;
+}
+export interface SessionCatalogSnapshot {
+    page?: DaemonSessionListPage;
+    loading: boolean;
+    stale: boolean;
+    error?: Error;
+    updatedAt?: number;
+}
+export interface SessionCatalogSubscriptionOptions {
+    autoLoad?: boolean;
+    maxAgeMs?: number;
+    pollIntervalMs?: number;
+}
+interface StagedCatalogPage {
+    key: string;
+    revision: number;
+    page: DaemonSessionListPage;
+}
+export interface StagedWorkspaceSessionCatalog {
+    workspaceCwd: string;
+    pages: StagedCatalogPage[];
+    complete: boolean;
+}
+export declare const SESSION_CATALOG_ERROR_RETRY_MS = 30000;
+export declare const SESSION_CATALOG_RETENTION_MS = 30000;
+export declare const SESSION_CATALOG_TRAILING_REFRESH_MS = 2000;
+export declare function getSessionCatalogQueryKey(query: SessionCatalogQuery): string;
+export declare class SessionCatalogStore {
+    private readonly client;
+    private readonly entries;
+    private readonly queue;
+    private readonly trailingRefreshTimers;
+    private readonly liveStateWorkspaceUsers;
+    private readonly liveStateWorkspaceRefreshRequests;
+    private readonly liveStateWakeHandlers;
+    private liveStateActivitySequence;
+    private readonly liveStatePendingActivity;
+    private readonly liveStateFailureStreaks;
+    private liveSessionRevision;
+    private readonly liveSessionRevisions;
+    private readonly liveSessionRequestTimes;
+    private readonly liveSessionsByWorkspace;
+    private readonly liveSessionListeners;
+    private readonly liveSessionObservationListeners;
+    private activeRequests;
+    private activeBackgroundRequests;
+    private queueSequence;
+    private visibilityListening;
+    constructor(client: DaemonClient);
+    getSnapshot(query: SessionCatalogQuery): SessionCatalogSnapshot;
+    getEmptySnapshot(): SessionCatalogSnapshot;
+    retainWorkspaceLiveState(workspaceCwd: string): () => void;
+    isWorkspaceLiveStateEnabled(workspaceCwd: string): boolean;
+    consumeWorkspaceLiveStateRefreshRequest(workspaceCwd: string): 'interactive' | 'invalidated' | undefined;
+    onLiveStateWake(handler: (workspaceCwd: string, bypassRetry?: boolean) => void): () => void;
+    requestWorkspaceLiveStateRefresh(workspaceCwd: string): void;
+    recordSessionActivity(workspaceCwd: string, sessionId: string): void;
+    snapshotSessionActivity(workspaceCwd: string): ReadonlyMap<string, number> | undefined;
+    resolveSessionActivity(workspaceCwd: string, sessionId: string, sequence: number): void;
+    private requestLiveStateRefresh;
+    subscribe(query: SessionCatalogQuery, listener: () => void, options?: SessionCatalogSubscriptionOptions): () => void;
+    refresh(query: SessionCatalogQuery, options?: {
+        interactive?: boolean;
+    }): Promise<DaemonSessionListPage>;
+    loadOnce(query: SessionCatalogQuery, options?: {
+        fresh?: boolean;
+    }): Promise<DaemonSessionListPage>;
+    invalidateWorkspace(workspaceCwd: string, options?: {
+        background?: boolean;
+        interactive?: boolean;
+    }): void;
+    patchSession(workspaceCwd: string, sessionId: string, patch: Partial<Omit<DaemonSessionSummary, 'sessionId' | 'workspaceCwd'>>): void;
+    /**
+     * Apply a pin toggle optimistically to every loaded page of the workspace,
+     * so the store owns the optimistic state's lifetime (the R5-1 fix
+     * direction). Pinned-view pages gain or lose the row; every other page
+     * patches it in place. Because the toggle lands in the page data itself,
+     * later local writes (`patchSession`, `applyLiveState`) churn around it
+     * without dropping it, and only an authoritative refetch replaces it.
+     * Rolling back is the same operation with the opposite target.
+     */
+    applySessionPinToggle(workspaceCwd: string, session: DaemonSessionSummary, toggle: {
+        pinned: boolean;
+        pinnedAt?: string;
+    }): void;
+    getLiveSession(workspaceCwd: string, sessionId: string): DaemonSessionLiveState | undefined;
+    hasLiveSessions(workspaceCwd: string): boolean;
+    getLiveSessionRequestStartedAt(workspaceCwd: string): number | undefined;
+    getLiveSessionRevision(workspaceCwd: string): number | undefined;
+    /**
+     * Drop the retained live-state snapshot after its channel has failed for
+     * long enough that the snapshot can no longer be called current. Readers
+     * then report the answer as unknown rather than serving a last-known value
+     * indefinitely — a daemon that dies mid-turn must not leave a pane believing
+     * the turn is still running for the life of the tab (#9487).
+     */
+    markWorkspaceLiveStateUnavailable(workspaceCwd: string): void;
+    recordLiveStateFailure(workspaceCwd: string): number;
+    subscribeLiveSessions(workspaceCwd: string, listener: () => void): () => void;
+    subscribeLiveSessionObservations(workspaceCwd: string, listener: () => void): () => void;
+    applyLiveState(workspaceCwd: string, liveSessions: readonly DaemonSessionLiveState[], requestStartedAt?: number): ReadonlySet<string>;
+    private recordLiveSessions;
+    private clearLiveSessions;
+    stageWorkspaceRefresh(workspaceCwd: string): Promise<StagedWorkspaceSessionCatalog>;
+    commitWorkspaceRefresh(staged: StagedWorkspaceSessionCatalog): boolean;
+    scheduleWorkspaceRefresh(workspaceCwd: string, delayMs?: number): void;
+    dispose(): void;
+    private getOrCreateEntry;
+    private requestFresh;
+    private createWaiter;
+    private requestBackground;
+    private ensureScheduled;
+    private sortQueue;
+    private drainQueue;
+    private startJob;
+    private finishJob;
+    private fetchStagedPage;
+    private fetchPage;
+    private resolveWaiters;
+    private rejectWaiters;
+    private setSnapshot;
+    private resetPollSchedule;
+    private schedulePollFromNow;
+    private scheduleEntryTimer;
+    private clearPollTimer;
+    private removeQueuedJob;
+    private scheduleCleanup;
+    private isHidden;
+    private updateVisibilityListener;
+    private removeVisibilityListener;
+    private readonly onVisibilityChange;
+}
+export declare function getSessionCatalogStore(client: DaemonClient): SessionCatalogStore;
+export declare function loadSessionCatalogOnce(client: DaemonClient, query: SessionCatalogQuery, options?: {
+    fresh?: boolean;
+}): Promise<DaemonSessionListPage>;
+export {};

package/dist/types/session-catalog/session-live-state-poll-interval.d.ts

@@ -0,0 +1,2 @@
+export declare const SESSION_LIVE_STATE_POLL_MS = 5000;
+export declare function resolveSessionLiveStatePollInterval(value: unknown): number;