@percena/weft-react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4980 @@
+export { EN_FALLBACK };
+export { CreateFlitroEmbedRuntimeOptions, createFlitroEmbedRuntime };
+
+/**
+ * useAgentSession — the official L1 runtime-configuration API.
+ *
+ * Wraps `createFlitroEmbedRuntime` in a hook: the host backend mints
+ * `{ server, token, sessionId }` (e.g. with `@percena/weft-node`) and the
+ * component renders `<TimelineAgentChatPanel runtime={session.runtime} />`.
+ */
+
+interface UseAgentSessionOptions {
+    /** Agent server base URL, as returned by the embed bootstrap. */
+    server: string;
+    /** Scoped session token from the embed bootstrap. */
+    token: string;
+    /** Session bound to the token. */
+    sessionId: string;
+    /** Fetch a fresh token from your backend when the current one expires. */
+    onTokenExpired?: () => Promise<string | undefined> | string | undefined;
+}
+interface AgentSession {
+    runtime: AgentRuntime;
+    sessionId: string;
+    server: string;
+}
+declare function useAgentSession(options: UseAgentSessionOptions): AgentSession;
+
+export { type AgentSession, type UseAgentSessionOptions, useAgentSession };
+
+// ── inlined from @weft/core ──
+// -- @weft/core/index.d.ts --
+
+/**
+ * Mode Types and Constants
+ *
+ * Pure types and UI configuration for permission modes.
+ * Note: This file imports zod for schema definitions.
+ * Type-only imports (PermissionMode, PermissionModeCanonical) have no runtime cost.
+ */
+
+/**
+ * Available permission modes (internal storage keys).
+ *
+ * UI-facing canonical names are:
+ * - explore  -> safe
+ * - ask      -> ask
+ * - execute  -> allow-all
+ */
+type PermissionMode = 'safe' | 'ask' | 'allow-all';
+/**
+ * Canonical mode names used in user-facing/session-state surfaces.
+ */
+type PermissionModeCanonical = 'explore' | 'ask' | 'execute';
+
+/**
+ * Thinking Level Configuration
+ *
+ * Six-tier thinking system for extended reasoning:
+ * - OFF: No extended thinking (disabled)
+ * - Low: Light reasoning, faster responses
+ * - Medium: Balanced speed and reasoning (default)
+ * - High: Deep reasoning for complex tasks
+ * - XHigh: Extra-high reasoning — Anthropic's recommended level for Opus 4.7 agentic/coding work
+ * - Max: Maximum effort reasoning
+ *
+ * Session-level setting with workspace defaults.
+ *
+ * Provider mappings:
+ * - Anthropic: adaptive thinking + effort levels (Opus 4.7+). On models that
+ *   don't accept `xhigh`, the Anthropic SDK silently falls back to `high`.
+ * - Pi/OpenAI: reasoning_effort via Pi SDK levels. Pi's ceiling is `xhigh`,
+ *   so Weft's `max` saturates there.
+ */
+/**
+ * Ordered list of valid thinking level IDs. Single source of truth — the
+ * `ThinkingLevel` type, `THINKING_LEVELS` metadata, the Zod schema in
+ * `validators.ts`, and runtime validation/error messages all derive from this.
+ *
+ * Order is significant: it determines UI ordering (low → max).
+ */
+declare const THINKING_LEVEL_IDS: readonly ["off", "low", "medium", "high", "xhigh", "max"];
+type ThinkingLevel = (typeof THINKING_LEVEL_IDS)[number];
+interface ThinkingLevelDefinition {
+    id: ThinkingLevel;
+    /** Translation key for the display name (resolve with t() at render site) */
+    nameKey: string;
+    /** Translation key for the description (resolve with t() at render site) */
+    descriptionKey: string;
+}
+/**
+ * Available thinking levels with display metadata.
+ * Used in UI dropdowns and for validation.
+ *
+ * Labels use translation keys — resolve with t(level.nameKey) in components.
+ */
+declare const THINKING_LEVELS: readonly ThinkingLevelDefinition[];
+/**
+ * Map ThinkingLevel to Anthropic SDK effort parameter.
+ * Used with adaptive thinking (thinking: { type: 'adaptive' }).
+ * Returns null for 'off' (thinking should be disabled entirely).
+ */
+declare const THINKING_TO_EFFORT: Record<ThinkingLevel, 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null>;
+/**
+ * Get the thinking token budget for a given level and model.
+ * Used as fallback for models that don't support adaptive thinking.
+ *
+ * @param level - The thinking level
+ * @param modelId - The model ID (e.g., 'claude-haiku-4-5-20251001')
+ * @returns Number of thinking tokens to allocate
+ */
+declare function getThinkingTokens(level: ThinkingLevel, modelId: string): number;
+/**
+ * Get the translation key for a thinking level's display name.
+ * Resolve with t() or i18n.t() at the call site.
+ */
+declare function getThinkingLevelNameKey(level: ThinkingLevel): string;
+/**
+ * Validate that a value is a valid ThinkingLevel.
+ */
+declare function isValidThinkingLevel(value: unknown): value is ThinkingLevel;
+/**
+ * Normalize a persisted thinking level value, handling legacy values.
+ * Maps the old 'think' value to 'medium' for backward compatibility.
+ *
+ * TODO: Remove the legacy 'think' compatibility path after old persisted session
+ * and workspace data has realistically aged out across upgrades.
+ *
+ * @returns The normalized ThinkingLevel, or undefined if the value is invalid
+ */
+declare function normalizeThinkingLevel(value: unknown): ThinkingLevel | undefined;
+
+/**
+ * Server DTO types — data shapes used by RPC handlers and SessionManager.
+ *
+ * Extracted here so handler code in @weft can import
+ * from @weft/protocol without reaching into the app.
+ */
+
+/**
+ * Dynamic status ID referencing workspace status config.
+ * Validated at runtime via validateSessionStatus().
+ * Falls back to 'todo' if status doesn't exist.
+ */
+type SessionStatus = string;
+type BuiltInStatusId = 'todo' | 'in-progress' | 'needs-review' | 'done' | 'cancelled';
+/**
+ * Electron-specific Session type (includes runtime state).
+ * Extends core Session with messages array and processing state.
+ */
+interface Session {
+    id: string;
+    workspaceId: string;
+    workspaceName: string;
+    name?: string;
+    /** Preview of first user message (from JSONL header, for lazy-loaded sessions) */
+    preview?: string;
+    lastMessageAt: number;
+    messages: Message[];
+    isProcessing: boolean;
+    isFlagged?: boolean;
+    /** Permission mode for this session ('safe', 'ask', 'allow-all') */
+    permissionMode?: PermissionMode;
+    sessionStatus?: SessionStatus;
+    /** Labels (additive tags, many-per-session — bare IDs or "id::value" entries) */
+    labels?: string[];
+    lastReadMessageId?: string;
+    /**
+     * Explicit unread flag - single source of truth for NEW badge.
+     * Set to true when assistant message completes while user is NOT viewing.
+     * Set to false when user views the session (and not processing).
+     */
+    hasUnread?: boolean;
+    enabledSourceSlugs?: string[];
+    workingDirectory?: string;
+    sessionFolderPath?: string;
+    sharedUrl?: string;
+    sharedId?: string;
+    model?: string;
+    llmConnection?: string;
+    thinkingLevel?: ThinkingLevel;
+    lastMessageRole?: 'user' | 'assistant' | 'plan' | 'tool' | 'error';
+    lastFinalMessageId?: string;
+    isAsyncOperationOngoing?: boolean;
+    /** @deprecated Use isAsyncOperationOngoing instead */
+    isRegeneratingTitle?: boolean;
+    currentStatus?: {
+        message: string;
+        statusType?: string;
+    };
+    createdAt?: number;
+    messageCount?: number;
+    tokenUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        contextTokens: number;
+        costUsd: number;
+        cacheReadTokens?: number;
+        cacheCreationTokens?: number;
+        /** Model's context window size in tokens (from SDK modelUsage) */
+        contextWindow?: number;
+    };
+    /** When true, session is hidden from session list (e.g., mini edit sessions) */
+    hidden?: boolean;
+    isArchived?: boolean;
+    archivedAt?: number;
+    supportsBranching?: boolean;
+}
+interface CreateSessionOptions {
+    name?: string;
+    permissionMode?: PermissionMode;
+    /**
+     * Reasoning/thinking level override. When set, takes precedence over workspace
+     * and global defaults. Silently ignored by the underlying SDK on non-reasoning
+     * models (e.g. gpt-4o) — provider drivers don't attach the reasoning param to
+     * the API request for models with `reasoning: false` in the Pi SDK catalog.
+     */
+    thinkingLevel?: ThinkingLevel;
+    /**
+     * Working directory for the session:
+     * - 'user_default' or undefined: Use workspace's configured default working directory
+     * - 'none': No working directory (session folder only)
+     * - Absolute path string: Use this specific path
+     */
+    workingDirectory?: string | 'user_default' | 'none';
+    model?: string;
+    llmConnection?: string;
+    systemPromptPreset?: 'default' | 'mini' | string;
+    hidden?: boolean;
+    sessionStatus?: SessionStatus;
+    labels?: string[];
+    isFlagged?: boolean;
+    enabledSourceSlugs?: string[];
+    /**
+     * Message ID to branch from. This is a hard context cutoff:
+     * the new session must not include model context from later parent messages.
+     */
+    branchFromMessageId?: string;
+    /** Parent session ID used together with branchFromMessageId. */
+    branchFromSessionId?: string;
+}
+interface RemoteSessionTransferPayload {
+    sourceSessionId: string;
+    name?: string;
+    sessionStatus?: SessionStatus;
+    labels?: string[];
+    permissionMode?: PermissionMode;
+    summary: string;
+}
+interface ImportRemoteSessionTransferResult {
+    sessionId: string;
+}
+interface PermissionModeState {
+    permissionMode: PermissionMode;
+    previousPermissionMode?: PermissionMode;
+    transitionDisplay?: string;
+    modeVersion: number;
+    changedAt: string;
+    changedBy: 'user' | 'system' | 'restore' | 'automation' | 'unknown';
+}
+type SessionEvent = {
+    type: 'text_delta';
+    sessionId: string;
+    delta: string;
+    turnId?: string;
+} | {
+    type: 'text_complete';
+    sessionId: string;
+    text: string;
+    isIntermediate?: boolean;
+    turnId?: string;
+    parentToolUseId?: string;
+    timestamp?: number;
+    messageId?: string;
+} | {
+    type: 'tool_start';
+    sessionId: string;
+    toolName: string;
+    toolUseId: string;
+    toolInput: Record<string, unknown>;
+    toolIntent?: string;
+    toolDisplayName?: string;
+    toolDisplayMeta?: ToolDisplayMeta;
+    turnId?: string;
+    parentToolUseId?: string;
+    timestamp?: number;
+} | {
+    type: 'tool_result';
+    sessionId: string;
+    toolUseId: string;
+    toolName: string;
+    result: string;
+    turnId?: string;
+    parentToolUseId?: string;
+    isError?: boolean;
+    timestamp?: number;
+} | {
+    type: 'error';
+    sessionId: string;
+    error: string;
+    timestamp?: number;
+} | {
+    type: 'typed_error';
+    sessionId: string;
+    error: TypedError;
+    timestamp?: number;
+} | {
+    type: 'complete';
+    sessionId: string;
+    tokenUsage?: Session['tokenUsage'];
+    hasUnread?: boolean;
+} | {
+    type: 'interrupted';
+    sessionId: string;
+    message?: Message;
+    queuedMessages?: string[];
+} | {
+    type: 'status';
+    sessionId: string;
+    message: string;
+    statusType?: 'compacting';
+} | {
+    type: 'info';
+    sessionId: string;
+    message: string;
+    statusType?: 'compaction_complete';
+    level?: 'info' | 'warning' | 'error' | 'success';
+    timestamp?: number;
+} | {
+    type: 'title_generated';
+    sessionId: string;
+    title: string;
+} | {
+    type: 'title_regenerating';
+    sessionId: string;
+    isRegenerating: boolean;
+} | {
+    type: 'async_operation';
+    sessionId: string;
+    isOngoing: boolean;
+} | {
+    type: 'working_directory_changed';
+    sessionId: string;
+    workingDirectory: string;
+} | {
+    type: 'permission_request';
+    sessionId: string;
+    request: PermissionRequest;
+} | {
+    type: 'credential_request';
+    sessionId: string;
+    request: CredentialRequest;
+} | {
+    type: 'permission_mode_changed';
+    sessionId: string;
+    permissionMode: PermissionMode;
+    previousPermissionMode?: PermissionMode;
+    transitionDisplay?: string;
+    modeVersion?: number;
+    changedAt?: string;
+    changedBy?: PermissionModeState['changedBy'];
+} | {
+    type: 'plan_submitted';
+    sessionId: string;
+    message: Message;
+} | {
+    type: 'sources_changed';
+    sessionId: string;
+    enabledSourceSlugs: string[];
+} | {
+    type: 'labels_changed';
+    sessionId: string;
+    labels: string[];
+} | {
+    type: 'connection_changed';
+    sessionId: string;
+    connectionSlug: string;
+    supportsBranching?: boolean;
+} | {
+    type: 'task_backgrounded';
+    sessionId: string;
+    toolUseId: string;
+    taskId: string;
+    intent?: string;
+    turnId?: string;
+} | {
+    type: 'shell_backgrounded';
+    sessionId: string;
+    toolUseId: string;
+    shellId: string;
+    intent?: string;
+    command?: string;
+    turnId?: string;
+} | {
+    type: 'task_progress';
+    sessionId: string;
+    toolUseId: string;
+    elapsedSeconds: number;
+    turnId?: string;
+} | {
+    type: 'task_completed';
+    sessionId: string;
+    taskId: string;
+    status: 'completed' | 'failed' | 'stopped';
+    outputFile?: string;
+    summary?: string;
+    turnId?: string;
+} | {
+    type: 'shell_killed';
+    sessionId: string;
+    shellId: string;
+} | {
+    type: 'user_message';
+    sessionId: string;
+    message: Message;
+    status: 'accepted' | 'queued' | 'processing';
+    optimisticMessageId?: string;
+} | {
+    type: 'session_flagged';
+    sessionId: string;
+} | {
+    type: 'session_unflagged';
+    sessionId: string;
+} | {
+    type: 'session_archived';
+    sessionId: string;
+} | {
+    type: 'session_unarchived';
+    sessionId: string;
+} | {
+    type: 'name_changed';
+    sessionId: string;
+    name?: string;
+} | {
+    type: 'session_model_changed';
+    sessionId: string;
+    model: string | null;
+} | {
+    type: 'session_status_changed';
+    sessionId: string;
+    sessionStatus: SessionStatus;
+} | {
+    type: 'session_deleted';
+    sessionId: string;
+} | {
+    type: 'session_created';
+    sessionId: string;
+} | {
+    type: 'session_shared';
+    sessionId: string;
+    sharedUrl: string;
+} | {
+    type: 'session_unshared';
+    sessionId: string;
+} | {
+    type: 'auth_request';
+    sessionId: string;
+    message: Message;
+    request: AuthRequest;
+} | {
+    type: 'auth_completed';
+    sessionId: string;
+    requestId: string;
+    success: boolean;
+    cancelled?: boolean;
+    error?: string;
+} | {
+    type: 'source_activated';
+    sessionId: string;
+    sourceSlug: string;
+    originalMessage: string;
+} | {
+    type: 'usage_update';
+    sessionId: string;
+    tokenUsage: {
+        inputTokens: number;
+        contextWindow?: number;
+    };
+} | {
+    type: 'message_annotations_updated';
+    sessionId: string;
+    messageId: string;
+    annotations: AnnotationV1[];
+} | {
+    type: 'working_directory_error';
+    sessionId: string;
+    error: string;
+};
+interface SendMessageOptions {
+    skillSlugs?: string[];
+    badges?: ContentBadge[];
+    optimisticMessageId?: string;
+}
+type SessionCommand = {
+    type: 'flag';
+} | {
+    type: 'unflag';
+} | {
+    type: 'archive';
+} | {
+    type: 'unarchive';
+} | {
+    type: 'rename';
+    name: string;
+} | {
+    type: 'setSessionStatus';
+    state: SessionStatus;
+} | {
+    type: 'markRead';
+} | {
+    type: 'markUnread';
+} | {
+    type: 'setActiveViewing';
+    workspaceId: string;
+} | {
+    type: 'setPermissionMode';
+    mode: PermissionMode;
+} | {
+    type: 'setThinkingLevel';
+    level: ThinkingLevel;
+} | {
+    type: 'updateWorkingDirectory';
+    dir: string;
+} | {
+    type: 'setSources';
+    sourceSlugs: string[];
+} | {
+    type: 'setLabels';
+    labels: string[];
+} | {
+    type: 'showInFinder';
+} | {
+    type: 'copyPath';
+} | {
+    type: 'shareToViewer';
+} | {
+    type: 'updateShare';
+} | {
+    type: 'revokeShare';
+} | {
+    type: 'refreshTitle';
+} | {
+    type: 'setConnection';
+    connectionSlug: string;
+} | {
+    type: 'setPendingPlanExecution';
+    planPath: string;
+    draftInputSnapshot?: string;
+} | {
+    type: 'markCompactionComplete';
+} | {
+    type: 'markPendingPlanExecutionDispatched';
+} | {
+    type: 'clearPendingPlanExecution';
+} | {
+    type: 'addAnnotation';
+    messageId: string;
+    annotation: AnnotationV1;
+} | {
+    type: 'removeAnnotation';
+    messageId: string;
+    annotationId: string;
+} | {
+    type: 'updateAnnotation';
+    messageId: string;
+    annotationId: string;
+    patch: Partial<AnnotationV1>;
+};
+interface NewChatActionParams {
+    input?: string;
+    name?: string;
+}
+
+/**
+ * Permission request with session context (for multi-session Electron app)
+ */
+interface PermissionRequest extends PermissionRequest$1 {
+    sessionId: string;
+}
+interface PermissionResponseOptions {
+    rememberForMinutes?: number;
+}
+
+/**
+ * Credential request from agent — prompts user for credentials
+ * (e.g., API key, username/password, OAuth token)
+ */
+interface CredentialRequest {
+    requestId: string;
+    toolName: string;
+    description: string;
+    credentialMode?: CredentialInputMode;
+    headerName?: string;
+    headerNames?: string[];
+    labels?: {
+        credential?: string;
+        username?: string;
+        password?: string;
+    };
+    hint?: string;
+    sourceUrl?: string;
+    passwordRequired?: boolean;
+}
+/**
+ * Auth request — unified auth flow (credential or OAuth)
+ */
+interface AuthRequest {
+    requestId: string;
+    type: AuthRequestType;
+    sourceSlug?: string;
+    sourceName?: string;
+    description?: string;
+    credentialMode?: CredentialInputMode;
+    headerName?: string;
+    headerNames?: string[];
+    labels?: {
+        credential?: string;
+        username?: string;
+        password?: string;
+    };
+    hint?: string;
+    sourceUrl?: string;
+    passwordRequired?: boolean;
+}
+interface CredentialResponse {
+    type: 'credential';
+    value?: string;
+    username?: string;
+    password?: string;
+    headers?: Record<string, string>;
+    cancelled: boolean;
+}
+/** Server-side directory listing result (for remote directory browsing). */
+interface DirectoryListingResult {
+    /** Normalized absolute path of the listed directory (after resolve(), not symlink-resolved). */
+    currentPath: string;
+    /** Parent directory path, or null if at root. */
+    parentPath: string | null;
+    /** Pre-split breadcrumb segments for display (computed server-side). */
+    breadcrumbs: Array<{
+        name: string;
+        path: string;
+    }>;
+    /** Server platform info. */
+    platform: 'win32' | 'darwin' | 'linux';
+    /** Whether the server truncated the directory list for safety/performance. */
+    truncated: boolean;
+    /** Total number of matching child directories before truncation. */
+    totalEntries: number;
+    /** Child directory entries. */
+    entries: Array<{
+        name: string;
+        path: string;
+        isSymlink: boolean;
+    }>;
+}
+interface FileAttachment {
+    type: 'image' | 'text' | 'pdf' | 'office' | 'audio' | 'unknown';
+    path: string;
+    name: string;
+    mimeType: string;
+    base64?: string;
+    text?: string;
+    size: number;
+    thumbnailBase64?: string;
+}
+interface SessionFile {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    size?: number;
+    children?: SessionFile[];
+}
+interface FileSearchResult {
+    name: string;
+    path: string;
+    type: 'file' | 'directory';
+    relativePath: string;
+}
+interface LlmConnectionSetup {
+    slug: string;
+    credential?: string;
+    baseUrl?: string | null;
+    defaultModel?: string | null;
+    models?: string[] | null;
+    piAuthProvider?: string;
+    modelSelectionMode?: 'automaticallySyncedFromProvider' | 'userDefined3Tier';
+    /** When true, reject setup if the connection doesn't already exist (reauth guard). */
+    updateOnly?: boolean;
+    /** Custom endpoint protocol for arbitrary OpenAI/Anthropic-compatible APIs */
+    customEndpoint?: Record<string, unknown>;
+    /** IAM credentials for Pi+Bedrock (piAuthProvider='amazon-bedrock') connections */
+    iamCredentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /** AWS region for Pi+Bedrock connections */
+    awsRegion?: string;
+    /** Bedrock authentication method — determines auth type for Pi+Bedrock connections */
+    bedrockAuthMethod?: 'iam_credentials' | 'environment';
+}
+interface TestLlmConnectionParams {
+    provider: 'anthropic' | 'pi';
+    apiKey: string;
+    baseUrl?: string;
+    model?: string;
+    piAuthProvider?: string;
+    /** Optional custom endpoint protocol hint so setup tests mirror runtime routing */
+    customEndpoint?: Record<string, unknown>;
+}
+interface TestLlmConnectionResult {
+    success: boolean;
+    error?: string;
+}
+interface SkillFile {
+    name: string;
+    type: 'file' | 'directory';
+    size?: number;
+    children?: SkillFile[];
+}
+interface OAuthResult {
+    success: boolean;
+    error?: string;
+}
+interface McpValidationResult {
+    success: boolean;
+    error?: string;
+    tools?: string[];
+}
+interface McpToolWithPermission {
+    name: string;
+    description?: string;
+    allowed: boolean;
+}
+interface McpToolsResult {
+    success: boolean;
+    error?: string;
+    tools?: McpToolWithPermission[];
+}
+interface SessionSearchMatch {
+    sessionId: string;
+    lineNumber: number;
+    snippet: string;
+}
+interface SessionSearchResult {
+    sessionId: string;
+    matchCount: number;
+    matches: SessionSearchMatch[];
+}
+interface UnreadSummary {
+    totalUnreadSessions: number;
+    byWorkspace: Record<string, number>;
+    hasUnreadByWorkspace: Record<string, boolean>;
+}
+interface ShareResult {
+    success: boolean;
+    url?: string;
+    error?: string;
+}
+interface RefreshTitleResult {
+    success: boolean;
+    title?: string;
+    error?: string;
+}
+interface PlanStep {
+    id: string;
+    description: string;
+    tools?: string[];
+    status?: 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped';
+}
+interface Plan {
+    id: string;
+    title: string;
+    summary?: string;
+    steps: PlanStep[];
+    questions?: string[];
+    state?: 'creating' | 'refining' | 'ready' | 'executing' | 'completed' | 'cancelled';
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface GitBashStatus {
+    found: boolean;
+    path: string | null;
+    platform: 'win32' | 'darwin' | 'linux';
+}
+interface UpdateInfo {
+    available: boolean;
+    currentVersion: string;
+    latestVersion: string | null;
+    downloadState: 'idle' | 'downloading' | 'ready' | 'installing' | 'error';
+    downloadProgress: number;
+    error?: string;
+}
+interface WorkspaceSettings {
+    name?: string;
+    model?: string;
+    permissionMode?: PermissionMode;
+    cyclablePermissionModes?: PermissionMode[];
+    thinkingLevel?: ThinkingLevel;
+    workingDirectory?: string;
+    localMcpEnabled?: boolean;
+    defaultLlmConnection?: string;
+    enabledSourceSlugs?: string[];
+}
+interface ClaudeOAuthResult {
+    success: boolean;
+    token?: string;
+    error?: string;
+}
+type TestAutomationAction = {
+    type: 'prompt';
+    prompt: string;
+    llmConnection?: string;
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
+} | {
+    type: 'webhook';
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    bodyFormat?: 'json' | 'form' | 'raw';
+    body?: unknown;
+    captureResponse?: boolean;
+    auth?: {
+        type: 'basic';
+        username: string;
+        password: string;
+    } | {
+        type: 'bearer';
+        token: string;
+    };
+};
+interface TestAutomationPayload {
+    workspaceId: string;
+    automationId?: string;
+    automationName?: string;
+    actions: TestAutomationAction[];
+    permissionMode?: PermissionMode;
+    labels?: string[];
+    /** Forwarded from the matcher; routes test-run sessions into a Telegram topic when paired. */
+    telegramTopic?: string;
+}
+type TestAutomationActionResult = {
+    type: 'prompt';
+    success: boolean;
+    stderr?: string;
+    sessionId?: string;
+    duration: number;
+} | {
+    type: 'webhook';
+    success: boolean;
+    url: string;
+    statusCode: number;
+    error?: string;
+    duration: number;
+};
+interface TestAutomationResult {
+    actions: TestAutomationActionResult[];
+}
+type WindowCloseRequestSource = 'keyboard-shortcut' | 'window-button' | 'unknown';
+interface WindowCloseRequest {
+    source: WindowCloseRequestSource;
+}
+interface BrowserInstanceInfo {
+    id: string;
+    url: string;
+    title: string;
+    favicon: string | null;
+    isLoading: boolean;
+    canGoBack: boolean;
+    canGoForward: boolean;
+    boundSessionId: string | null;
+    ownerType: 'session' | 'manual';
+    ownerSessionId: string | null;
+    isVisible: boolean;
+    agentControlActive: boolean;
+    themeColor: string | null;
+}
+interface DeepLinkNavigation {
+    view?: string;
+    tabType?: string;
+    tabParams?: Record<string, string>;
+    action?: string;
+    actionParams?: Record<string, string>;
+}
+
+/**
+ * RPC channel names — organized by domain namespace.
+ * Wire-format strings (values) are the stable API contract.
+ * Key paths are internal and may be reorganized freely.
+ */
+declare const RPC_CHANNELS: {
+    readonly remote: {
+        readonly TEST_CONNECTION: "remote:testConnection";
+    };
+    readonly server: {
+        readonly GET_WORKSPACES: "server:getWorkspaces";
+        readonly CREATE_WORKSPACE: "server:createWorkspace";
+        readonly GET_STATUS: "server:getStatus";
+        readonly GET_HEALTH: "server:getHealth";
+        readonly GET_ACTIVE_SESSIONS: "server:getActiveSessions";
+        readonly SHUTTING_DOWN: "server:shuttingDown";
+        readonly STATUS_CHANGED: "server:statusChanged";
+        readonly HOME_DIR: "server:homeDir";
+    };
+    readonly sessions: {
+        readonly GET: "sessions:get";
+        readonly GET_UNREAD_SUMMARY: "sessions:getUnreadSummary";
+        readonly MARK_ALL_READ: "sessions:markAllRead";
+        readonly UNREAD_SUMMARY_CHANGED: "sessions:unreadSummaryChanged";
+        readonly CREATE: "sessions:create";
+        readonly DELETE: "sessions:delete";
+        readonly GET_MESSAGES: "sessions:getMessages";
+        readonly SEND_MESSAGE: "sessions:sendMessage";
+        readonly CANCEL: "sessions:cancel";
+        readonly KILL_SHELL: "sessions:killShell";
+        readonly RESPOND_TO_PERMISSION: "sessions:respondToPermission";
+        readonly RESPOND_TO_CREDENTIAL: "sessions:respondToCredential";
+        readonly COMMAND: "sessions:command";
+        readonly GET_PENDING_PLAN_EXECUTION: "sessions:getPendingPlanExecution";
+        readonly GET_PERMISSION_MODE_STATE: "sessions:getPermissionModeState";
+        readonly EVENT: "session:event";
+        readonly GET_MODEL: "session:getModel";
+        readonly SET_MODEL: "session:setModel";
+        readonly GET_FILES: "sessions:getFiles";
+        readonly GET_NOTES: "sessions:getNotes";
+        readonly SET_NOTES: "sessions:setNotes";
+        readonly WATCH_FILES: "sessions:watchFiles";
+        readonly UNWATCH_FILES: "sessions:unwatchFiles";
+        readonly FILES_CHANGED: "sessions:filesChanged";
+        readonly SEARCH_CONTENT: "sessions:searchContent";
+        readonly EXPORT: "sessions:export";
+        readonly IMPORT: "sessions:import";
+        readonly EXPORT_REMOTE_TRANSFER: "sessions:exportRemoteTransfer";
+        readonly IMPORT_REMOTE_TRANSFER: "sessions:importRemoteTransfer";
+    };
+    readonly transfer: {
+        readonly START: "transfer:start";
+        readonly CHUNK: "transfer:chunk";
+        readonly COMMIT: "transfer:commit";
+        readonly ABORT: "transfer:abort";
+    };
+    readonly tasks: {
+        readonly GET_OUTPUT: "tasks:getOutput";
+    };
+    readonly workspaces: {
+        readonly GET: "workspaces:get";
+        readonly CREATE: "workspaces:create";
+        readonly CHECK_SLUG: "workspaces:checkSlug";
+        readonly UPDATE_REMOTE: "workspaces:updateRemote";
+    };
+    readonly window: {
+        readonly GET_WORKSPACE: "window:getWorkspace";
+        readonly GET_MODE: "window:getMode";
+        readonly OPEN_WORKSPACE: "window:openWorkspace";
+        readonly OPEN_SESSION_IN_NEW_WINDOW: "window:openSessionInNewWindow";
+        readonly SWITCH_WORKSPACE: "window:switchWorkspace";
+        readonly CLOSE: "window:close";
+        readonly CLOSE_REQUESTED: "window:closeRequested";
+        readonly CONFIRM_CLOSE: "window:confirmClose";
+        readonly CANCEL_CLOSE: "window:cancelClose";
+        readonly SET_TRAFFIC_LIGHTS: "window:setTrafficLights";
+        readonly FOCUS_STATE: "window:focusState";
+        readonly GET_FOCUS_STATE: "window:getFocusState";
+    };
+    readonly file: {
+        readonly READ: "file:read";
+        readonly READ_DATA_URL: "file:readDataUrl";
+        readonly READ_PREVIEW_DATA_URL: "file:readPreviewDataUrl";
+        readonly READ_BINARY: "file:readBinary";
+        readonly OPEN_DIALOG: "file:openDialog";
+        readonly READ_ATTACHMENT: "file:readAttachment";
+        readonly READ_USER_ATTACHMENT: "file:readUserAttachment";
+        readonly STORE_ATTACHMENT: "file:storeAttachment";
+        readonly GENERATE_THUMBNAIL: "file:generateThumbnail";
+    };
+    readonly fs: {
+        readonly SEARCH: "fs:search";
+        readonly LIST_DIRECTORY: "fs:listDirectory";
+    };
+    readonly debug: {
+        readonly LOG: "debug:log";
+    };
+    readonly theme: {
+        readonly GET_SYSTEM_PREFERENCE: "theme:getSystemPreference";
+        readonly SYSTEM_CHANGED: "theme:systemChanged";
+        readonly APP_CHANGED: "theme:appChanged";
+        readonly GET_APP: "theme:getApp";
+        readonly GET_PRESETS: "theme:getPresets";
+        readonly LOAD_PRESET: "theme:loadPreset";
+        readonly GET_COLOR_THEME: "theme:getColorTheme";
+        readonly SET_COLOR_THEME: "theme:setColorTheme";
+        readonly BROADCAST_PREFERENCES: "theme:broadcastPreferences";
+        readonly PREFERENCES_CHANGED: "theme:preferencesChanged";
+        readonly GET_WORKSPACE_COLOR_THEME: "theme:getWorkspaceColorTheme";
+        readonly SET_WORKSPACE_COLOR_THEME: "theme:setWorkspaceColorTheme";
+        readonly GET_ALL_WORKSPACE_THEMES: "theme:getAllWorkspaceThemes";
+        readonly BROADCAST_WORKSPACE_THEME: "theme:broadcastWorkspaceTheme";
+        readonly WORKSPACE_THEME_CHANGED: "theme:workspaceThemeChanged";
+    };
+    readonly system: {
+        readonly VERSIONS: "system:versions";
+        readonly HOME_DIR: "system:homeDir";
+        readonly IS_DEBUG_MODE: "system:isDebugMode";
+    };
+    readonly update: {
+        readonly CHECK: "update:check";
+        readonly GET_INFO: "update:getInfo";
+        readonly INSTALL: "update:install";
+        readonly DISMISS: "update:dismiss";
+        readonly GET_DISMISSED: "update:getDismissed";
+        readonly AVAILABLE: "update:available";
+        readonly DOWNLOAD_PROGRESS: "update:downloadProgress";
+    };
+    readonly shell: {
+        readonly OPEN_URL: "shell:openUrl";
+        readonly OPEN_FILE: "shell:openFile";
+        readonly SHOW_IN_FOLDER: "shell:showInFolder";
+    };
+    readonly menu: {
+        readonly NEW_CHAT: "menu:newChat";
+        readonly NEW_WINDOW: "menu:newWindow";
+        readonly OPEN_SETTINGS: "menu:openSettings";
+        readonly KEYBOARD_SHORTCUTS: "menu:keyboardShortcuts";
+        readonly TOGGLE_FOCUS_MODE: "menu:toggleFocusMode";
+        readonly TOGGLE_SIDEBAR: "menu:toggleSidebar";
+        readonly QUIT: "menu:quit";
+        readonly MINIMIZE: "menu:minimize";
+        readonly MAXIMIZE: "menu:maximize";
+        readonly ZOOM_IN: "menu:zoomIn";
+        readonly ZOOM_OUT: "menu:zoomOut";
+        readonly ZOOM_RESET: "menu:zoomReset";
+        readonly TOGGLE_DEV_TOOLS: "menu:toggleDevTools";
+        readonly UNDO: "menu:undo";
+        readonly REDO: "menu:redo";
+        readonly CUT: "menu:cut";
+        readonly COPY: "menu:copy";
+        readonly PASTE: "menu:paste";
+        readonly SELECT_ALL: "menu:selectAll";
+    };
+    readonly deeplink: {
+        readonly NAVIGATE: "deeplink:navigate";
+    };
+    readonly auth: {
+        readonly LOGOUT: "auth:logout";
+        readonly SHOW_LOGOUT_CONFIRMATION: "auth:showLogoutConfirmation";
+        readonly SHOW_DELETE_SESSION_CONFIRMATION: "auth:showDeleteSessionConfirmation";
+    };
+    readonly credentials: {
+        readonly HEALTH_CHECK: "credentials:healthCheck";
+    };
+    readonly onboarding: {
+        readonly GET_AUTH_STATE: "onboarding:getAuthState";
+        readonly VALIDATE_MCP: "onboarding:validateMcp";
+        readonly START_MCP_OAUTH: "onboarding:startMcpOAuth";
+        readonly START_CLAUDE_OAUTH: "onboarding:startClaudeOAuth";
+        readonly EXCHANGE_CLAUDE_CODE: "onboarding:exchangeClaudeCode";
+        readonly HAS_CLAUDE_OAUTH_STATE: "onboarding:hasClaudeOAuthState";
+        readonly CLEAR_CLAUDE_OAUTH_STATE: "onboarding:clearClaudeOAuthState";
+        readonly DEFER_SETUP: "onboarding:deferSetup";
+    };
+    readonly llmConnections: {
+        readonly LIST: "LLM_Connection:list";
+        readonly LIST_WITH_STATUS: "LLM_Connection:listWithStatus";
+        readonly GET: "LLM_Connection:get";
+        readonly GET_API_KEY: "LLM_Connection:getApiKey";
+        readonly SAVE: "LLM_Connection:save";
+        readonly DELETE: "LLM_Connection:delete";
+        readonly TEST: "LLM_Connection:test";
+        readonly SET_DEFAULT: "LLM_Connection:setDefault";
+        readonly SET_WORKSPACE_DEFAULT: "LLM_Connection:setWorkspaceDefault";
+        readonly REFRESH_MODELS: "LLM_Connection:refreshModels";
+        readonly CHANGED: "LLM_Connection:changed";
+    };
+    readonly chatgpt: {
+        readonly START_OAUTH: "chatgpt:startOAuth";
+        readonly COMPLETE_OAUTH: "chatgpt:completeOAuth";
+        readonly CANCEL_OAUTH: "chatgpt:cancelOAuth";
+        readonly GET_AUTH_STATUS: "chatgpt:getAuthStatus";
+        readonly LOGOUT: "chatgpt:logout";
+    };
+    readonly copilot: {
+        readonly START_OAUTH: "copilot:startOAuth";
+        readonly CANCEL_OAUTH: "copilot:cancelOAuth";
+        readonly GET_AUTH_STATUS: "copilot:getAuthStatus";
+        readonly LOGOUT: "copilot:logout";
+        readonly DEVICE_CODE: "copilot:deviceCode";
+    };
+    readonly settings: {
+        readonly SETUP_LLM_CONNECTION: "settings:setupLlmConnection";
+        readonly TEST_LLM_CONNECTION_SETUP: "settings:testLlmConnectionSetup";
+        readonly GET_DEFAULT_THINKING_LEVEL: "settings:getDefaultThinkingLevel";
+        readonly SET_DEFAULT_THINKING_LEVEL: "settings:setDefaultThinkingLevel";
+        readonly GET_NETWORK_PROXY: "settings:getNetworkProxy";
+        readonly SET_NETWORK_PROXY: "settings:setNetworkProxy";
+        readonly GET_SERVER_CONFIG: "settings:getServerConfig";
+        readonly SET_SERVER_CONFIG: "settings:setServerConfig";
+        readonly GET_SERVER_STATUS: "settings:getServerStatus";
+    };
+    readonly pi: {
+        readonly GET_API_KEY_PROVIDERS: "pi:getApiKeyProviders";
+        readonly GET_PROVIDER_BASE_URL: "pi:getProviderBaseUrl";
+        readonly GET_PROVIDER_MODELS: "pi:getProviderModels";
+    };
+    readonly dialog: {
+        readonly OPEN_FOLDER: "dialog:openFolder";
+    };
+    readonly preferences: {
+        readonly READ: "preferences:read";
+        readonly WRITE: "preferences:write";
+    };
+    readonly drafts: {
+        readonly GET: "drafts:get";
+        readonly SET: "drafts:set";
+        readonly DELETE: "drafts:delete";
+        readonly GET_ALL: "drafts:getAll";
+    };
+    readonly sources: {
+        readonly GET: "sources:get";
+        readonly CREATE: "sources:create";
+        readonly DELETE: "sources:delete";
+        readonly START_OAUTH: "sources:startOAuth";
+        readonly SAVE_CREDENTIALS: "sources:saveCredentials";
+        readonly CHANGED: "sources:changed";
+        readonly GET_PERMISSIONS: "sources:getPermissions";
+        readonly GET_MCP_TOOLS: "sources:getMcpTools";
+    };
+    readonly oauth: {
+        readonly START: "oauth:start";
+        readonly COMPLETE: "oauth:complete";
+        readonly CANCEL: "oauth:cancel";
+        readonly REVOKE: "oauth:revoke";
+    };
+    readonly workspace: {
+        readonly GET_PERMISSIONS: "workspace:getPermissions";
+        readonly READ_IMAGE: "workspace:readImage";
+        readonly WRITE_IMAGE: "workspace:writeImage";
+        readonly SETTINGS_GET: "workspaceSettings:get";
+        readonly SETTINGS_UPDATE: "workspaceSettings:update";
+    };
+    readonly permissions: {
+        readonly GET_DEFAULTS: "permissions:getDefaults";
+        readonly DEFAULTS_CHANGED: "permissions:defaultsChanged";
+    };
+    readonly skills: {
+        readonly GET: "skills:get";
+        readonly GET_FILES: "skills:getFiles";
+        readonly DELETE: "skills:delete";
+        readonly OPEN_EDITOR: "skills:openEditor";
+        readonly OPEN_FINDER: "skills:openFinder";
+        readonly CHANGED: "skills:changed";
+    };
+    readonly statuses: {
+        readonly LIST: "statuses:list";
+        readonly REORDER: "statuses:reorder";
+        readonly CHANGED: "statuses:changed";
+    };
+    readonly labels: {
+        readonly LIST: "labels:list";
+        readonly CREATE: "labels:create";
+        readonly DELETE: "labels:delete";
+        readonly CHANGED: "labels:changed";
+    };
+    readonly views: {
+        readonly LIST: "views:list";
+        readonly SAVE: "views:save";
+    };
+    readonly toolIcons: {
+        readonly GET_MAPPINGS: "toolIcons:getMappings";
+    };
+    readonly logo: {
+        readonly GET_URL: "logo:getUrl";
+    };
+    readonly notification: {
+        readonly SHOW: "notification:show";
+        readonly NAVIGATE: "notification:navigate";
+        readonly GET_ENABLED: "notification:getEnabled";
+        readonly SET_ENABLED: "notification:setEnabled";
+    };
+    readonly input: {
+        readonly GET_AUTO_CAPITALISATION: "input:getAutoCapitalisation";
+        readonly SET_AUTO_CAPITALISATION: "input:setAutoCapitalisation";
+        readonly GET_SEND_MESSAGE_KEY: "input:getSendMessageKey";
+        readonly SET_SEND_MESSAGE_KEY: "input:setSendMessageKey";
+        readonly GET_SPELL_CHECK: "input:getSpellCheck";
+        readonly SET_SPELL_CHECK: "input:setSpellCheck";
+    };
+    readonly power: {
+        readonly GET_KEEP_AWAKE: "power:getKeepAwake";
+        readonly SET_KEEP_AWAKE: "power:setKeepAwake";
+    };
+    readonly appearance: {
+        readonly GET_RICH_TOOL_DESCRIPTIONS: "appearance:getRichToolDescriptions";
+        readonly SET_RICH_TOOL_DESCRIPTIONS: "appearance:setRichToolDescriptions";
+    };
+    readonly tools: {
+        readonly GET_BROWSER_TOOL_ENABLED: "tools:getBrowserToolEnabled";
+        readonly SET_BROWSER_TOOL_ENABLED: "tools:setBrowserToolEnabled";
+    };
+    readonly caching: {
+        readonly GET_EXTENDED_PROMPT_CACHE: "caching:getExtendedPromptCache";
+        readonly SET_EXTENDED_PROMPT_CACHE: "caching:setExtendedPromptCache";
+        readonly GET_ENABLE_1M_CONTEXT: "caching:getEnable1MContext";
+        readonly SET_ENABLE_1M_CONTEXT: "caching:setEnable1MContext";
+    };
+    readonly badge: {
+        readonly REFRESH: "badge:refresh";
+        readonly SET_ICON: "badge:setIcon";
+        readonly DRAW: "badge:draw";
+        readonly DRAW_WINDOWS: "badge:draw-windows";
+    };
+    readonly releaseNotes: {
+        readonly GET: "releaseNotes:get";
+        readonly GET_LATEST_VERSION: "releaseNotes:getLatestVersion";
+    };
+    readonly git: {
+        readonly GET_BRANCH: "git:getBranch";
+    };
+    readonly gitbash: {
+        readonly CHECK: "gitbash:check";
+        readonly BROWSE: "gitbash:browse";
+        readonly SET_PATH: "gitbash:setPath";
+    };
+    readonly browserPane: {
+        readonly CREATE: "browser-pane:create";
+        readonly DESTROY: "browser-pane:destroy";
+        readonly LIST: "browser-pane:list";
+        readonly NAVIGATE: "browser-pane:navigate";
+        readonly GO_BACK: "browser-pane:go-back";
+        readonly GO_FORWARD: "browser-pane:go-forward";
+        readonly RELOAD: "browser-pane:reload";
+        readonly STOP: "browser-pane:stop";
+        readonly FOCUS: "browser-pane:focus";
+        readonly SNAPSHOT: "browser-pane:snapshot";
+        readonly CLICK: "browser-pane:click";
+        readonly FILL: "browser-pane:fill";
+        readonly SELECT: "browser-pane:select";
+        readonly SCREENSHOT: "browser-pane:screenshot";
+        readonly EVALUATE: "browser-pane:evaluate";
+        readonly SCROLL: "browser-pane:scroll";
+        readonly LAUNCH: "browser-empty-state:launch";
+        readonly STATE_CHANGED: "browser-pane:state-changed";
+        readonly REMOVED: "browser-pane:removed";
+        readonly INTERACTED: "browser-pane:interacted";
+    };
+    readonly automations: {
+        readonly GET: "automations:get";
+        readonly TEST: "automations:test";
+        readonly SET_ENABLED: "automations:setEnabled";
+        readonly DUPLICATE: "automations:duplicate";
+        readonly DELETE: "automations:delete";
+        readonly GET_HISTORY: "automations:getHistory";
+        readonly GET_LAST_EXECUTED: "automations:getLastExecuted";
+        readonly REPLAY: "automations:replay";
+        readonly CHANGED: "automations:changed";
+    };
+    readonly resources: {
+        readonly EXPORT: "resources:export";
+        readonly IMPORT: "resources:import";
+    };
+    readonly messaging: {
+        readonly WA_REGISTER: "messaging:wa:register";
+        readonly WA_INCOMING: "messaging:wa:incoming";
+        readonly WA_BUTTON_PRESS: "messaging:wa:buttonPress";
+        readonly WA_STATUS: "messaging:wa:status";
+        readonly WA_QR: "messaging:wa:qr";
+        readonly WA_SEND: "messaging:wa:send";
+        readonly WA_SEND_BUTTONS: "messaging:wa:sendButtons";
+        readonly WA_SEND_TYPING: "messaging:wa:sendTyping";
+        readonly WA_SEND_FILE: "messaging:wa:sendFile";
+        readonly WA_CONNECT: "messaging:wa:connect";
+        readonly WA_DISCONNECT: "messaging:wa:disconnect";
+        readonly BINDING_CHANGED: "messaging:bindingChanged";
+        readonly PLATFORM_STATUS: "messaging:platformStatus";
+        /** Broadcast when the workspace's pending-senders list mutates. */
+        readonly PENDING_CHANGED: "messaging:pendingChanged";
+        readonly GET_CONFIG: "messaging:getConfig";
+        readonly UPDATE_CONFIG: "messaging:updateConfig";
+        readonly TEST_TELEGRAM: "messaging:testTelegram";
+        readonly SAVE_TELEGRAM: "messaging:saveTelegram";
+        readonly TEST_LARK: "messaging:testLark";
+        readonly SAVE_LARK: "messaging:saveLark";
+        readonly DISCONNECT: "messaging:disconnect";
+        readonly FORGET: "messaging:forget";
+        readonly GET_BINDINGS: "messaging:getBindings";
+        readonly GENERATE_CODE: "messaging:generateCode";
+        readonly UNBIND: "messaging:unbind";
+        readonly UNBIND_BINDING: "messaging:unbindBinding";
+        /** Workspace-supergroup pairing (Telegram forum support). UI ↔ Server. */
+        readonly GENERATE_SUPERGROUP_CODE: "messaging:generateSupergroupCode";
+        readonly GET_SUPERGROUP: "messaging:getSupergroup";
+        readonly UNBIND_SUPERGROUP: "messaging:unbindSupergroup";
+        readonly WA_START_CONNECT: "messaging:wa:startConnect";
+        readonly WA_SUBMIT_PHONE: "messaging:wa:submitPhone";
+        /** Broadcast to UI clients: QR string, pairing code, status, unavailable, error. */
+        readonly WA_UI_EVENT: "messaging:wa:uiEvent";
+        readonly GET_PLATFORM_OWNERS: "messaging:access:getOwners";
+        readonly SET_PLATFORM_OWNERS: "messaging:access:setOwners";
+        readonly GET_PLATFORM_ACCESS_MODE: "messaging:access:getMode";
+        readonly SET_PLATFORM_ACCESS_MODE: "messaging:access:setMode";
+        readonly GET_PENDING_SENDERS: "messaging:access:getPending";
+        readonly DISMISS_PENDING_SENDER: "messaging:access:dismissPending";
+        readonly ALLOW_PENDING_SENDER: "messaging:access:allowPending";
+        readonly SET_BINDING_ACCESS: "messaging:access:setBindingAccess";
+    };
+};
+
+/**
+ * Typed event map for server → client push channels.
+ * Keys are channel string literals, values are argument tuples.
+ */
+
+interface BroadcastEventMap {
+    [RPC_CHANNELS.sessions.EVENT]: [event: SessionEvent];
+    [RPC_CHANNELS.sessions.UNREAD_SUMMARY_CHANGED]: [summary: UnreadSummary];
+    [RPC_CHANNELS.sessions.FILES_CHANGED]: [sessionId: string];
+    [RPC_CHANNELS.sources.CHANGED]: [workspaceId: string, sources: unknown[]];
+    [RPC_CHANNELS.labels.CHANGED]: [workspaceId: string];
+    [RPC_CHANNELS.statuses.CHANGED]: [workspaceId: string];
+    [RPC_CHANNELS.automations.CHANGED]: [workspaceId: string];
+    [RPC_CHANNELS.skills.CHANGED]: [workspaceId: string, skills: unknown[]];
+    [RPC_CHANNELS.llmConnections.CHANGED]: [];
+    [RPC_CHANNELS.permissions.DEFAULTS_CHANGED]: [value: null];
+    [RPC_CHANNELS.theme.APP_CHANGED]: [theme: Record<string, unknown> | null];
+    [RPC_CHANNELS.theme.SYSTEM_CHANGED]: [isDark: boolean];
+    [RPC_CHANNELS.theme.PREFERENCES_CHANGED]: [preferences: {
+        mode: string;
+        colorTheme: string;
+        font: string;
+    }];
+    [RPC_CHANNELS.theme.WORKSPACE_THEME_CHANGED]: [data: {
+        workspaceId: string;
+        themeId: string | null;
+    }];
+    [RPC_CHANNELS.update.AVAILABLE]: [info: UpdateInfo];
+    [RPC_CHANNELS.update.DOWNLOAD_PROGRESS]: [progress: number];
+    [RPC_CHANNELS.badge.DRAW]: [data: {
+        count: number;
+        iconDataUrl: string;
+    }];
+    [RPC_CHANNELS.badge.DRAW_WINDOWS]: [data: {
+        count: number;
+    }];
+    [RPC_CHANNELS.window.FOCUS_STATE]: [isFocused: boolean];
+    [RPC_CHANNELS.window.CLOSE_REQUESTED]: [];
+    [RPC_CHANNELS.browserPane.STATE_CHANGED]: [info: BrowserInstanceInfo];
+    [RPC_CHANNELS.browserPane.REMOVED]: [id: string];
+    [RPC_CHANNELS.browserPane.INTERACTED]: [id: string];
+    [RPC_CHANNELS.notification.NAVIGATE]: [data: {
+        workspaceId: string;
+        sessionId: string;
+    }];
+    [RPC_CHANNELS.deeplink.NAVIGATE]: [navigation: DeepLinkNavigation];
+    [RPC_CHANNELS.copilot.DEVICE_CODE]: [data: {
+        userCode: string;
+        verificationUri: string;
+    }];
+    [RPC_CHANNELS.menu.NEW_CHAT]: [];
+    [RPC_CHANNELS.menu.OPEN_SETTINGS]: [];
+    [RPC_CHANNELS.menu.KEYBOARD_SHORTCUTS]: [];
+    [RPC_CHANNELS.menu.TOGGLE_FOCUS_MODE]: [];
+    [RPC_CHANNELS.menu.TOGGLE_SIDEBAR]: [];
+    [RPC_CHANNELS.messaging.BINDING_CHANGED]: [workspaceId: string];
+    [RPC_CHANNELS.messaging.PLATFORM_STATUS]: [workspaceId: string, platform: string, connected: boolean];
+}
+
+interface ParsedMentions {
+    skills: string[];
+    invalidSkills: string[];
+    sources: string[];
+    files: string[];
+    folders: string[];
+}
+interface MentionMatch {
+    type: 'skill' | 'source' | 'file' | 'folder';
+    id: string;
+    fullMatch: string;
+    startIndex: number;
+}
+
+declare function parseMentions(text: string, availableSkillSlugs: string[], availableSourceSlugs: string[]): ParsedMentions;
+declare function resolveSkillMentions(text: string, skillNames: Map<string, string>): string;
+declare function resolveSourceMentions(text: string): string;
+declare function resolvePathMentions(text: string, workingDirectory?: string): Promise<string>;
+declare function resolveFileMentions(text: string, workingDirectory?: string): Promise<string>;
+declare function stripAllMentions(text: string): string;
+declare function findMentionMatches(text: string, availableSkillSlugs: string[], availableSourceSlugs: string[]): MentionMatch[];
+
+export { AnnotationV1, type AuthRequest, AuthRequestType, type BroadcastEventMap, type BrowserInstanceInfo, type BuiltInStatusId, type ClaudeOAuthResult, ContentBadge, type CreateSessionOptions, CredentialInputMode, type CredentialRequest, type CredentialResponse, type DeepLinkNavigation, type DirectoryListingResult, type FileAttachment, type FileSearchResult, type GitBashStatus, type ImportRemoteSessionTransferResult, type LlmConnectionSetup, type McpToolWithPermission, type McpToolsResult, type McpValidationResult, type MentionMatch, Message, type NewChatActionParams, type OAuthResult, type ParsedMentions, type PermissionMode, type PermissionModeCanonical, type PermissionModeState, PermissionRequest$1 as PermissionRequest, type PermissionResponseOptions, type Plan, type PlanStep, type Session as ProtocolSession, RPC_CHANNELS, type RefreshTitleResult, type RemoteSessionTransferPayload, type SendMessageOptions, type SessionCommand, type SessionEvent, type SessionFile, type PermissionRequest as SessionPermissionRequest, type SessionSearchMatch, type SessionSearchResult, type ShareResult, type SkillFile, THINKING_LEVELS, THINKING_LEVEL_IDS, THINKING_TO_EFFORT, type TestAutomationAction, type TestAutomationActionResult, type TestAutomationPayload, type TestAutomationResult, type TestLlmConnectionParams, type TestLlmConnectionResult, type ThinkingLevel, ToolDisplayMeta, TypedError, type UnreadSummary, type UpdateInfo, type WindowCloseRequest, type WindowCloseRequestSource, type WorkspaceSettings, findMentionMatches, getThinkingLevelNameKey, getThinkingTokens, isValidThinkingLevel, normalizeThinkingLevel, parseMentions, resolveFileMentions, resolvePathMentions, resolveSkillMentions, resolveSourceMentions, stripAllMentions };
+
+// -- @weft/core/types/index.d.ts --
+/**
+ * Workspace and authentication types
+ */
+/**
+ * How MCP server should be authenticated (workspace-level)
+ * Note: Different from SourceMcpAuthType which uses 'oauth' | 'bearer' | 'none' for individual sources
+ */
+type McpAuthType = 'workspace_oauth' | 'workspace_bearer' | 'public';
+/**
+ * Configuration for a remote Agent Server.
+ * When set on a workspace, handler calls are proxied over WebSocket.
+ */
+interface RemoteServerConfig {
+    url: string;
+    token: string;
+    remoteWorkspaceId: string;
+}
+/**
+ * Client-facing workspace DTO — safe to send over RPC to remote clients.
+ * Does not expose server-internal filesystem paths.
+ */
+interface WorkspaceInfo {
+    id: string;
+    name: string;
+    slug: string;
+    lastAccessedAt?: number;
+    iconUrl?: string;
+    mcpUrl?: string;
+    mcpAuthType?: McpAuthType;
+    remoteServer?: RemoteServerConfig;
+}
+/**
+ * Full workspace with server-internal details.
+ * Used by server code and local Electron renderer (LOCAL_ONLY channels).
+ */
+interface Workspace extends WorkspaceInfo {
+    rootPath: string;
+    createdAt: number;
+}
+/**
+ * Authentication type for AI provider
+ * - api_key: Anthropic API key
+ * - oauth_token: Claude Max OAuth (Anthropic)
+ * - codex_oauth: ChatGPT Plus OAuth via Codex app-server
+ * - codex_api_key: OpenAI API key via Codex (OpenRouter, Vercel AI Gateway compatible)
+ * - provider_owned: Auth is owned by the provider tool itself
+ *   (Claude Code uses `~/.claude`, Codex uses `~/.codex`).
+ *   Weft never injects credentials — it detects and delegates.
+ */
+type AuthType = 'api_key' | 'oauth_token' | 'codex_oauth' | 'codex_api_key' | 'provider_owned';
+/**
+ * OAuth credentials from a fresh authentication flow.
+ * Used for temporary state in UI components before saving to credential store.
+ */
+interface OAuthCredentials {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    clientId: string;
+    tokenType: string;
+}
+interface StoredConfig {
+    authType?: AuthType;
+    workspaces: Workspace[];
+    activeWorkspaceId: string | null;
+    activeSessionId: string | null;
+    model?: string;
+}
+
+/**
+ * Message types for conversations
+ */
+/**
+ * Message roles for display (runtime)
+ */
+type MessageRole = 'user' | 'assistant' | 'tool' | 'error' | 'status' | 'info' | 'warning' | 'plan' | 'auth-request';
+/**
+ * Credential input modes for different auth types
+ */
+type CredentialInputMode = 'bearer' | 'basic' | 'header' | 'query' | 'multi-header';
+/**
+ * Auth request types
+ */
+type AuthRequestType = 'credential' | 'oauth' | 'oauth-google' | 'oauth-slack' | 'oauth-microsoft';
+/**
+ * Auth request status
+ */
+type AuthStatus = 'pending' | 'completed' | 'cancelled' | 'failed';
+/**
+ * Tool execution status
+ */
+type ToolStatus = 'pending' | 'executing' | 'completed' | 'error' | 'backgrounded';
+/**
+ * Tool display metadata - embedded at storage time for viewer compatibility
+ * Icons are base64-encoded to work in both Electron and web viewer
+ */
+interface ToolDisplayMeta {
+    /** Display name for the tool (e.g., "Commit", "Linear") */
+    displayName: string;
+    /** Base64-encoded icon as data URL (e.g., "data:image/png;base64,...") - 32x32px */
+    iconDataUrl?: string;
+    /** Description of what this tool does */
+    description?: string;
+    /** Category for grouping/styling */
+    category?: 'skill' | 'source' | 'native' | 'mcp';
+}
+/**
+ * Attachment type categories
+ */
+type AttachmentType = 'image' | 'text' | 'pdf' | 'office' | 'audio' | 'unknown';
+/**
+ * Attachment preview for display in user messages (runtime, before storage)
+ */
+interface MessageAttachment {
+    type: AttachmentType;
+    name: string;
+    mimeType: string;
+    size: number;
+    base64?: string;
+}
+/**
+ * Content badge for inline display in user messages
+ * Badges are self-contained with all display data (label, icon)
+ */
+interface ContentBadge {
+    /** Badge type - used for fallback icon if iconBase64 not available */
+    type: 'source' | 'skill' | 'context' | 'command' | 'file' | 'folder';
+    /** Display label (e.g., "Linear", "Commit") */
+    label: string;
+    /** Original text pattern (e.g., "@linear", "@commit") */
+    rawText: string;
+    /** Icon as data URL (e.g., "data:image/png;base64,...") - preserves mime type */
+    iconDataUrl?: string;
+    /** Start position in content string */
+    start: number;
+    /** End position in content string */
+    end: number;
+    /**
+     * Collapsed label for context badges (e.g., "Edit: Permissions")
+     * When set, the badge replaces the entire marked range with this label
+     * and hides the original content
+     */
+    collapsedLabel?: string;
+    /**
+     * File path for file badges - stores the full path for click handler
+     * Used when the badge represents a clickable file reference
+     */
+    filePath?: string;
+}
+/**
+ * Author metadata for annotations
+ */
+interface AnnotationAuthor {
+    id: string;
+    name?: string;
+    type?: 'user' | 'agent' | 'system';
+}
+/**
+ * Annotation body payloads (extensible)
+ */
+type AnnotationBody = {
+    type: 'highlight';
+} | {
+    type: 'note';
+    text: string;
+    format?: 'plain' | 'markdown';
+} | {
+    type: 'tag';
+    value: string;
+};
+/**
+ * Annotation intent (tight v1 semantics).
+ */
+type AnnotationIntent = 'highlight' | 'comment' | 'question';
+/**
+ * Optional lifecycle status for annotation workflows.
+ */
+type AnnotationStatus = 'pending' | 'acknowledged' | 'resolved' | 'dismissed';
+/**
+ * Block types for block selectors.
+ */
+type AnnotationBlockType = 'paragraph' | 'code' | 'latex' | 'mermaid' | 'datatable' | 'spreadsheet' | 'image-preview' | 'pdf-preview' | 'html-preview';
+/**
+ * Selector union used to anchor an annotation target.
+ * Multiple selectors can be stored for robust fallback resolution.
+ */
+type AnnotationSelector = {
+    type: 'text-quote';
+    exact: string;
+    prefix?: string;
+    suffix?: string;
+} | {
+    type: 'text-position';
+    start: number;
+    end: number;
+    textVersion?: string;
+} | {
+    type: 'block';
+    blockType: AnnotationBlockType;
+    path: string;
+    blockId?: string;
+} | {
+    type: 'xywh';
+    unit: 'pixel' | 'percent';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    page?: number;
+    rotation?: number;
+} | {
+    type: 'table-cell';
+    rowKey: string | number;
+    columnKey: string;
+};
+/**
+ * Annotation target definition.
+ */
+interface AnnotationTarget {
+    source: {
+        sessionId: string;
+        messageId: string;
+    };
+    selectors: AnnotationSelector[];
+}
+/**
+ * Persisted annotation payload (schema-versioned for migration safety).
+ */
+interface AnnotationV1 {
+    id: string;
+    schemaVersion: 1;
+    createdAt: number;
+    updatedAt?: number;
+    createdBy?: AnnotationAuthor;
+    deletedAt?: number;
+    body: AnnotationBody[];
+    target: AnnotationTarget;
+    /** Optional workflow intent (tight v1 semantics). */
+    intent?: AnnotationIntent;
+    /** Optional lifecycle status. */
+    status?: AnnotationStatus;
+    /** Optional reference to the conversation/thread around this annotation. */
+    threadRef?: {
+        threadId?: string;
+        sessionId?: string;
+    };
+    style?: {
+        color?: 'yellow' | 'green' | 'blue' | 'pink' | string;
+        opacity?: number;
+    };
+    meta?: Record<string, unknown>;
+}
+/**
+ * Stored attachment metadata (persisted to disk, no base64)
+ * Created when user sends a message with attachments
+ */
+interface StoredAttachment {
+    id: string;
+    type: AttachmentType;
+    name: string;
+    mimeType: string;
+    size: number;
+    originalSize?: number;
+    storedPath: string;
+    thumbnailPath?: string;
+    thumbnailBase64?: string;
+    markdownPath?: string;
+    wasResized?: boolean;
+    resizedBase64?: string;
+}
+/**
+ * Runtime message type (includes transient fields like isStreaming)
+ */
+interface Message {
+    id: string;
+    role: MessageRole;
+    content: string;
+    timestamp: number;
+    toolName?: string;
+    toolUseId?: string;
+    toolInput?: Record<string, unknown>;
+    toolResult?: string;
+    toolStatus?: ToolStatus;
+    toolDuration?: number;
+    toolIntent?: string;
+    toolDisplayName?: string;
+    /** Tool display metadata with base64 icon - embedded at storage time for viewer */
+    toolDisplayMeta?: ToolDisplayMeta;
+    parentToolUseId?: string;
+    taskId?: string;
+    shellId?: string;
+    elapsedSeconds?: number;
+    isBackground?: boolean;
+    attachments?: StoredAttachment[];
+    badges?: ContentBadge[];
+    /** Annotation payloads for this message */
+    annotations?: AnnotationV1[];
+    isError?: boolean;
+    isStreaming?: boolean;
+    isPending?: boolean;
+    isQueued?: boolean;
+    isIntermediate?: boolean;
+    turnId?: string;
+    statusType?: 'compacting' | 'compaction_complete';
+    infoLevel?: 'info' | 'warning' | 'error' | 'success';
+    errorCode?: string;
+    errorTitle?: string;
+    errorDetails?: string[];
+    errorOriginal?: string;
+    errorCanRetry?: boolean;
+    errorActions?: Array<{
+        key: string;
+        label: string;
+        action?: 'retry' | 'settings' | 'reauth' | 'open_url' | 'reconnect_source';
+        url?: string;
+        sourceSlug?: string;
+    }>;
+    planPath?: string;
+    authRequestId?: string;
+    authRequestType?: AuthRequestType;
+    authSourceSlug?: string;
+    authSourceName?: string;
+    authStatus?: AuthStatus;
+    authCredentialMode?: CredentialInputMode;
+    authHeaderName?: string;
+    authHeaderNames?: string[];
+    authLabels?: {
+        credential?: string;
+        username?: string;
+        password?: string;
+    };
+    authDescription?: string;
+    authHint?: string;
+    authSourceUrl?: string;
+    authPasswordRequired?: boolean;
+    authError?: string;
+    authEmail?: string;
+    authWorkspace?: string;
+}
+/**
+ * Stored message format (persistence)
+ * Excludes transient runtime-only fields (isStreaming, isPending)
+ */
+interface StoredMessage {
+    id: string;
+    type: MessageRole;
+    content: string;
+    timestamp?: number;
+    toolName?: string;
+    toolUseId?: string;
+    toolInput?: Record<string, unknown>;
+    toolResult?: string;
+    toolStatus?: ToolStatus;
+    toolDuration?: number;
+    toolIntent?: string;
+    toolDisplayName?: string;
+    /** Tool display metadata with base64 icon - embedded at storage time for viewer */
+    toolDisplayMeta?: ToolDisplayMeta;
+    parentToolUseId?: string;
+    taskId?: string;
+    shellId?: string;
+    elapsedSeconds?: number;
+    isBackground?: boolean;
+    isError?: boolean;
+    /** Stored attachments for user messages (persisted to disk) */
+    attachments?: StoredAttachment[];
+    /** Content badges for inline display (sources, skills) */
+    badges?: ContentBadge[];
+    /** Annotations persisted at message level */
+    annotations?: AnnotationV1[];
+    isIntermediate?: boolean;
+    turnId?: string;
+    statusType?: 'compacting' | 'compaction_complete';
+    infoLevel?: 'info' | 'warning' | 'error' | 'success';
+    errorCode?: string;
+    errorTitle?: string;
+    errorDetails?: string[];
+    errorOriginal?: string;
+    errorCanRetry?: boolean;
+    errorActions?: Array<{
+        key: string;
+        label: string;
+        action?: 'retry' | 'settings' | 'reauth' | 'open_url' | 'reconnect_source';
+        url?: string;
+        sourceSlug?: string;
+    }>;
+    planPath?: string;
+    authRequestId?: string;
+    authRequestType?: AuthRequestType;
+    authSourceSlug?: string;
+    authSourceName?: string;
+    authStatus?: AuthStatus;
+    authCredentialMode?: CredentialInputMode;
+    authHeaderName?: string;
+    authHeaderNames?: string[];
+    authLabels?: {
+        credential?: string;
+        username?: string;
+        password?: string;
+    };
+    authDescription?: string;
+    authHint?: string;
+    authSourceUrl?: string;
+    authPasswordRequired?: boolean;
+    authError?: string;
+    authEmail?: string;
+    authWorkspace?: string;
+    isQueued?: boolean;
+}
+/**
+ * Token usage tracking
+ */
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    contextTokens: number;
+    costUsd: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+}
+/**
+ * Recovery action for typed errors
+ */
+interface RecoveryAction {
+    /** Keyboard shortcut (single letter) */
+    key: string;
+    /** Description of the action */
+    label: string;
+    /** Slash command to execute (e.g., '/settings') */
+    command?: string;
+    /** Custom action type for special handling */
+    action?: 'retry' | 'settings' | 'reauth' | 'open_url' | 'reconnect_source';
+    /** URL to open (for open_url action) */
+    url?: string;
+    /** Source slug (for reconnect_source action) */
+    sourceSlug?: string;
+}
+/**
+ * Error codes for typed errors - must match AgentError.code in shared/agent/errors.ts
+ */
+type ErrorCode = 'invalid_api_key' | 'invalid_credentials' | 'response_too_large' | 'expired_oauth_token' | 'token_expired' | 'rate_limited' | 'service_error' | 'service_unavailable' | 'network_error' | 'proxy_error' | 'mcp_auth_required' | 'mcp_unreachable' | 'billing_error' | 'model_no_tool_support' | 'invalid_model' | 'data_policy_error' | 'invalid_request' | 'image_too_large' | 'provider_error' | 'queued_message_replay_failed' | 'sdk_binary_missing' | 'sdk_cwd_missing' | 'unknown_error';
+/**
+ * Typed error from agent
+ */
+interface TypedError {
+    /** Error code for programmatic handling */
+    code: ErrorCode;
+    /** User-friendly title */
+    title: string;
+    /** Detailed message explaining what went wrong */
+    message: string;
+    /** Suggested recovery actions */
+    actions: RecoveryAction[];
+    /** Whether auto-retry is possible */
+    canRetry: boolean;
+    /** Retry delay in ms (if canRetry is true) */
+    retryDelayMs?: number;
+    /** Diagnostic check results for debugging */
+    details?: string[];
+    /** Original error message for debugging */
+    originalError?: string;
+}
+/**
+ * Permission request type categories
+ */
+type PermissionRequestType = 'bash' | 'file_write' | 'mcp_mutation' | 'api_mutation' | 'admin_approval';
+/**
+ * Permission request from agent (e.g., bash command approval)
+ */
+interface PermissionRequest {
+    requestId: string;
+    toolName: string;
+    command?: string;
+    description: string;
+    type?: PermissionRequestType;
+    /** Friendly app/package label for admin approval prompts */
+    appName?: string;
+    /** Plain-language reason shown in admin approval prompt */
+    reason?: string;
+    /** Plain-language impact shown in admin approval prompt */
+    impact?: string;
+    /** Whether native OS auth prompt is expected */
+    requiresSystemPrompt?: boolean;
+    /** Optional remember window for this exact command */
+    rememberForMinutes?: number;
+    /** Hash binding for approval integrity checks */
+    commandHash?: string;
+    /** Approval validity window */
+    approvalTtlSeconds?: number;
+}
+/**
+ * Usage data emitted by the agent runtime in 'complete' events
+ * Note: This is a subset of TokenUsage - totalTokens/contextTokens are computed by consumers
+ */
+interface AgentEventUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    costUsd?: number;
+    /** Model's context window size in tokens (from SDK modelUsage) */
+    contextWindow?: number;
+}
+/**
+ * Events emitted by the agent runtime during chat
+ * turnId: Correlation ID from the API's message.id, groups all events in an assistant turn
+ */
+type AgentEvent = {
+    type: 'status';
+    message: string;
+} | {
+    type: 'info';
+    message: string;
+} | {
+    type: 'text_delta';
+    text: string;
+    turnId?: string;
+    parentToolUseId?: string;
+} | {
+    type: 'text_complete';
+    text: string;
+    isIntermediate?: boolean;
+    turnId?: string;
+    parentToolUseId?: string;
+    sdkTurnAnchor?: string;
+} | {
+    type: 'tool_start';
+    toolName: string;
+    toolUseId: string;
+    input: Record<string, unknown>;
+    intent?: string;
+    displayName?: string;
+    turnId?: string;
+    parentToolUseId?: string;
+    toolDisplayMeta?: ToolDisplayMeta;
+} | {
+    type: 'tool_result';
+    toolUseId: string;
+    toolName?: string;
+    result: string;
+    isError: boolean;
+    input?: Record<string, unknown>;
+    turnId?: string;
+    parentToolUseId?: string;
+} | {
+    type: 'permission_request';
+    requestId: string;
+    toolName: string;
+    command?: string;
+    description: string;
+    permissionType?: PermissionRequestType;
+    appName?: string;
+    reason?: string;
+    impact?: string;
+    requiresSystemPrompt?: boolean;
+    rememberForMinutes?: number;
+    commandHash?: string;
+    approvalTtlSeconds?: number;
+} | {
+    type: 'reasoning_delta';
+    text: string;
+    turnId?: string;
+} | {
+    type: 'reasoning';
+    text: string;
+    turnId?: string;
+} | {
+    type: 'permission_response';
+    requestId: string;
+    allowed: boolean;
+    remember?: boolean;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'typed_error';
+    error: TypedError;
+} | {
+    type: 'complete';
+    usage?: AgentEventUsage;
+} | {
+    type: 'working_directory_changed';
+    workingDirectory: string;
+} | {
+    type: 'task_backgrounded';
+    toolUseId: string;
+    taskId: string;
+    intent?: string;
+    turnId?: string;
+} | {
+    type: 'shell_backgrounded';
+    toolUseId: string;
+    shellId: string;
+    intent?: string;
+    command?: string;
+    turnId?: string;
+} | {
+    type: 'task_progress';
+    toolUseId: string;
+    elapsedSeconds: number;
+    turnId?: string;
+} | {
+    type: 'task_completed';
+    taskId: string;
+    status: 'completed' | 'failed' | 'stopped';
+    outputFile?: string;
+    summary?: string;
+    turnId?: string;
+} | {
+    type: 'shell_killed';
+    shellId: string;
+    turnId?: string;
+} | {
+    type: 'source_activated';
+    sourceSlug: string;
+    originalMessage: string;
+} | {
+    type: 'usage_update';
+    usage: Pick<AgentEventUsage, 'inputTokens' | 'contextWindow'>;
+} | {
+    type: 'steer_undelivered';
+    message: string;
+} | {
+    type: 'compaction_started';
+} | {
+    type: 'compaction_boundary';
+    summary?: string;
+};
+/**
+ * Generate a unique message ID
+ */
+declare function generateMessageId(): string;
+
+/**
+ * Session types for conversation management
+ *
+ * Sessions are the primary isolation boundary. Each session maps 1:1
+ * with an agent runtime instance and SDK conversation.
+ */
+
+/**
+ * Session status for workflow tracking
+ * Agents can update this to reflect the current state of the conversation
+ */
+type SessionStatus = 'todo' | 'in_progress' | 'needs_review' | 'done' | 'cancelled';
+/**
+ * Session represents a conversation scope (SDK session = our scope boundary)
+ */
+interface Session {
+    id: string;
+    sdkSessionId?: string;
+    workspaceId: string;
+    name?: string;
+    createdAt: number;
+    lastUsedAt: number;
+    isArchived?: boolean;
+    isFlagged?: boolean;
+    status?: SessionStatus;
+    lastReadMessageId?: string;
+}
+/**
+ * Stored session with conversation data (for persistence)
+ */
+interface StoredSession extends Session {
+    messages: StoredMessage[];
+    tokenUsage: TokenUsage;
+}
+/**
+ * Session metadata for listing (without loading full messages)
+ * Extended with archive status for Inbox/Archive features
+ */
+interface SessionMetadata {
+    id: string;
+    workspaceId: string;
+    name?: string;
+    createdAt: number;
+    lastUsedAt: number;
+    messageCount: number;
+    preview?: string;
+    sdkSessionId?: string;
+    isArchived?: boolean;
+    isFlagged?: boolean;
+    status?: SessionStatus;
+    hidden?: boolean;
+}
+
+/**
+ * Convert runtime Message to StoredMessage for persistence.
+ *
+ * Excludes transient runtime-only fields:
+ * - isStreaming
+ * - isPending
+ */
+declare function messageToStored(msg: Message): StoredMessage;
+/**
+ * Convert StoredMessage to runtime Message.
+ *
+ * Adds a timestamp fallback for legacy messages where timestamp was omitted.
+ */
+declare function storedToMessage(stored: StoredMessage): Message;
+
+/**
+ * Server-level types for headless server operations.
+ *
+ * These types are used by the `server:` RPC namespace for
+ * server status, health checks, active session discovery,
+ * and headless configuration bootstrap.
+ */
+interface ServerStatus {
+    serverId: string;
+    version: string;
+    uptime: number;
+    connectedClients: number;
+    workspaces: {
+        id: string;
+        name: string;
+        slug: string;
+        activeSessions: number;
+        automationCount: number;
+        schedulerRunning: boolean;
+    }[];
+    memory: {
+        heapUsed: number;
+        heapTotal: number;
+        rss: number;
+    };
+}
+interface ServerHealth {
+    status: 'ok' | 'degraded' | 'unhealthy';
+    checks: {
+        name: string;
+        status: 'pass' | 'fail';
+        message?: string;
+    }[];
+}
+/** Session processing state — typed union, not stringly. */
+type SessionProcessingStatus = 'idle' | 'processing' | 'waiting_input' | 'error' | 'completed';
+/** Server-level active session info (cross-workspace, client-safe). */
+interface ActiveSessionInfo {
+    sessionId: string;
+    workspaceId: string;
+    workspaceName: string;
+    title?: string;
+    status: SessionProcessingStatus;
+    triggeredBy?: {
+        automationName: string;
+        timestamp: number;
+    };
+    createdAt: number;
+}
+
+export { type ActiveSessionInfo, type AgentEvent, type AgentEventUsage, type AnnotationAuthor, type AnnotationBlockType, type AnnotationBody, type AnnotationIntent, type AnnotationSelector, type AnnotationStatus, type AnnotationTarget, type AnnotationV1, type AttachmentType, type AuthRequestType, type AuthStatus, type AuthType, type ContentBadge, type CredentialInputMode, type ErrorCode, type McpAuthType, type Message, type MessageAttachment, type MessageRole, type OAuthCredentials, type PermissionRequest, type PermissionRequestType, type RecoveryAction, type RemoteServerConfig, type ServerHealth, type ServerStatus, type Session, type SessionMetadata, type SessionProcessingStatus, type SessionStatus, type StoredAttachment, type StoredConfig, type StoredMessage, type StoredSession, type TokenUsage, type ToolDisplayMeta, type ToolStatus, type TypedError, type Workspace, type WorkspaceInfo, generateMessageId, messageToStored, storedToMessage };
+
+// -- @weft/core/utils/index.d.ts --
+/**
+ * Debug utility for core package
+ *
+ * This is a stub that can be enhanced to support debug logging.
+ * Currently a no-op - use @weft debug utilities for full logging.
+ */
+declare function debug(..._args: any[]): void;
+
+/**
+ * Cross-Platform Path Utilities
+ *
+ * Functions for consistent path handling across Windows, macOS, and Linux.
+ * Always normalize paths to forward slashes before comparison operations.
+ */
+/**
+ * Normalize a path to use forward slashes for consistent cross-platform comparison.
+ * Use this before comparing paths or using regex patterns on paths.
+ *
+ * @example
+ * normalizePath('C:\\Users\\foo\\bar') // 'C:/Users/foo/bar'
+ * normalizePath('/Users/foo/bar')      // '/Users/foo/bar' (unchanged)
+ */
+declare function normalizePath(path: string): string;
+/**
+ * Check if a file path starts with a directory path (cross-platform).
+ * Handles both Windows backslashes and Unix forward slashes.
+ *
+ * @example
+ * pathStartsWith('C:\\Users\\foo\\file.txt', 'C:\\Users\\foo') // true
+ * pathStartsWith('/home/user/file.txt', '/home/user')          // true
+ * pathStartsWith('/home/user2/file.txt', '/home/user')         // false
+ */
+declare function pathStartsWith(filePath: string, dirPath: string): boolean;
+/**
+ * Strip a directory prefix from a path (cross-platform).
+ * Returns the relative path portion after the prefix.
+ *
+ * @example
+ * stripPathPrefix('/home/user/docs/file.txt', '/home/user') // 'docs/file.txt'
+ * stripPathPrefix('C:\\foo\\bar\\baz.txt', 'C:\\foo')       // 'bar/baz.txt'
+ */
+declare function stripPathPrefix(filePath: string, prefix: string): string;
+
+export { debug, normalizePath, pathStartsWith, stripPathPrefix };
+
+// ── inlined from @weft/timeline ──
+// -- @weft/timeline/index.d.ts --
+type TimelineProvider = string;
+type TimelinePermissionScope = {
+    type: 'session';
+    sessionId: string;
+} | {
+    type: 'workspace';
+    workspaceId: string;
+} | {
+    type: 'source';
+    sourceSlug: string;
+} | {
+    type: 'skill';
+    skillSlug: string;
+} | {
+    type: 'automation';
+    automationId: string;
+} | {
+    type: 'tool-call';
+    callId: string;
+};
+type TimelineCommandOrigin = {
+    type: 'user';
+    id?: string;
+} | {
+    type: 'automation';
+    id: string;
+} | {
+    type: 'scheduler';
+    id?: string;
+} | {
+    type: 'host';
+    id?: string;
+} | {
+    type: 'replay';
+    id?: string;
+} | {
+    type: 'system';
+    id?: string;
+};
+interface ToolIntent {
+    kind: string;
+    command?: string;
+    baseCommand?: string;
+    path?: string;
+    toolName?: string;
+    name?: string;
+    method?: string;
+    url?: string;
+}
+interface TimelinePermissionRequest {
+    requestId: string;
+    toolName: string;
+    scope?: TimelinePermissionScope;
+    input?: Record<string, unknown>;
+    reason?: string;
+    intent?: ToolIntent;
+}
+interface TimelinePermissionResolution {
+    allowed: boolean;
+    remember?: boolean;
+    reason?: string;
+}
+type TimelineToolStatus = 'pending' | 'running' | 'completed' | 'failed';
+type TimelineItem = {
+    type: 'user_message';
+    text: string;
+    messageId: string;
+    turnId?: string;
+} | {
+    type: 'assistant_message_delta';
+    text: string;
+    messageId: string;
+    turnId: string;
+} | {
+    type: 'assistant_message';
+    text: string;
+    messageId: string;
+    turnId: string;
+} | {
+    type: 'reasoning_delta';
+    text: string;
+    messageId: string;
+    turnId: string;
+} | {
+    type: 'reasoning';
+    text: string;
+    messageId: string;
+    turnId: string;
+} | {
+    type: 'tool_call';
+    callId: string;
+    name: string;
+    status: TimelineToolStatus;
+    detail?: unknown;
+    turnId?: string;
+} | {
+    type: 'tool_output_delta';
+    callId: string;
+    text: string;
+    stream?: 'stdout' | 'stderr' | string;
+    turnId?: string;
+} | {
+    type: 'tool_result';
+    callId: string;
+    result: unknown;
+    isError?: boolean;
+    turnId?: string;
+} | {
+    type: 'permission_requested';
+    request: TimelinePermissionRequest;
+} | {
+    type: 'permission_resolved';
+    requestId: string;
+    resolution: TimelinePermissionResolution;
+} | {
+    type: 'permission_policy_changed';
+    policy: unknown;
+} | {
+    type: 'source_state_changed';
+    source: unknown;
+} | {
+    type: 'skill_activated';
+    skill: unknown;
+} | {
+    type: 'host_state_changed';
+    state: unknown;
+} | {
+    type: 'automation_triggered';
+    automation: {
+        automationId: string;
+        origin: TimelineCommandOrigin;
+        detail?: unknown;
+    };
+} | {
+    type: 'automation_action_result';
+    result: unknown;
+} | {
+    type: 'runtime_capability_report';
+    report: unknown;
+} | {
+    type: 'runtime_fallback';
+    reason: string;
+    from?: string;
+    to: string;
+} | {
+    type: 'turn_started';
+    turnId: string;
+} | {
+    type: 'turn_completed';
+    turnId: string;
+    usage?: unknown;
+} | {
+    type: 'turn_failed';
+    turnId: string;
+    error: unknown;
+} | {
+    type: 'session_status';
+    status: string;
+} | {
+    type: 'tool_suspended';
+    callId: string;
+    name: string;
+    stepId?: string;
+} | {
+    type: 'tool_resumed';
+    callId: string;
+    name: string;
+    stepId?: string;
+} | {
+    type: 'compaction_started';
+} | {
+    type: 'compaction_boundary';
+    summary?: string;
+};
+interface TimelineRawRef {
+    providerEventType?: string;
+    logPath?: string;
+    offset?: number;
+}
+interface TimelineEnvelope {
+    sessionId: string;
+    provider: TimelineProvider;
+    seq: number;
+    epoch: string;
+    timestamp: number;
+    item: TimelineItem;
+    rawRef?: TimelineRawRef;
+}
+interface TimelineCursor {
+    epoch: string;
+    afterSeq: number;
+}
+interface TimelineFetchRequest {
+    cursor?: TimelineCursor;
+    limit?: number;
+}
+interface TimelineFetchResult {
+    items: TimelineEnvelope[];
+    nextCursor: TimelineCursor;
+    hasGap: boolean;
+}
+interface CreateTimelineSequencerOptions {
+    sessionId: string;
+    provider: TimelineProvider;
+    epoch: string;
+    startSeq?: number;
+    now?: () => number;
+}
+interface TimelineSequencer {
+    append(item: TimelineItem, rawRef?: TimelineRawRef): TimelineEnvelope;
+}
+declare function createTimelineSequencer(options: CreateTimelineSequencerOptions): TimelineSequencer;
+declare function appendTimelineItem(envelope: TimelineEnvelope): TimelineEnvelope;
+declare function createTimelineCursor(cursor: TimelineCursor): TimelineCursor;
+declare function fetchTimeline(timeline: TimelineEnvelope[], request?: TimelineFetchRequest): TimelineFetchResult;
+declare function mergeTimeline(existing: TimelineEnvelope[], incoming: TimelineEnvelope[]): TimelineEnvelope[];
+
+export { type CreateTimelineSequencerOptions, type TimelineCommandOrigin, type TimelineCursor, type TimelineEnvelope, type TimelineFetchRequest, type TimelineFetchResult, type TimelineItem, type TimelinePermissionRequest, type TimelinePermissionResolution, type TimelinePermissionScope, type TimelineProvider, type TimelineRawRef, type TimelineSequencer, type TimelineToolStatus, type ToolIntent, appendTimelineItem, createTimelineCursor, createTimelineSequencer, fetchTimeline, mergeTimeline };
+
+// ── inlined from @weft/ui ──
+// -- @weft/ui/index.d.ts --
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
+
+type ActivityStatus = 'pending' | 'running' | 'completed' | 'error' | 'backgrounded';
+type ActivityType = 'tool' | 'thinking' | 'intermediate' | 'status' | 'plan';
+type AnnotationInteractionMode = 'interactive' | 'tooltip-only';
+type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'interrupted';
+interface TodoItem {
+    /** Task content/description */
+    content: string;
+    /** Current status */
+    status: TodoStatus;
+    /** Present continuous form shown when in_progress (e.g., "Running tests") */
+    activeForm?: string;
+}
+interface ActivityItem {
+    id: string;
+    type: ActivityType;
+    status: ActivityStatus;
+    toolName?: string;
+    toolUseId?: string;
+    toolInput?: Record<string, unknown>;
+    content?: string;
+    intent?: string;
+    /** Optional backing message id (used by plan activities for branching/annotations) */
+    messageId?: string;
+    /** Optional persisted annotations (used by plan activities) */
+    annotations?: AnnotationV1[];
+    displayName?: string;
+    toolDisplayMeta?: ToolDisplayMeta;
+    timestamp: number;
+    error?: string;
+    parentId?: string;
+    depth?: number;
+    statusType?: string;
+    taskId?: string;
+    shellId?: string;
+    elapsedSeconds?: number;
+    isBackground?: boolean;
+}
+interface ResponseContent {
+    text: string;
+    isStreaming: boolean;
+    streamStartTime?: number;
+    /** Whether this response is a plan (renders with plan variant) */
+    isPlan?: boolean;
+    /** ID of the underlying message (for branching + annotations) */
+    messageId?: string;
+    /** Persisted annotations attached to the response message */
+    annotations?: AnnotationV1[];
+}
+/** Represents one complete assistant turn */
+interface AssistantTurn {
+    type: 'assistant';
+    turnId: string;
+    activities: ActivityItem[];
+    response?: ResponseContent;
+    intent?: string;
+    isStreaming: boolean;
+    isComplete: boolean;
+    timestamp: number;
+    /** Extracted from TodoWrite tool - latest todo state in this turn */
+    todos?: TodoItem[];
+}
+/** Represents a user message */
+interface UserTurn {
+    type: 'user';
+    message: Message;
+    timestamp: number;
+}
+/** Represents a system/info/error message that stands alone */
+interface SystemTurn {
+    type: 'system';
+    message: Message;
+    timestamp: number;
+}
+/** Represents an auth request (credential input, OAuth flow) */
+interface AuthRequestTurn {
+    type: 'auth-request';
+    message: Message;
+    timestamp: number;
+}
+type Turn = AssistantTurn | UserTurn | SystemTurn | AuthRequestTurn;
+type OpenAnnotationRequest = {
+    messageId: string;
+    annotationId: string;
+    mode: 'view' | 'edit';
+    anchorX?: number;
+    anchorY?: number;
+    nonce: number;
+};
+
+/**
+ * turn-phase.ts
+ *
+ * Turn lifecycle phase detection for assistant turns.
+ */
+
+/**
+ * Build a stable UI identity key for an assistant turn card.
+ *
+ * Why this exists:
+ * - Backend turnId can be reused across visually split assistant cards
+ *   (e.g., steer/interruption boundaries).
+ * - Expansion state must be keyed by UI-card identity, not raw backend turnId.
+ */
+declare function getAssistantTurnUiKey(turn: AssistantTurn, index: number): string;
+
+/**
+ * turn-grouping.ts
+ *
+ * Core groupMessagesByTurn function plus internal helpers for converting
+ * a flat Message[] array into grouped Turn[] for TurnCard rendering.
+ */
+
+/**
+ * Groups messages into turns for TurnCard rendering
+ *
+ * Rules:
+ * - User messages flush and start fresh context
+ * - Tool messages + intermediate assistant messages belong to current turn
+ * - Final assistant message (non-streaming, non-intermediate) flushes the turn
+ * - Error/status/info messages are standalone system turns
+ *
+ * Note: We intentionally ignore turnId for grouping. The SDK generates a new
+ * turnId for each API message, but from a user perspective, all work between
+ * a user message and the final response should be ONE turn. We use isIntermediate
+ * as the signal: isIntermediate=true means more work coming, isIntermediate=false
+ * means final response.
+ */
+declare function groupMessagesByTurn(messages: Message[]): Turn[];
+
+/**
+ * Global size configuration for TurnCard components.
+ * Adjust these values to scale the entire component uniformly.
+ */
+/** Shared size configuration for activity UI - exported for reuse in inline execution */
+declare const SIZE_CONFIG: {
+    /** Base font size class for all text */
+    readonly fontSize: "text-[13px]";
+    /** Icon size class (width and height) */
+    readonly iconSize: "w-3 h-3";
+    /** Spinner text size class */
+    readonly spinnerSize: "text-[10px]";
+    /** Small spinner for header */
+    readonly spinnerSizeSmall: "text-[8px]";
+    /** Activity row height in pixels (approx for calculation) */
+    readonly activityRowHeight: 24;
+    /** Max visible activities before scrolling (show ~15 items) */
+    readonly maxVisibleActivities: 15;
+    /** Number of items before which we apply staggered animation */
+    readonly staggeredAnimationLimit: 10;
+};
+type BufferReason = 'complete' | 'min_time' | 'timeout' | 'code_block' | 'list' | 'header' | 'question' | 'threshold_met' | 'high_word_count' | 'buffering';
+
+/**
+ * tool-display.ts
+ *
+ * Tool display formatting functions extracted from TurnCard.tsx.
+ * No JSX — pure string/object formatting logic.
+ */
+
+/**
+ * Determine if buffered content should be shown.
+ * This is the core buffering decision function.
+ *
+ * @param text - The accumulated response text
+ * @param isStreaming - Whether the response is still streaming
+ * @param streamStartTime - When streaming started (for timeout calculation)
+ * @returns Decision with reason for debugging
+ */
+declare function shouldShowStreamingContent(text: string, isStreaming: boolean, streamStartTime?: number): {
+    shouldShow: boolean;
+    reason: BufferReason;
+    wordCount: number;
+};
+
+interface ResponseCardProps {
+    /** The content to display (markdown) */
+    text: string;
+    /** Whether the content is still streaming */
+    isStreaming: boolean;
+    /** When streaming started - used for buffering timeout calculation */
+    streamStartTime?: number;
+    /** Callback to open file in editor */
+    onOpenFile?: (path: string) => void;
+    /** Callback to open URL */
+    onOpenUrl?: (url: string) => void;
+    /** Callback to open response in Monaco editor */
+    onPopOut?: () => void;
+    /** Card variant - 'response' for AI messages, 'plan' for plan messages */
+    variant?: 'response' | 'plan';
+    /** Parent session ID (used to reset local annotation/island UI state on session switches) */
+    sessionId?: string;
+    /** Underlying message ID for annotation actions */
+    messageId?: string;
+    /** Persisted annotations for this response */
+    annotations?: AnnotationV1[];
+    /** Callback when user accepts the plan (plan variant only) */
+    onAccept?: () => void;
+    /** Callback when user accepts the plan with compaction (compact first, then execute) */
+    onAcceptWithCompact?: () => void;
+    /** Whether this is the last response in the session (shows Accept Plan button only for last response) */
+    isLastResponse?: boolean;
+    /** Whether to show the Accept Plan button (default: true) */
+    showAcceptPlan?: boolean;
+    /** Hide footer for compact embedding (EditPopover) */
+    compactMode?: boolean;
+    /** Callback to branch the session from this response */
+    onBranch?: (options?: {
+        newPanel?: boolean;
+    }) => void;
+    /** Callback to add annotation from selected text */
+    onAddAnnotation?: (messageId: string, annotation: AnnotationV1) => void;
+    /** Callback to remove persisted annotation */
+    onRemoveAnnotation?: (messageId: string, annotationId: string) => void;
+    /** Callback to update persisted annotation */
+    onUpdateAnnotation?: (messageId: string, annotationId: string, patch: Partial<AnnotationV1>) => void;
+    /** Input send key behavior used by follow-up editor */
+    sendMessageKey?: 'enter' | 'cmd-enter';
+    /** Callback when follow-up is saved via "Save & Send" action */
+    onSaveAndSendFollowUp?: (target: {
+        messageId: string;
+        annotationId: string;
+        note: string;
+        selectedText: string;
+    }) => void;
+    /** Whether there are active pending follow-up annotations in the session */
+    hasActiveFollowUpAnnotations?: boolean;
+    /** External request to open a specific annotation in this response */
+    openAnnotationRequest?: OpenAnnotationRequest | null;
+    /** Annotation interaction mode (viewer uses tooltip-only to suppress the island) */
+    annotationInteractionMode?: AnnotationInteractionMode;
+}
+/**
+ * ResponseCard - Unified card component for AI responses and plans
+ *
+ * Variants:
+ * - 'response': Buffered streaming response with smart content gating
+ * - 'plan': Plan message with header and Accept Plan button
+ *
+ * Response variant implements smart buffering:
+ * - Waits for 40+ words with structure OR
+ * - High-confidence patterns (code blocks, headers, lists) with lower threshold OR
+ * - Timeout after 2.5 seconds
+ *
+ * Performance optimization: Uses throttled static snapshots instead of re-rendering
+ * on every character. Content updates every 300ms during streaming, avoiding
+ * expensive markdown parsing on every delta.
+ */
+declare function ResponseCard({ text, isStreaming, streamStartTime, onOpenFile, onOpenUrl, onPopOut, variant, sessionId, messageId, annotations, onAccept, onAcceptWithCompact, isLastResponse, showAcceptPlan, compactMode, onBranch, onAddAnnotation, onRemoveAnnotation, onUpdateAnnotation, sendMessageKey, onSaveAndSendFollowUp, hasActiveFollowUpAnnotations, openAnnotationRequest, annotationInteractionMode, }: ResponseCardProps): react_jsx_runtime.JSX.Element | null;
+
+interface TurnCardProps {
+    /** Session ID for state persistence (optional in shared context) */
+    sessionId?: string;
+    /** Turn ID for state persistence */
+    turnId: string;
+    /** All activities in this turn (tools, thinking, intermediate text) */
+    activities: ActivityItem[];
+    /** Final response content (may be streaming) */
+    response?: ResponseContent;
+    /** Primary intent/goal for this turn (shown in collapsed preview) */
+    intent?: string;
+    /** Whether content is still being received */
+    isStreaming: boolean;
+    /** Whether this turn is fully complete */
+    isComplete: boolean;
+    /** Start in expanded state */
+    defaultExpanded?: boolean;
+    /** Controlled expansion state (overrides internal state) */
+    isExpanded?: boolean;
+    /** Callback when expansion state changes */
+    onExpandedChange?: (expanded: boolean) => void;
+    /** Controlled expansion state for activity groups */
+    expandedActivityGroups?: Set<string>;
+    /** Callback when activity group expansion changes */
+    onExpandedActivityGroupsChange?: (groups: Set<string>) => void;
+    /** Callback when file path is clicked */
+    onOpenFile?: (path: string) => void;
+    /** Callback when URL is clicked */
+    onOpenUrl?: (url: string) => void;
+    /** Callback to open response in Monaco editor */
+    onPopOut?: (text: string) => void;
+    /** Callback to open turn details in a new window */
+    onOpenDetails?: () => void;
+    /** Callback to open individual activity details in Monaco */
+    onOpenActivityDetails?: (activity: ActivityItem) => void;
+    /** Callback to open all edits/writes in multi-file diff view */
+    onOpenMultiFileDiff?: () => void;
+    /** Whether this turn has any Edit or Write activities */
+    hasEditOrWriteActivities?: boolean;
+    /** TodoWrite tool state - shown at bottom of turn */
+    todos?: TodoItem[];
+    /** Optional render prop for actions menu (Electron provides dropdown) */
+    renderActionsMenu?: () => React$1.ReactNode;
+    /** Callback when user accepts the plan (plan responses only) */
+    onAcceptPlan?: () => void;
+    /** Callback when user accepts the plan with compaction (compact conversation first, then execute) */
+    onAcceptPlanWithCompact?: () => void;
+    /** Whether this is the last response in the session (shows Accept Plan button only for last response) */
+    isLastResponse?: boolean;
+    /** Session folder path for stripping from file paths in tool display */
+    sessionFolderPath?: string;
+    /** Display mode: 'detailed' shows all info, 'informative' hides MCP/API names and params */
+    displayMode?: 'informative' | 'detailed';
+    /** Animate response appearance (for playground demos) */
+    animateResponse?: boolean;
+    /** Hide footers for compact embedding (EditPopover) */
+    compactMode?: boolean;
+    /** Callback to branch the session from a specific message */
+    onBranch?: (messageId: string, options?: {
+        newPanel?: boolean;
+    }) => void;
+    /** Callback to add an annotation to a response message */
+    onAddAnnotation?: (messageId: string, annotation: AnnotationV1) => void;
+    /** Callback to remove a persisted annotation from a response message */
+    onRemoveAnnotation?: (messageId: string, annotationId: string) => void;
+    /** Callback to update a persisted annotation */
+    onUpdateAnnotation?: (messageId: string, annotationId: string, patch: Partial<AnnotationV1>) => void;
+    /** Input send key behavior used by follow-up editor */
+    sendMessageKey?: 'enter' | 'cmd-enter';
+    /** Callback when follow-up is saved via "Save & Send" action */
+    onSaveAndSendFollowUp?: (target: {
+        messageId: string;
+        annotationId: string;
+        note: string;
+        selectedText: string;
+    }) => void;
+    /** Whether there are active pending follow-up annotations in the session */
+    hasActiveFollowUpAnnotations?: boolean;
+    /** External request to open a specific annotation in the follow-up island */
+    openAnnotationRequest?: OpenAnnotationRequest | null;
+    /** Annotation interaction mode (viewer uses tooltip-only to suppress the island) */
+    annotationInteractionMode?: AnnotationInteractionMode;
+}
+/**
+ * TurnCard - Email-like display for one assistant turn
+ *
+ * Batches all activities (tools, thinking) into a collapsible section
+ * with the final response displayed separately below.
+ *
+ * Memoized to prevent re-renders of completed turns during session switches.
+ * Only complete, non-streaming turns are memoized - active turns always re-render.
+ */
+declare const TurnCard: React$1.MemoExoticComponent<({ sessionId, turnId, activities, response, intent, isStreaming, isComplete, defaultExpanded, isExpanded: externalIsExpanded, onExpandedChange, expandedActivityGroups: externalExpandedActivityGroups, onExpandedActivityGroupsChange, onOpenFile, onOpenUrl, onPopOut, onOpenDetails, onOpenActivityDetails, onOpenMultiFileDiff, hasEditOrWriteActivities, todos, renderActionsMenu, onAcceptPlan, onAcceptPlanWithCompact, isLastResponse, sessionFolderPath, displayMode, animateResponse, compactMode, onBranch, onAddAnnotation, onRemoveAnnotation, onUpdateAnnotation, sendMessageKey, onSaveAndSendFollowUp, hasActiveFollowUpAnnotations, openAnnotationRequest, annotationInteractionMode, }: TurnCardProps) => react_jsx_runtime.JSX.Element | null>;
+
+type InlineExecutionStatus = 'executing' | 'success' | 'error';
+interface InlineActivityItem {
+    id: string;
+    name: string;
+    status: ActivityStatus;
+    description?: string;
+}
+interface InlineExecutionProps {
+    /** Current execution status */
+    status: InlineExecutionStatus;
+    /** Activities to display (simplified from full ActivityItem) */
+    activities: InlineActivityItem[];
+    /** Result message on success */
+    result?: string;
+    /** Error message on failure */
+    error?: string;
+    /** Callback to cancel execution */
+    onCancel?: () => void;
+    /** Callback to dismiss (on success/error) */
+    onDismiss?: () => void;
+    /** Callback to retry (on error) */
+    onRetry?: () => void;
+    /** Optional className */
+    className?: string;
+}
+declare function InlineExecution({ status, activities, result, error, onCancel, onDismiss, onRetry, className, }: InlineExecutionProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Platform-specific actions for UI components.
+ * Consumers provide these via PlatformProvider.
+ */
+interface PlatformActions {
+    /** Open a file in the system editor/Finder */
+    onOpenFile?: (path: string) => void;
+    /** Open a URL in the system browser */
+    onOpenUrl?: (url: string) => void;
+    /** Open a markdown preview popover */
+    onOpenMarkdownPreview?: (sessionId: string, markdown: string) => void;
+    /** Open turn details in a new window/panel */
+    onOpenTurnDetails?: (sessionId: string, turnId: string) => void;
+    /** Open activity details */
+    onOpenActivityDetails?: (sessionId: string, activityId: string) => void;
+    /** Open multi-file diff view for a turn */
+    onOpenMultiFileDiff?: (sessionId: string, turnId: string) => void;
+    /** Respond to a permission or auth request */
+    onPermissionAllow?: (requestId: string, allowed: boolean, remember?: boolean) => void;
+}
+/**
+ * Provider that injects platform-specific actions into the component tree.
+ */
+declare function PlatformProvider({ actions, children, }: {
+    actions: PlatformActions;
+    children: React__default.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface ChatTranscriptProps {
+    messages: Message[];
+    platformActions?: PlatformActions;
+    className?: string;
+    onTurnClick?: (turnId: string) => void;
+    onActivityClick?: (activity: ActivityItem) => void;
+    defaultExpanded?: boolean;
+    displayMode?: 'informative' | 'detailed';
+    animateResponse?: boolean;
+    annotationInteractionMode?: AnnotationInteractionMode;
+    sessionId?: string;
+    sessionFolderPath?: string;
+    children?: ReactNode;
+}
+declare function ChatTranscript({ messages, platformActions, className, onTurnClick, onActivityClick, defaultExpanded, displayMode, animateResponse, annotationInteractionMode, sessionId, sessionFolderPath, children, }: ChatTranscriptProps): react_jsx_runtime.JSX.Element;
+
+type SessionViewerMode = 'interactive' | 'readonly';
+interface SessionViewerProps {
+    session: StoredSession;
+    mode?: SessionViewerMode;
+    platformActions?: PlatformActions;
+    className?: string;
+    onTurnClick?: (turnId: string) => void;
+    onActivityClick?: (activity: ActivityItem) => void;
+    defaultExpanded?: boolean;
+    header?: ReactNode;
+    footer?: ReactNode;
+    sessionFolderPath?: string;
+}
+declare function SessionViewer({ session, mode, platformActions, className, onTurnClick, onActivityClick, defaultExpanded, header, footer, sessionFolderPath, }: SessionViewerProps): react_jsx_runtime.JSX.Element;
+
+interface PendingIndicatorProps {
+    isReconnecting?: boolean;
+}
+declare function PendingIndicator({ isReconnecting, }: PendingIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface UserMessageBubbleProps {
+    /** Message content (markdown supported) */
+    content: string;
+    /** Additional className for the outer container */
+    className?: string;
+    /** Callback when a URL is clicked */
+    onUrlClick?: (url: string) => void;
+    /** Callback when a file path is clicked */
+    onFileClick?: (path: string) => void;
+    /** Stored attachments (images, documents) */
+    attachments?: StoredAttachment[];
+    /** Content badges for inline display (sources, skills) */
+    badges?: ContentBadge[];
+    /** Whether the message is awaiting backend confirmation. User bubbles stay visually stable. */
+    isPending?: boolean;
+    /** Whether the message is queued (badge shown) */
+    isQueued?: boolean;
+    /** Compact mode - reduces padding for popover embedding */
+    compactMode?: boolean;
+}
+declare function UserMessageBubble({ content, className, onUrlClick, onFileClick, attachments, badges, isQueued, compactMode, }: UserMessageBubbleProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * SystemMessage - Displays system/info/error/warning messages
+ *
+ * Used for displaying non-conversational messages like errors, warnings,
+ * info notices, and general system messages. Supports different visual
+ * styles based on the message type.
+ *
+ * Error and warning types use shadow-tinted for a softer, more polished appearance.
+ * System and info types use a simple bordered style.
+ */
+type SystemMessageType = 'error' | 'info' | 'warning' | 'system';
+interface SystemMessageProps {
+    /** Message content (markdown supported) */
+    content: string;
+    /** Message type determining visual style */
+    type: SystemMessageType;
+    /** Additional className for the outer container */
+    className?: string;
+}
+/**
+ * SystemMessage - Renders a styled message bubble based on type
+ */
+declare function SystemMessage({ content, type, className, }: SystemMessageProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * PermissionRequestCard - Inline permission prompt for agent tool approval
+ *
+ * Renders when the agent is paused awaiting user approval for a tool
+ * invocation (e.g. bash command, file write, MCP mutation). Displays
+ * the tool name, input preview, and reason, with Allow/Deny/Remember
+ * action buttons.
+ *
+ * Styling follows the Weft design system:
+ * - Rounded-[8px] card with shadow-minimal
+ * - Accent-coloured header strip for tool identity
+ * - Truncated input preview in a subtle code block
+ * - Two or three action buttons (Allow, Deny, Remember)
+ */
+interface PermissionRequestCardProps {
+    /** Unique request ID matching the runtime permission request */
+    requestId: string;
+    /** Tool name requesting approval (e.g. "Bash", "Write", "Edit") */
+    toolName: string;
+    /** Optional scope descriptor (session, workspace, source, skill, tool-call) */
+    scope?: {
+        type: string;
+        label?: string;
+    };
+    /** Optional input preview (command, file path, MCP payload) */
+    input?: Record<string, unknown>;
+    /** Optional reason text explaining why permission is needed */
+    reason?: string;
+    /** Whether this request is currently active (not yet resolved) */
+    isActive?: boolean;
+    /** Previous resolution if re-shown for context (allowed/denied) */
+    previousResolution?: {
+        allowed: boolean;
+        remember?: boolean;
+        reason?: string;
+    };
+    /** Callback when user approves the request */
+    onAllow?: (requestId: string, remember?: boolean) => void;
+    /** Callback when user denies the request */
+    onDeny?: (requestId: string) => void;
+    /** Additional className */
+    className?: string;
+}
+declare function PermissionRequestCard({ requestId, toolName, scope, input, reason, isActive, previousResolution, onAllow, onDeny, className, }: PermissionRequestCardProps): react_jsx_runtime.JSX.Element;
+
+interface CodeBlockProps {
+    code: string;
+    language?: string;
+    className?: string;
+    /**
+     * Render mode affects code block styling:
+     * - 'terminal': Minimal, keeps control chars visible
+     * - 'minimal': Clean code, basic styling
+     * - 'full': Rich styling with background, copy button, etc.
+     */
+    mode?: 'terminal' | 'minimal' | 'full';
+    /**
+     * Force a specific theme. If not provided, detects from document.documentElement.classList
+     */
+    forcedTheme?: 'light' | 'dark';
+}
+/**
+ * CodeBlock - Syntax highlighted code block using Shiki
+ *
+ * Uses VS Code's syntax highlighting engine for accurate highlighting.
+ * Lazy-loads highlighting and caches results for performance.
+ */
+declare function CodeBlock({ code, language, className, mode, forcedTheme }: CodeBlockProps): react_jsx_runtime.JSX.Element;
+/**
+ * InlineCode - Styled inline code span
+ * Features: subtle background (3%), no border, 75% opacity text
+ */
+declare function InlineCode({ children, className }: {
+    children: React$1.ReactNode;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare function CollapsibleMarkdownProvider({ children, }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+/**
+ * Render modes for markdown content:
+ *
+ * - 'terminal': Raw output with minimal formatting, control chars visible
+ *   Best for: Debug output, raw logs, when you want to see exactly what's there
+ *
+ * - 'minimal': Clean rendering with syntax highlighting but no extra chrome
+ *   Best for: Chat messages, inline content, when you want readability without clutter
+ *
+ * - 'full': Rich rendering with beautiful tables, styled code blocks, proper typography
+ *   Best for: Documentation, long-form content, when presentation matters
+ */
+type RenderMode = 'terminal' | 'minimal' | 'full';
+interface MarkdownProps {
+    children: string;
+    /**
+     * Render mode controlling formatting level
+     * @default 'minimal'
+     */
+    mode?: RenderMode;
+    className?: string;
+    /**
+     * Message ID for memoization (optional)
+     * When provided, memoizes parsed blocks to avoid re-parsing during streaming
+     */
+    id?: string;
+    /**
+     * Callback when a URL is clicked
+     */
+    onUrlClick?: (url: string) => void;
+    /**
+     * Callback when a file path is clicked
+     */
+    onFileClick?: (path: string) => void;
+    /**
+     * Enable collapsible headings
+     * Requires wrapping in CollapsibleMarkdownProvider
+     * @default false
+     */
+    collapsible?: boolean;
+    /**
+     * Hide expand button on first mermaid block (when message starts with mermaid)
+     * Used in chat to avoid overlap with TurnCard's fullscreen button
+     * @default true
+     */
+    hideFirstMermaidExpand?: boolean;
+}
+/**
+ * Markdown - Customizable markdown renderer with multiple render modes
+ *
+ * Features:
+ * - Three render modes: terminal, minimal, full
+ * - Syntax highlighting via Shiki
+ * - GFM support (tables, task lists, strikethrough)
+ * - Clickable links and file paths
+ * - Memoization for streaming performance
+ */
+declare function Markdown({ children, mode, className, id, onUrlClick, onFileClick, collapsible, hideFirstMermaidExpand, }: MarkdownProps): react_jsx_runtime.JSX.Element;
+/**
+ * MemoizedMarkdown - Optimized for streaming scenarios
+ *
+ * Splits content into blocks and memoizes each block separately,
+ * so only new/changed blocks re-render during streaming.
+ */
+declare const MemoizedMarkdown: React$1.MemoExoticComponent<typeof Markdown>;
+
+interface AnchoredSelection {
+    anchorX: number;
+    anchorY: number;
+    start: number;
+    end: number;
+    exact: string;
+    selectedText?: string;
+    prefix?: string;
+    suffix?: string;
+}
+
+/**
+ * annotation-core — stub for annotation overlay core utilities.
+ *
+ * Provides type definitions and utility functions for annotation rendering.
+ * Full implementation will be ported from the upstream source project.
+ */
+
+interface AnnotationOverlayRect {
+    id: string;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    color: string;
+}
+type AnnotationOverlayChip = {
+    id: string;
+    index: number;
+    left: number;
+    top: number;
+    sentFollowUp: boolean;
+};
+declare function hasExistingTextRangeAnnotation(annotations: AnnotationV1[], start: number, end: number): boolean;
+declare function createSelectionPreviewAnnotation(messageId: string, sessionIdOrSelection: string | AnchoredSelection, startOrSessionId?: number | string, end?: number, exact?: string): AnnotationV1;
+declare function createTextSelectionAnnotation(messageId: string, sessionId: string, start: number, end: number, exact: string, note: string): AnnotationV1;
+interface TextSegment {
+    start: number;
+    end: number;
+    node: Text;
+}
+declare function collectTextSegments(_content: string | HTMLElement, _annotations: AnnotationV1[]): TextSegment[];
+/** Stub — full implementation will compute canonical text from DOM */
+declare function getCanonicalText(_content: string | HTMLElement): string;
+/**
+ * Stub — resolves character offset within a DOM node.
+ * Full implementation will walk the DOM tree to compute text offset.
+ */
+declare function resolveNodeOffset(_root: string | HTMLElement, _node?: Node, _offset?: number): number | null;
+
+/**
+ * annotation-overlay-geometry — stub for annotation overlay geometry computation.
+ */
+
+interface AnnotationOverlayGeometryResult {
+    rects: AnnotationOverlayRect[];
+    chips: AnnotationOverlayChip[];
+    unresolved: Array<{
+        annotation: AnnotationV1;
+        reason: string;
+    }>;
+}
+declare function computeAnnotationOverlayGeometry(_containerOrOpts: HTMLElement | {
+    root: HTMLElement;
+    renderedAnnotations: AnnotationV1[];
+    persistedAnnotations?: AnnotationV1[];
+}, _annotations?: AnnotationV1[], _content?: string): AnnotationOverlayGeometryResult;
+
+interface AnnotationOverlayLayerProps {
+    rects: AnnotationOverlayRect[];
+    chips: AnnotationOverlayChip[];
+    annotations?: AnnotationV1[];
+    getTooltipText?: (annotation: AnnotationV1, index: number) => string;
+    /** Whether clicking a chip should open the annotation island/details view. */
+    allowChipOpen?: boolean;
+    onChipOpen: (params: {
+        annotationId: string;
+        index: number;
+        anchorX: number;
+        anchorY: number;
+        mode: 'view' | 'edit';
+    }) => void;
+}
+declare function AnnotationOverlayLayer({ rects, chips, annotations, getTooltipText, allowChipOpen, onChipOpen, }: AnnotationOverlayLayerProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * IslandTransitionConfig — type stub for annotation island transition animations.
+ */
+interface IslandTransitionConfig {
+    duration?: number;
+    easing?: string;
+}
+
+/**
+ * AnnotationIslandMenu — stub for annotation island menu component.
+ * Accepts all props used by TurnCard but renders nothing.
+ */
+
+interface AnnotationIslandMenuProps {
+    anchor?: {
+        x: number;
+        y: number;
+    } | null;
+    sourceKey?: string;
+    replayNonce?: number;
+    isVisible?: boolean;
+    activeView?: string | null;
+    mode?: string;
+    draft?: string;
+    onDraftChange?: (draft: string) => void;
+    onOpenFollowUp?: () => void;
+    onCancel?: () => void;
+    onRequestBack?: () => boolean;
+    onRequestEdit?: () => void;
+    onSubmit?: (note: string) => void;
+    onSubmitAndSend?: (...args: any[]) => void;
+    onDelete?: () => void;
+    sendMessageKey?: string;
+    transitionConfig?: Record<string, unknown> | IslandTransitionConfig;
+    onExitComplete?: () => void;
+    usePortal?: boolean;
+    className?: string;
+}
+declare function AnnotationIslandMenu(_props: AnnotationIslandMenuProps): React$1.ReactNode;
+
+/**
+ * island-motion — stub for annotation island motion/animation utilities.
+ */
+interface PointerSnapshot {
+    x: number;
+    y: number;
+    timestamp: number;
+}
+declare function buildAnnotationChipEntryTransition(_snapshot?: PointerSnapshot | null): Record<string, unknown>;
+declare function buildSelectionEntryTransition(_primary?: PointerSnapshot | null, _secondary?: PointerSnapshot | null): Record<string, unknown>;
+
+/**
+ * Event Processor Types
+ *
+ * Defines the state and event types for the centralized event processor.
+ * All agent events flow through a single pure function for consistent state transitions.
+ */
+
+/**
+ * Runtime Session type — extends core Session with messages and processing state.
+ * Aliased from ProtocolSession which includes all runtime fields needed by the processor.
+ */
+type Session = ProtocolSession;
+
+/**
+ * Streaming state for a session - replaces streamingTextRef
+ */
+interface StreamingState {
+    content: string;
+    turnId?: string;
+    parentToolUseId?: string;
+}
+/**
+ * Complete state for a session - combines session + streaming
+ */
+interface SessionState {
+    session: Session;
+    streaming: StreamingState | null;
+}
+/**
+ * Text delta event - streaming text content
+ */
+interface TextDeltaEvent {
+    type: 'text_delta';
+    sessionId: string;
+    delta: string;
+    turnId?: string;
+    /** Timestamp from canonical timeline for stable ordering */
+    timestamp?: number;
+}
+/**
+ * Text complete event - finalizes streaming text
+ */
+interface TextCompleteEvent {
+    type: 'text_complete';
+    sessionId: string;
+    text: string;
+    turnId?: string;
+    isIntermediate?: boolean;
+    parentToolUseId?: string;
+    /** Timestamp from main process for consistent ordering with session.jsonl */
+    timestamp?: number;
+    /** Authoritative message ID from main process for persistence/branching parity */
+    messageId?: string;
+}
+/**
+ * Tool start event - begins tool execution
+ * Field names match SessionEvent from @weft/protocol
+ */
+interface ToolStartEvent {
+    type: 'tool_start';
+    sessionId: string;
+    toolUseId: string;
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+    /** Timestamp from main process for consistent ordering */
+    timestamp?: number;
+    turnId?: string;
+    parentToolUseId?: string;
+    toolIntent?: string;
+    toolDisplayName?: string;
+    /** Tool display metadata with base64-encoded icon for viewer compatibility */
+    toolDisplayMeta?: ToolDisplayMeta;
+}
+/**
+ * Tool result event - completes tool execution
+ */
+interface ToolResultEvent {
+    type: 'tool_result';
+    sessionId: string;
+    toolUseId: string;
+    toolName?: string;
+    result: string;
+    isError?: boolean;
+    turnId?: string;
+    parentToolUseId?: string;
+    /** Timestamp from main process for consistent ordering */
+    timestamp?: number;
+}
+/**
+ * Tool delta event - appends streaming output to an executing tool.
+ */
+interface ToolDeltaEvent {
+    type: 'tool_delta';
+    sessionId: string;
+    toolUseId: string;
+    delta: string;
+    stream?: string;
+    turnId?: string;
+    /** Timestamp from main process for consistent ordering */
+    timestamp?: number;
+}
+/**
+ * Complete event - agent loop finished
+ */
+interface CompleteEvent {
+    type: 'complete';
+    sessionId: string;
+    tokenUsage?: Session['tokenUsage'];
+    /** Explicit unread flag - set by main process based on viewing state */
+    hasUnread?: boolean;
+}
+/**
+ * Error event - agent error occurred
+ */
+interface ErrorEvent {
+    type: 'error';
+    sessionId: string;
+    error: string;
+    code?: string;
+    title?: string;
+    details?: string;
+    original?: string;
+    /** Timestamp from main process for consistent ordering */
+    timestamp?: number;
+}
+/**
+ * Permission request event
+ * Matches SessionEvent shape from @weft/protocol
+ */
+interface PermissionRequestEvent {
+    type: 'permission_request';
+    sessionId: string;
+    request: PermissionRequest;
+}
+/**
+ * Sources changed event
+ */
+interface SourcesChangedEvent {
+    type: 'sources_changed';
+    sessionId: string;
+    enabledSourceSlugs: string[];
+}
+/**
+ * Labels changed event
+ */
+interface LabelsChangedEvent {
+    type: 'labels_changed';
+    sessionId: string;
+    labels: string[];
+}
+/**
+ * Todo state changed event (external metadata change or agent tool)
+ */
+interface SessionStatusChangedEvent {
+    type: 'session_status_changed';
+    sessionId: string;
+    sessionStatus?: string;
+}
+/**
+ * Session flagged/unflagged events (external metadata change)
+ */
+interface SessionFlaggedEvent {
+    type: 'session_flagged';
+    sessionId: string;
+}
+interface SessionUnflaggedEvent {
+    type: 'session_unflagged';
+    sessionId: string;
+}
+/**
+ * Session archived/unarchived events (external metadata change)
+ */
+interface SessionArchivedEvent {
+    type: 'session_archived';
+    sessionId: string;
+}
+interface SessionUnarchivedEvent {
+    type: 'session_unarchived';
+    sessionId: string;
+}
+/**
+ * Session name changed event (external metadata change)
+ */
+interface NameChangedEvent {
+    type: 'name_changed';
+    sessionId: string;
+    name?: string;
+}
+/**
+ * Plan submitted event
+ */
+interface PlanSubmittedEvent {
+    type: 'plan_submitted';
+    sessionId: string;
+    message: Message;
+}
+/**
+ * Typed error event
+ */
+interface TypedErrorEvent {
+    type: 'typed_error';
+    sessionId: string;
+    error: TypedError;
+    /** Timestamp from main process for consistent ordering */
+    timestamp?: number;
+}
+/**
+ * Status event
+ */
+interface StatusEvent {
+    type: 'status';
+    sessionId: string;
+    message: string;
+    statusType?: 'compacting';
+    /** Timestamp from main process for consistent ordering */
+    timestamp?: number;
+}
+/**
+ * Info event
+ */
+interface InfoEvent {
+    type: 'info';
+    sessionId: string;
+    message: string;
+    statusType?: 'compaction_complete';
+    level?: 'info' | 'warning' | 'error' | 'success';
+    /** Timestamp from main process for consistent ordering */
+    timestamp?: number;
+}
+/**
+ * Interrupted event
+ */
+interface InterruptedEvent {
+    type: 'interrupted';
+    sessionId: string;
+    message?: Message;
+    /** Messages that were queued but not processed — should be restored to input field */
+    queuedMessages?: string[];
+}
+/**
+ * Title generated event
+ */
+interface TitleGeneratedEvent {
+    type: 'title_generated';
+    sessionId: string;
+    title: string;
+    preview?: string;
+}
+/**
+ * Title regenerating event - indicates title regeneration has started/finished
+ * Used to show shimmer effect on title during regeneration
+ * @deprecated Use AsyncOperationEvent instead
+ */
+interface TitleRegeneratingEvent {
+    type: 'title_regenerating';
+    sessionId: string;
+    isRegenerating: boolean;
+}
+/**
+ * Generic async operation state event
+ * Used to show shimmer effect during any async operation (sharing, updating, revoking, title regeneration)
+ */
+interface AsyncOperationEvent {
+    type: 'async_operation';
+    sessionId: string;
+    isOngoing: boolean;
+}
+/**
+ * Working directory changed event (user-initiated via UI)
+ */
+interface WorkingDirectoryChangedEvent {
+    type: 'working_directory_changed';
+    sessionId: string;
+    workingDirectory: string;
+}
+/**
+ * Working directory error event - server rejected the path (cross-platform, not found, etc.)
+ */
+interface WorkingDirectoryErrorEvent {
+    type: 'working_directory_error';
+    sessionId: string;
+    error: string;
+}
+/**
+ * Permission mode changed event
+ */
+interface PermissionModeChangedEvent {
+    type: 'permission_mode_changed';
+    sessionId: string;
+    permissionMode: PermissionMode;
+    previousPermissionMode?: PermissionMode;
+    transitionDisplay?: string;
+    modeVersion?: number;
+    changedAt?: string;
+    changedBy?: 'user' | 'system' | 'restore' | 'automation' | 'unknown';
+}
+/**
+ * Session model changed event
+ */
+interface SessionModelChangedEvent {
+    type: 'session_model_changed';
+    sessionId: string;
+    model: string | null;
+}
+/**
+ * LLM connection changed event - syncs session.llmConnection to renderer
+ */
+interface LLMConnectionChangedEvent {
+    type: 'connection_changed';
+    sessionId: string;
+    connectionSlug: string;
+    supportsBranching?: boolean;
+}
+/**
+ * Credential request event - prompts user for credentials
+ */
+interface CredentialRequestEvent {
+    type: 'credential_request';
+    sessionId: string;
+    request: CredentialRequest;
+}
+/**
+ * Task backgrounded event - background agent started
+ */
+interface TaskBackgroundedEvent {
+    type: 'task_backgrounded';
+    sessionId: string;
+    toolUseId: string;
+    taskId: string;
+    intent?: string;
+    turnId?: string;
+}
+/**
+ * Shell backgrounded event - background bash shell started
+ */
+interface ShellBackgroundedEvent {
+    type: 'shell_backgrounded';
+    sessionId: string;
+    toolUseId: string;
+    shellId: string;
+    intent?: string;
+    turnId?: string;
+}
+/**
+ * Task progress event - live progress updates for background tasks
+ */
+interface TaskProgressEvent {
+    type: 'task_progress';
+    sessionId: string;
+    toolUseId: string;
+    elapsedSeconds: number;
+    turnId?: string;
+}
+/**
+ * Task completed event - background task finished execution
+ * Updates the tool message status and result when a background task completes.
+ */
+interface TaskCompletedEvent {
+    type: 'task_completed';
+    sessionId: string;
+    taskId: string;
+    status: 'completed' | 'failed' | 'stopped';
+    outputFile?: string;
+    summary?: string;
+    turnId?: string;
+}
+/**
+ * User message event - backend confirmation of optimistic user message
+ * Used for optimistic UI: frontend shows message immediately,
+ * backend confirms/updates status via this event
+ */
+interface UserMessageEvent {
+    type: 'user_message';
+    sessionId: string;
+    message: Message;
+    status: 'accepted' | 'queued' | 'processing';
+    /** Frontend's optimistic message ID for reliable matching */
+    optimisticMessageId?: string;
+}
+/**
+ * Message annotation update event
+ */
+interface MessageAnnotationsUpdatedEvent {
+    type: 'message_annotations_updated';
+    sessionId: string;
+    messageId: string;
+    annotations: NonNullable<Message['annotations']>;
+}
+/**
+ * Session shared event - session was shared to viewer
+ */
+interface SessionSharedEvent {
+    type: 'session_shared';
+    sessionId: string;
+    sharedUrl: string;
+}
+/**
+ * Session unshared event - session share was revoked
+ */
+interface SessionUnsharedEvent {
+    type: 'session_unshared';
+    sessionId: string;
+}
+/**
+ * Auth request event - unified auth flow (credential or OAuth)
+ * Adds auth-request message to session and displays inline auth UI
+ */
+interface AuthRequestEvent {
+    type: 'auth_request';
+    sessionId: string;
+    message: Message;
+    request: AuthRequest;
+}
+/**
+ * Auth completed event - auth request was completed (success, failure, or cancelled)
+ * Updates the auth-request message status
+ */
+interface AuthCompletedEvent {
+    type: 'auth_completed';
+    sessionId: string;
+    requestId: string;
+    success: boolean;
+    cancelled?: boolean;
+    error?: string;
+}
+/**
+ * Source activated event - a source was auto-activated mid-turn
+ * Caller should re-send the original message to retry with the now-active source
+ */
+interface SourceActivatedEvent {
+    type: 'source_activated';
+    sessionId: string;
+    sourceSlug: string;
+    originalMessage: string;
+}
+/**
+ * Usage update event - real-time context usage during processing
+ * Allows UI to show growing context as agent processes, not just on complete
+ */
+interface UsageUpdateEvent {
+    type: 'usage_update';
+    sessionId: string;
+    tokenUsage: {
+        inputTokens: number;
+        contextWindow?: number;
+    };
+}
+/**
+ * Union of all agent events
+ */
+type ChatEvent = TextDeltaEvent | TextCompleteEvent | ToolStartEvent | ToolDeltaEvent | ToolResultEvent | CompleteEvent | ErrorEvent | TypedErrorEvent | PermissionRequestEvent | CredentialRequestEvent | SourcesChangedEvent | LabelsChangedEvent | SessionStatusChangedEvent | SessionFlaggedEvent | SessionUnflaggedEvent | SessionArchivedEvent | SessionUnarchivedEvent | NameChangedEvent | PlanSubmittedEvent | StatusEvent | InfoEvent | InterruptedEvent | TitleGeneratedEvent | TitleRegeneratingEvent | AsyncOperationEvent | WorkingDirectoryChangedEvent | WorkingDirectoryErrorEvent | PermissionModeChangedEvent | SessionModelChangedEvent | LLMConnectionChangedEvent | TaskBackgroundedEvent | ShellBackgroundedEvent | TaskProgressEvent | TaskCompletedEvent | UserMessageEvent | MessageAnnotationsUpdatedEvent | SessionSharedEvent | SessionUnsharedEvent | AuthRequestEvent | AuthCompletedEvent | SourceActivatedEvent | UsageUpdateEvent;
+/**
+ * Side effects that need to be handled outside the pure processor
+ */
+type Effect = {
+    type: 'permission_request';
+    request: PermissionRequest;
+} | {
+    type: 'credential_request';
+    request: CredentialRequest;
+} | {
+    type: 'generate_title';
+    sessionId: string;
+    userMessage: string;
+} | {
+    type: 'permission_mode_changed';
+    sessionId: string;
+    permissionMode: PermissionMode;
+    previousPermissionMode?: PermissionMode;
+    transitionDisplay?: string;
+    modeVersion?: number;
+    changedAt?: string;
+    changedBy?: 'user' | 'system' | 'restore' | 'automation' | 'unknown';
+} | {
+    type: 'auto_retry';
+    sessionId: string;
+    originalMessage: string;
+    sourceSlug: string;
+} | {
+    type: 'restore_input';
+    text: string;
+} | {
+    type: 'toast_error';
+    message: string;
+};
+/**
+ * Result of processing an event
+ */
+interface ProcessResult {
+    state: SessionState;
+    /** Side effects to execute (permissions, etc.) */
+    effects: Effect[];
+}
+
+/**
+ * Event Processor
+ *
+ * Central pure function that processes all agent events.
+ * Guarantees consistent state transitions and always returns new references.
+ *
+ * Benefits:
+ * - Single source of truth for event handling
+ * - Pure functions - easy to test
+ * - No race conditions - single update path
+ * - Always new references - atom sync always works
+ * - Message lookup by ID - never position-based
+ */
+
+/**
+ * Process an agent event, returning new state and any side effects
+ *
+ * This is a PURE FUNCTION - no side effects, always returns new state.
+ * Guaranteed to return a new session reference (no referential equality issues).
+ *
+ * @param state - Current session state (session + streaming)
+ * @param event - Agent event to process
+ * @returns New state and any side effects to execute
+ */
+declare function processEvent(state: SessionState, event: ChatEvent): ProcessResult;
+
+/**
+ * Map a core AgentEvent to the processor's session-scoped event format.
+ *
+ * Core AgentEvent is the raw SDK/runtime format. The processor expects
+ * session-scoped events with its own field names. Keeping this as a pure
+ * function makes local-runtime, tests, and React hooks share one mapping.
+ */
+declare function mapCoreEventToProcessorEvent(coreEvent: AgentEvent, sessionId: string): ChatEvent;
+declare function mapTimelineEnvelopeToProcessorEvent(envelope: TimelineEnvelope): ChatEvent;
+
+/**
+ * Message Operation Helpers
+ *
+ * Pure utility functions for finding and updating messages.
+ * All lookups are by ID (turnId, toolUseId) - NEVER by position.
+ */
+
+/**
+ * Generate a unique message ID
+ * Delegates to core's generateMessageId for uniqueness
+ */
+declare function generateMessageId(): string;
+/**
+ * Find streaming assistant message by turnId
+ * Falls back to last streaming assistant if no turnId
+ */
+declare function findStreamingMessage(messages: Message[], turnId?: string): number;
+/**
+ * Find assistant message by turnId (streaming or not)
+ */
+declare function findAssistantMessage(messages: Message[], turnId?: string): number;
+/**
+ * Find tool message by toolUseId
+ */
+declare function findToolMessage(messages: Message[], toolUseId: string): number;
+/**
+ * Update message at index, returning new session
+ * Always creates new references (immutable update)
+ * @param updateTimestamp - If true, also update lastMessageAt
+ */
+declare function updateMessageAt(session: Session, index: number, updates: Partial<Message>, updateTimestamp?: boolean): Session;
+/**
+ * Append message to session, returning new session
+ * @param updateTimestamp - If false, don't update lastMessageAt (for intermediate/tool messages)
+ */
+declare function appendMessage(session: Session, message: Message, updateTimestamp?: boolean): Session;
+
+/**
+ * Event Source Interface
+ *
+ * Generic abstraction for receiving SessionEvent streams.
+ * Replaces Electron IPC (window.electronAPI.onSessionEvent) with
+ * a provider-agnostic interface that works in any runtime:
+ * - WebSocket (browser/server)
+ * - HTTP SSE (server)
+ * - stdin/stdout (CLI)
+ * - In-process (testing)
+ */
+
+/**
+ * Event source callback — receives events from the source.
+ */
+type EventSourceCallback = (event: AgentEvent) => void;
+/**
+ * Error callback — receives errors from the source.
+ */
+type EventSourceErrorCallback = (error: Error) => void;
+/**
+ * Close callback — called when the source is disconnected.
+ */
+type EventSourceCloseCallback = () => void;
+/**
+ * Generic event source interface.
+ * Implementations provide events from different transports.
+ */
+interface EventSource {
+    /**
+     * Start receiving events.
+     * @param onEvent - Callback for each AgentEvent
+     * @param onError - Callback for transport errors
+     * @param onClose - Callback when source disconnects
+     */
+    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
+    /**
+     * Stop receiving events and clean up resources.
+     */
+    disconnect(): void;
+    /**
+     * Check if the source is currently connected.
+     */
+    isConnected(): boolean;
+}
+/**
+ * WebSocket-based EventSource implementation.
+ * Receives SessionEvent messages over a WebSocket connection.
+ */
+declare class WebSocketEventSource implements EventSource {
+    private ws;
+    private connected;
+    private url;
+    private protocols?;
+    constructor(url: string, protocols?: string | string[]);
+    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
+    disconnect(): void;
+    isConnected(): boolean;
+}
+/**
+ * SSE (Server-Sent Events) EventSource implementation.
+ * Receives SessionEvent messages over an HTTP SSE connection.
+ */
+declare class SSEEventSource implements EventSource {
+    private source;
+    private connected;
+    private url;
+    constructor(url: string);
+    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
+    disconnect(): void;
+    isConnected(): boolean;
+}
+/**
+ * In-process EventSource for testing.
+ * Events are pushed directly via enqueue().
+ */
+declare class InProcessEventSource implements EventSource {
+    private listeners;
+    private connected;
+    connect(onEvent: EventSourceCallback, onError?: EventSourceErrorCallback, onClose?: EventSourceCloseCallback): void;
+    disconnect(): void;
+    isConnected(): boolean;
+    /**
+     * Push an event directly to the connected listener.
+     * Useful for testing and in-process scenarios.
+     */
+    enqueue(event: AgentEvent): void;
+    /**
+     * Simulate an error.
+     */
+    simulateError(error: Error): void;
+    /**
+     * Simulate a disconnect.
+     */
+    simulateClose(): void;
+}
+
+/**
+ * Event Processor Hook
+ *
+ * Provides the event processor for use in React apps.
+ * Manages streaming state per session and returns processed events.
+ *
+ * Accepts an EventSource (WebSocket, SSE, in-process) instead of
+ * Electron IPC (window.electronAPI). Uses React useState/useRef
+ * instead of Jotai atoms for state management.
+ */
+
+interface UseEventProcessorOptions {
+    /** EventSource to receive agent events from */
+    eventSource: EventSource;
+    /** Session ID to associate with incoming events */
+    sessionId: string;
+    /** Workspace ID for creating new sessions */
+    workspaceId: string;
+    /** Workspace name for creating new sessions */
+    workspaceName?: string;
+    /** Callback for side effects (permissions, toasts, etc.) */
+    onEffect?: (effect: Effect) => void;
+    /** Callback for errors from the event source */
+    onError?: (error: Error) => void;
+    /** Callback when event source disconnects */
+    onClose?: () => void;
+}
+interface UseEventProcessorResult {
+    /** Current session state (messages, processing status, etc.) */
+    session: Session | null;
+    /** Current streaming state for the session */
+    streamingState: StreamingState | null;
+    /**
+     * Process an agent event and return the updated session + any side effects
+     *
+     * @param event - The core AgentEvent to process
+     * @returns Updated session and any side effects to execute
+     */
+    processAgentEvent: (event: AgentEvent) => {
+        session: Session;
+        effects: Effect[];
+    };
+    /**
+     * Clear streaming state for the session (e.g., on error or complete)
+     */
+    clearStreamingState: () => void;
+    /**
+     * Get current streaming state (for debugging/testing)
+     */
+    getStreamingState: () => StreamingState | null;
+    /**
+     * Whether the event source is currently connected
+     */
+    isConnected: boolean;
+}
+/**
+ * Hook that provides the event processor connected to an EventSource.
+ *
+ * Manages streaming state per session using React useRef (not Jotai atoms).
+ * All event processing goes through pure functions.
+ *
+ * Connects to the EventSource on mount and disconnects on unmount.
+ */
+declare function useEventProcessor(options: UseEventProcessorOptions): UseEventProcessorResult;
+
+export { type ActivityItem, type ActivityStatus, AnnotationIslandMenu, type AnnotationIslandMenuProps, type AnnotationOverlayChip, type AnnotationOverlayGeometryResult, AnnotationOverlayLayer, type AnnotationOverlayLayerProps, type AnnotationOverlayRect, type AssistantTurn, type AuthRequestTurn, type ChatEvent, ChatTranscript, type ChatTranscriptProps, CodeBlock, CollapsibleMarkdownProvider, type Effect, type EventSource, type EventSourceCallback, type EventSourceCloseCallback, type EventSourceErrorCallback, InProcessEventSource, type InlineActivityItem, InlineCode, InlineExecution, type InlineExecutionProps, type InlineExecutionStatus, type IslandTransitionConfig, Markdown, type MarkdownProps, MemoizedMarkdown, PendingIndicator, type PendingIndicatorProps, PermissionRequestCard, type PermissionRequestCardProps, type PlatformActions, PlatformProvider, type PointerSnapshot, type ProcessResult, type RenderMode, ResponseCard, type ResponseCardProps, type ResponseContent, SIZE_CONFIG, SSEEventSource, type Session, type SessionState, SessionViewer, type SessionViewerMode, type SessionViewerProps, type StreamingState, SystemMessage, type SystemMessageProps, type SystemMessageType, type SystemTurn, type TextSegment, type TodoItem, type Turn, TurnCard, type TurnCardProps, UserMessageBubble, type UserMessageBubbleProps, type UserTurn, WebSocketEventSource, appendMessage, buildAnnotationChipEntryTransition, buildSelectionEntryTransition, collectTextSegments, computeAnnotationOverlayGeometry, createSelectionPreviewAnnotation, createTextSelectionAnnotation, findAssistantMessage, findStreamingMessage, findToolMessage, generateMessageId, getAssistantTurnUiKey, getCanonicalText, groupMessagesByTurn, hasExistingTextRangeAnnotation, mapCoreEventToProcessorEvent, mapTimelineEnvelopeToProcessorEvent, processEvent, resolveNodeOffset, shouldShowStreamingContent, updateMessageAt, useEventProcessor };
+
+// -- @weft/ui/lib/en-fallback.d.ts --
+/**
+ * English fallback translations for UI components.
+ *
+ * Used by:
+ * - `TurnCard.tsx` `t()` wrapper — when i18next is uninitialized or has no resource for a key
+ * - `apps/demo/src/i18n-init.ts` — as the primary `en` resource bundle
+ *
+ * Single source of truth — add new keys here, both consumers stay synchronized.
+ */
+declare const EN_FALLBACK: Record<string, string>;
+
+export { EN_FALLBACK };
+
+// ── inlined from @weft/runtime-core ──
+// -- @weft/runtime-core/index.d.ts --
+
+declare const RUNTIME_KINDS: readonly ["native-sdk", "app-server", "compatible-sdk", "cli-fallback"];
+type AgentRuntimeKind = typeof RUNTIME_KINDS[number];
+type AgentRuntimeStatus = 'idle' | 'preflighting' | 'ready' | 'starting' | 'running' | 'waiting_for_permission' | 'turn_completed' | 'completed' | 'failed' | 'disposed';
+
+/**
+ * How a provider's authentication is managed.
+ * Provider-neutral auth mode — covers native SDK, app-server, compatible SDK, and CLI fallback.
+ */
+type ProviderAuthMode = 'provider-owned' | 'managed' | 'none';
+/**
+ * Result of probing a provider's auth configuration.
+ *
+ * For provider-owned auth: checks whether the provider binary reports
+ * authentication as configured (e.g. `claude auth status --json` returns
+ * `loggedIn: true`, or `codex app-server account/read` returns an account).
+ *
+ * For managed auth: checks whether required env vars are present.
+ * For 'none': no auth required (e.g. fake backend for testing).
+ */
+interface ProviderAuthDetection {
+    /** Which auth mode this provider uses */
+    mode: ProviderAuthMode;
+    /** Whether auth credentials are available and valid */
+    configured: boolean;
+    /** How auth was detected (e.g. "claude auth status --json", "env vars") */
+    source: string;
+    /** Whether an account was found (provider-owned: from CLI output) */
+    accountPresent?: boolean;
+    /** Whether OpenAI auth is required (Codex-specific) */
+    requiresOpenaiAuth?: boolean;
+    /** Auth method reported by provider (e.g. "oauth", "api_key") */
+    method?: string;
+    /** Provider name reported by CLI (e.g. "anthropic") */
+    provider?: string;
+    /** Error message if auth detection failed */
+    error?: string;
+}
+/**
+ * Narrowed auth detection for runtime capability reports.
+ * Only covers provider-owned auth, which is the SDK-first default.
+ */
+interface RuntimeAuthDetection extends ProviderAuthDetection {
+    mode: 'provider-owned';
+}
+interface RuntimeCandidate {
+    kind: AgentRuntimeKind;
+    available: boolean;
+    reason?: string;
+}
+interface RuntimeSelectionOptions {
+    provider?: string;
+    candidates: RuntimeCandidate[];
+    preferredRuntime?: AgentRuntimeKind;
+    allowFallback?: boolean;
+}
+interface RuntimeSelection {
+    selected?: AgentRuntimeKind;
+    fallback: boolean;
+    fallbackReason?: string;
+    error?: string;
+}
+interface RuntimeCapabilityReport extends RuntimeSelection {
+    provider: string;
+    candidates: RuntimeCandidate[];
+    preferredRuntime?: AgentRuntimeKind;
+    allowFallback: boolean;
+    auth: RuntimeAuthDetection;
+    policyCapabilities: RuntimePolicyCapabilities;
+    sourceCapabilities: RuntimeSourceCapabilities;
+    skillCapabilities: RuntimeSkillCapabilities;
+    automationCapabilities: RuntimeAutomationCapabilities;
+    hostToolCapabilities: RuntimeHostToolCapabilities;
+}
+interface CreateRuntimeCapabilityReportOptions extends RuntimeSelectionOptions {
+    provider: string;
+    auth: RuntimeAuthDetection;
+    extensionCapabilities?: RuntimeExtensionCapabilities;
+}
+interface AgentRuntimeOptions {
+    provider: string;
+    cwd: string;
+    sessionId?: string;
+    model?: string;
+    reasoningEffort?: string;
+    permissionMode?: PermissionMode;
+    authMode?: 'provider-owned';
+    preferredRuntime?: AgentRuntimeKind;
+    allowFallback?: boolean;
+    executable?: string;
+    env?: Record<string, string>;
+    extensions?: RuntimeExtensionContext;
+}
+interface SendMessageOptions {
+    turnId?: string;
+    model?: string;
+    reasoningEffort?: string;
+    permissionMode?: PermissionMode;
+    commandOrigin?: CommandOrigin;
+}
+type ToolPolicyDecision = {
+    decision: 'allow';
+} | {
+    decision: 'ask';
+    reason: string;
+} | {
+    decision: 'deny';
+    reason: string;
+};
+interface CodexPermissionParams {
+    approvalPolicy: string;
+    approvalsReviewer: string;
+    sandbox: string;
+}
+/**
+ * Canonical PermissionMode → Codex permission parameters mapping, shared by
+ * the app-server driver (thread/start, turn/start), the host controller, and
+ * the CLI fallback runtime. `sandbox` is a Codex `SandboxMode` string as used
+ * by `thread/start` and `codex exec --sandbox`.
+ */
+declare function mapPermissionModeToCodexParams(mode: PermissionMode): CodexPermissionParams;
+/**
+ * Codex app-server v2 `turn/start` takes a tagged `SandboxPolicy` object,
+ * unlike `thread/start` which takes a plain `SandboxMode` string. Variant
+ * fields are all serde-defaulted, so the minimal `{ type }` form is valid.
+ */
+declare function mapCodexSandboxModeToSandboxPolicy(sandbox: string): {
+    type: string;
+};
+type RuntimePermissionScope = {
+    type: 'session';
+    sessionId: string;
+} | {
+    type: 'workspace';
+    workspaceId: string;
+} | {
+    type: 'source';
+    sourceSlug: string;
+} | {
+    type: 'skill';
+    skillSlug: string;
+} | {
+    type: 'automation';
+    automationId: string;
+} | {
+    type: 'tool-call';
+    callId: string;
+};
+type RuntimePermissionScopeInput = string | RuntimePermissionScope;
+type RuntimeToolIntent = {
+    kind: 'bash';
+    command: string;
+    baseCommand: string;
+} | {
+    kind: 'file_write';
+    path: string;
+    toolName: string;
+} | {
+    kind: 'mcp';
+    name: string;
+} | {
+    kind: 'api';
+    method: string;
+    path: string;
+    url?: string;
+} | {
+    kind: 'unknown';
+    toolName: string;
+};
+interface ToolPolicyRequest {
+    toolName: string;
+    input?: Record<string, unknown>;
+    toolIntent?: RuntimeToolIntent;
+    scope?: RuntimePermissionScopeInput;
+}
+type RuntimePolicyHook = (request: ToolPolicyRequest) => ToolPolicyDecision | Promise<ToolPolicyDecision>;
+interface RuntimeFeatureCapabilities {
+    supported: boolean;
+    degraded?: boolean;
+    reason?: string;
+}
+interface RuntimePolicyCapabilities extends RuntimeFeatureCapabilities {
+    modes: PermissionMode[];
+    approvals: boolean;
+    toolPolicy: boolean;
+}
+interface RuntimeSourceCapabilities extends RuntimeFeatureCapabilities {
+    registry?: boolean;
+    credentialGateway?: boolean;
+    mcpTools?: boolean;
+}
+interface RuntimeSkillCapabilities extends RuntimeFeatureCapabilities {
+    registry?: boolean;
+    activationPlan?: boolean;
+    scopedPolicy?: boolean;
+}
+interface RuntimeAutomationCapabilities extends RuntimeFeatureCapabilities {
+    eventBus: boolean;
+    schedulerHost: boolean;
+    promptAction: boolean;
+    webhookAction: boolean;
+}
+interface RuntimeHostToolCapabilities extends RuntimeFeatureCapabilities {
+    sessionTools: boolean;
+    workflowTransitions: boolean;
+    browserActions: boolean;
+    metadataWrites: boolean;
+}
+interface RuntimeExtensionCapabilities {
+    policy?: RuntimePolicyCapabilities;
+    sources?: RuntimeSourceCapabilities;
+    skills?: RuntimeSkillCapabilities;
+    automations?: RuntimeAutomationCapabilities;
+    hostTools?: RuntimeHostToolCapabilities;
+}
+interface RuntimePolicyExtension {
+    mode: PermissionMode;
+    hook?: RuntimePolicyHook;
+    degraded?: boolean;
+}
+interface SourceSelection {
+    enabledSourceSlugs: string[];
+}
+interface ProviderSourceCredentialRef {
+    type: string;
+    sourceSlug: string;
+    workspaceId?: string;
+}
+type ProviderSourceToolDescriptor = {
+    kind: 'api-source';
+    sourceSlug: string;
+    baseUrl: string;
+    authType: string;
+    defaultHeaders?: Record<string, string>;
+    credentialRef?: ProviderSourceCredentialRef;
+    [key: string]: unknown;
+} | {
+    kind: 'local-source';
+    sourceSlug: string;
+    path: string;
+    format?: string;
+    [key: string]: unknown;
+} | {
+    kind: 'mcp-server';
+    sourceSlug: string;
+    transport: 'stdio' | 'http' | 'sse';
+    url?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    headers?: Record<string, string>;
+    credentialRef?: ProviderSourceCredentialRef;
+    [key: string]: unknown;
+};
+interface SkillSelection {
+    activeSkillSlugs: string[];
+}
+type CommandOrigin = {
+    type: 'user';
+    id?: string;
+} | {
+    type: 'automation';
+    id: string;
+} | {
+    type: 'scheduler';
+    id?: string;
+} | {
+    type: 'host';
+    id?: string;
+} | {
+    type: 'replay';
+    id?: string;
+} | {
+    type: 'system';
+    id?: string;
+};
+interface SubmitPlanRequest {
+    sessionId?: string;
+    planRef: string;
+    origin?: CommandOrigin;
+}
+interface SubmitPlanReceipt {
+    accepted: boolean;
+    planRef?: string;
+    reason?: string;
+}
+interface SourceAuthRequest {
+    sessionId?: string;
+    sourceSlug: string;
+    reason?: string;
+}
+interface SourceAuthReceipt {
+    ok: boolean;
+    sourceSlug: string;
+    reason?: string;
+}
+interface SourceActivationRequest {
+    sessionId?: string;
+    sourceSlug: string;
+}
+interface SourceActivationReceipt {
+    ok: boolean;
+    sourceSlug: string;
+    availability?: 'immediate' | 'next-turn';
+    reason?: string;
+}
+interface BrowserActionRequest {
+    sessionId?: string;
+    action: string;
+    input?: unknown;
+}
+interface BrowserActionReceipt {
+    ok: boolean;
+    result?: unknown;
+    reason?: string;
+}
+interface SpawnSessionRequest {
+    parentSessionId?: string;
+    prompt: string;
+    model?: string;
+    commandOrigin?: CommandOrigin;
+}
+interface SpawnSessionReceipt {
+    sessionId: string;
+}
+interface InterSessionMessageRequest {
+    sessionId: string;
+    message: string;
+    attachments?: Array<{
+        path: string;
+        name?: string;
+    }>;
+    commandOrigin?: CommandOrigin;
+}
+interface CommandReceipt {
+    ok: boolean;
+    commandId?: string;
+    reason?: string;
+}
+interface SessionMetadataPatch {
+    sessionId?: string;
+    labels?: string[];
+    status?: string;
+    flagged?: boolean;
+    topic?: string;
+}
+interface SessionMetadataSnapshot {
+    sessionId?: string;
+    labels?: string[];
+    status?: string;
+    flagged?: boolean;
+    topic?: string;
+}
+interface SessionListRequest {
+    status?: string;
+    labels?: string[];
+    limit?: number;
+}
+interface SessionListResult {
+    sessions: SessionMetadataSnapshot[];
+}
+interface LlmToolRequest {
+    prompt: string;
+    model?: string;
+    commandOrigin?: CommandOrigin;
+}
+interface LlmToolResult {
+    text: string;
+    model?: string;
+    usage?: unknown;
+}
+interface ListSourcesRequest {
+    sessionId?: string;
+    enabledOnly?: boolean;
+}
+interface SourceSummary {
+    slug: string;
+    name: string;
+    provider: string;
+    type: string;
+    enabled: boolean;
+    isAuthenticated?: boolean;
+    connectionStatus?: string;
+    tagline?: string;
+}
+interface ListSourcesResult {
+    sources: SourceSummary[];
+}
+interface GetSourceRequest {
+    sessionId?: string;
+    sourceSlug: string;
+}
+interface GetSourceResult {
+    source: SourceSummary & {
+        createdAt?: number;
+        updatedAt?: number;
+        mcp?: Record<string, unknown>;
+        api?: Record<string, unknown>;
+        local?: Record<string, unknown>;
+    };
+}
+interface CreateSourceRequest {
+    sessionId?: string;
+    name: string;
+    provider: string;
+    type: string;
+    mcp?: Record<string, unknown>;
+    api?: Record<string, unknown>;
+    local?: Record<string, unknown>;
+    icon?: string;
+    enabled?: boolean;
+}
+interface CreateSourceResult {
+    ok: boolean;
+    source?: SourceSummary;
+    reason?: string;
+}
+interface UpdateSourceRequest {
+    sessionId?: string;
+    sourceSlug: string;
+    enabled?: boolean;
+    name?: string;
+    icon?: string;
+    tagline?: string;
+}
+interface UpdateSourceResult {
+    ok: boolean;
+    source?: SourceSummary;
+    reason?: string;
+}
+interface DeleteSourceRequest {
+    sessionId?: string;
+    sourceSlug: string;
+}
+interface DeleteSourceResult {
+    ok: boolean;
+    sourceSlug: string;
+    reason?: string;
+}
+interface ListSkillsRequest {
+    sessionId?: string;
+}
+interface SkillSummary {
+    slug: string;
+    name: string;
+    description: string;
+    source: string;
+    icon?: string;
+    globs?: string[];
+    requiredSources?: string[];
+}
+interface ListSkillsResult {
+    skills: SkillSummary[];
+}
+interface GetSkillRequest {
+    sessionId?: string;
+    skillSlug: string;
+}
+interface GetSkillResult {
+    skill: SkillSummary & {
+        content: string;
+        alwaysAllow?: string[];
+    };
+}
+interface CreateSkillRequest {
+    sessionId?: string;
+    slug: string;
+    name: string;
+    description: string;
+    content: string;
+    globs?: string[];
+    alwaysAllow?: string[];
+    icon?: string;
+    requiredSources?: string[];
+}
+interface CreateSkillResult {
+    ok: boolean;
+    skill?: SkillSummary;
+    reason?: string;
+}
+interface UpdateSkillRequest {
+    sessionId?: string;
+    skillSlug: string;
+    name?: string;
+    description?: string;
+    content?: string;
+    globs?: string[];
+    alwaysAllow?: string[];
+    icon?: string;
+    requiredSources?: string[];
+}
+interface UpdateSkillResult {
+    ok: boolean;
+    skill?: SkillSummary;
+    reason?: string;
+}
+interface DeleteSkillRequest {
+    sessionId?: string;
+    skillSlug: string;
+}
+interface DeleteSkillResult {
+    ok: boolean;
+    skillSlug: string;
+    reason?: string;
+}
+interface GetAutomationsConfigRequest {
+    sessionId?: string;
+}
+interface GetAutomationsConfigResult {
+    config: Record<string, unknown> | null;
+    configPath: string;
+}
+interface UpdateAutomationsConfigRequest {
+    sessionId?: string;
+    config: Record<string, unknown>;
+}
+interface UpdateAutomationsConfigResult {
+    ok: boolean;
+    automationCount?: number;
+    errors?: string[];
+}
+interface ListSchedulesRequest {
+    sessionId?: string;
+}
+interface ScheduleSummary {
+    schedulerId: string;
+    workspaceId: string;
+    cron: string;
+    timezone: string;
+}
+interface ListSchedulesResult {
+    schedules: ScheduleSummary[];
+}
+interface StartScheduleRequest {
+    sessionId?: string;
+    schedulerId: string;
+    workspaceId: string;
+    cron: string;
+    timezone: string;
+}
+interface StartScheduleResult {
+    schedulerId: string;
+    state: 'started' | 'stopped';
+    timestamp: number;
+}
+interface StopScheduleRequest {
+    sessionId?: string;
+    schedulerId: string;
+}
+interface StopScheduleResult {
+    ok: boolean;
+    schedulerId: string;
+    state?: 'stopped';
+    reason?: string;
+}
+interface SessionToolBridge {
+    submitPlan?(request: SubmitPlanRequest): Promise<SubmitPlanReceipt>;
+    requestSourceAuth?(request: SourceAuthRequest): Promise<SourceAuthReceipt>;
+    activateSource?(request: SourceActivationRequest): Promise<SourceActivationReceipt>;
+    runBrowserAction?(request: BrowserActionRequest): Promise<BrowserActionReceipt>;
+    spawnSession?(request: SpawnSessionRequest): Promise<SpawnSessionReceipt>;
+    sendSessionMessage?(request: InterSessionMessageRequest): Promise<CommandReceipt>;
+    updateSessionMetadata?(request: SessionMetadataPatch): Promise<SessionMetadataSnapshot>;
+    listSessions?(request: SessionListRequest): Promise<SessionListResult>;
+    queryLlm?(request: LlmToolRequest): Promise<LlmToolResult>;
+    listSources?(request: ListSourcesRequest): Promise<ListSourcesResult>;
+    getSource?(request: GetSourceRequest): Promise<GetSourceResult>;
+    createSource?(request: CreateSourceRequest): Promise<CreateSourceResult>;
+    updateSource?(request: UpdateSourceRequest): Promise<UpdateSourceResult>;
+    deleteSource?(request: DeleteSourceRequest): Promise<DeleteSourceResult>;
+    listSkills?(request: ListSkillsRequest): Promise<ListSkillsResult>;
+    getSkill?(request: GetSkillRequest): Promise<GetSkillResult>;
+    createSkill?(request: CreateSkillRequest): Promise<CreateSkillResult>;
+    updateSkill?(request: UpdateSkillRequest): Promise<UpdateSkillResult>;
+    deleteSkill?(request: DeleteSkillRequest): Promise<DeleteSkillResult>;
+    getAutomationsConfig?(request: GetAutomationsConfigRequest): Promise<GetAutomationsConfigResult>;
+    updateAutomationsConfig?(request: UpdateAutomationsConfigRequest): Promise<UpdateAutomationsConfigResult>;
+    listSchedules?(request: ListSchedulesRequest): Promise<ListSchedulesResult>;
+    startSchedule?(request: StartScheduleRequest): Promise<StartScheduleResult>;
+    stopSchedule?(request: StopScheduleRequest): Promise<StopScheduleResult>;
+}
+type SessionToolName = keyof SessionToolBridge;
+type SessionToolRequest = SubmitPlanRequest | SourceAuthRequest | SourceActivationRequest | BrowserActionRequest | SpawnSessionRequest | InterSessionMessageRequest | SessionMetadataPatch | SessionListRequest | LlmToolRequest | ListSourcesRequest | GetSourceRequest | CreateSourceRequest | UpdateSourceRequest | DeleteSourceRequest | ListSkillsRequest | GetSkillRequest | CreateSkillRequest | UpdateSkillRequest | DeleteSkillRequest | GetAutomationsConfigRequest | UpdateAutomationsConfigRequest | ListSchedulesRequest | StartScheduleRequest | StopScheduleRequest;
+interface SessionToolTimelineRef {
+    epoch: string;
+    seq: number;
+}
+interface SessionToolInvocationReceipt {
+    ok: boolean;
+    requestId: string;
+    toolName: SessionToolName;
+    origin?: CommandOrigin;
+    policyDecision: ToolPolicyDecision;
+    result?: unknown;
+    reason?: string;
+    timelineRefs: SessionToolTimelineRef[];
+}
+interface InvokeSessionToolOptions {
+    sessionId: string;
+    toolName: SessionToolName;
+    request: SessionToolRequest;
+    bridge: SessionToolBridge;
+    policy?: RuntimePolicyHook;
+    commandOrigin?: CommandOrigin;
+    appendTimeline?: (item: TimelineItem) => TimelineEnvelope;
+}
+interface RuntimeHostServices {
+    sessionTools?: SessionToolBridge;
+}
+interface RuntimeExtensionContext {
+    policy?: RuntimePolicyExtension;
+    sources?: SourceSelection;
+    skills?: SkillSelection;
+    commandOrigin?: CommandOrigin;
+    hostServices?: RuntimeHostServices;
+}
+interface AgentCommandSink {
+    sendMessage(message: string, options?: SendMessageOptions): Promise<void>;
+    abort(reason?: string): Promise<void>;
+    respondToPermission(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
+    resumeTool?(runId: string, resumeData: Record<string, unknown>): Promise<void>;
+    dispose(): Promise<void>;
+}
+interface AgentEventStream {
+    connect(onEvent: (event: AgentEvent) => void, onError?: (error: Error) => void, onClose?: () => void): void;
+    disconnect(): void;
+    isConnected(): boolean;
+}
+interface AgentTimelineStream {
+    connect(onEvent: (event: TimelineEnvelope) => void, onError?: (error: Error) => void, onClose?: () => void): void;
+    disconnect(): void;
+    isConnected(): boolean;
+}
+interface AgentRuntimeState {
+    status: AgentRuntimeStatus;
+    acceptedMessages: string[];
+    queuedMessages: string[];
+    lastError?: string;
+    waitingPermissionRequestId?: string;
+}
+type RuntimeAction = {
+    type: 'preflight_start';
+} | {
+    type: 'preflight_ok';
+} | {
+    type: 'preflight_error';
+    error: string;
+} | {
+    type: 'starting';
+} | {
+    type: 'send_message';
+    message: string;
+} | {
+    type: 'permission_request';
+    requestId: string;
+} | {
+    type: 'permission_response';
+} | {
+    type: 'turn_completed';
+} | {
+    type: 'complete';
+} | {
+    type: 'abort';
+    reason?: string;
+} | {
+    type: 'error';
+    error: string;
+} | {
+    type: 'dispose';
+};
+declare const initialRuntimeState: AgentRuntimeState;
+/**
+ * Canonical state machine reducer for AgentRuntime lifecycle.
+ *
+ * Transitions follow the architecture spec:
+ *   idle → preflighting → ready → starting → running
+ *   running → waiting_for_permission → running
+ *   running → turn_completed → ready
+ *   running → ready (via complete with empty queue)
+ *   any → failed / disposed
+ *   any non-disposed → ready (via abort)
+ *
+ * `send_message` while running enqueues (session manager semantics).
+ * `complete` drains the queue: if a queued message exists, it is
+ * immediately accepted and the state stays running.
+ */
+declare function reduceRuntimeState(state: AgentRuntimeState | undefined, action: RuntimeAction): AgentRuntimeState;
+interface AgentRuntime {
+    readonly sessionId: string;
+    readonly provider: string;
+    readonly runtimeKind: AgentRuntimeKind;
+    readonly events: AgentTimelineStream;
+    readonly commands: AgentCommandSink;
+    preflight(): Promise<RuntimeCapabilityReport>;
+    fetchTimeline(request: TimelineFetchRequest): Promise<TimelineFetchResult>;
+    getState(): AgentRuntimeState;
+}
+declare function createRuntimeExtensionContext(context?: RuntimeExtensionContext): RuntimeExtensionContext;
+declare function sanitizeProviderSourceTools(sourceTools: ProviderSourceToolDescriptor[] | undefined): ProviderSourceToolDescriptor[];
+declare function invokeSessionTool(options: InvokeSessionToolOptions): Promise<SessionToolInvocationReceipt>;
+declare function selectRuntimeCandidate(options: RuntimeSelectionOptions): RuntimeSelection;
+declare function createRuntimeCapabilityReport(options: CreateRuntimeCapabilityReportOptions): RuntimeCapabilityReport;
+
+export { type AgentCommandSink, type AgentEventStream, type AgentRuntime, type AgentRuntimeKind, type AgentRuntimeOptions, type AgentRuntimeState, type AgentRuntimeStatus, type AgentTimelineStream, type BrowserActionReceipt, type BrowserActionRequest, type CodexPermissionParams, type CommandOrigin, type CommandReceipt, type CreateRuntimeCapabilityReportOptions, type CreateSkillRequest, type CreateSkillResult, type CreateSourceRequest, type CreateSourceResult, type DeleteSkillRequest, type DeleteSkillResult, type DeleteSourceRequest, type DeleteSourceResult, type GetAutomationsConfigRequest, type GetAutomationsConfigResult, type GetSkillRequest, type GetSkillResult, type GetSourceRequest, type GetSourceResult, type InterSessionMessageRequest, type InvokeSessionToolOptions, type ListSchedulesRequest, type ListSchedulesResult, type ListSkillsRequest, type ListSkillsResult, type ListSourcesRequest, type ListSourcesResult, type LlmToolRequest, type LlmToolResult, type ProviderAuthDetection, type ProviderAuthMode, type ProviderSourceCredentialRef, type ProviderSourceToolDescriptor, RUNTIME_KINDS, type RuntimeAction, type RuntimeAuthDetection, type RuntimeAutomationCapabilities, type RuntimeCandidate, type RuntimeCapabilityReport, type RuntimeExtensionCapabilities, type RuntimeExtensionContext, type RuntimeFeatureCapabilities, type RuntimeHostServices, type RuntimeHostToolCapabilities, type RuntimePermissionScope, type RuntimePermissionScopeInput, type RuntimePolicyCapabilities, type RuntimePolicyExtension, type RuntimePolicyHook, type RuntimeSelection, type RuntimeSelectionOptions, type RuntimeSkillCapabilities, type RuntimeSourceCapabilities, type RuntimeToolIntent, type ScheduleSummary, type SendMessageOptions, type SessionListRequest, type SessionListResult, type SessionMetadataPatch, type SessionMetadataSnapshot, type SessionToolBridge, type SessionToolInvocationReceipt, type SessionToolName, type SessionToolRequest, type SessionToolTimelineRef, type SkillSelection, type SkillSummary, type SourceActivationReceipt, type SourceActivationRequest, type SourceAuthReceipt, type SourceAuthRequest, type SourceSelection, type SourceSummary, type SpawnSessionReceipt, type SpawnSessionRequest, type StartScheduleRequest, type StartScheduleResult, type StopScheduleRequest, type StopScheduleResult, type SubmitPlanReceipt, type SubmitPlanRequest, type ToolPolicyDecision, type ToolPolicyRequest, type UpdateAutomationsConfigRequest, type UpdateAutomationsConfigResult, type UpdateSkillRequest, type UpdateSkillResult, type UpdateSourceRequest, type UpdateSourceResult, createRuntimeCapabilityReport, createRuntimeExtensionContext, initialRuntimeState, invokeSessionTool, mapCodexSandboxModeToSandboxPolicy, mapPermissionModeToCodexParams, reduceRuntimeState, sanitizeProviderSourceTools, selectRuntimeCandidate };
+
+// ── inlined from @weft/local-chat ──
+// -- @weft/local-chat/index.d.ts --
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+interface LocalChatAuthDetection {
+    provider: string;
+    configured: boolean;
+    source?: string;
+    error?: string;
+}
+interface LocalChatRuntimeState {
+    status: 'idle' | 'preflighting' | 'running' | 'ready' | 'failed' | string;
+}
+interface LocalChatEventSource {
+    connect(onEvent: (event: AgentEvent) => void, onError?: (error: Error) => void, onClose?: () => void): void;
+    disconnect(): void;
+    isConnected(): boolean;
+}
+interface LocalChatCommandSink {
+    sendMessage(message: string): Promise<void>;
+    abort(reason?: string): Promise<void>;
+    respondToPermission(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
+}
+interface LocalChatSessionRuntime {
+    sessionId: string;
+    provider: string;
+    events: LocalChatEventSource;
+    commands: LocalChatCommandSink;
+    preflight(): Promise<LocalChatAuthDetection>;
+    getState(): LocalChatRuntimeState;
+}
+interface AgentChatSessionModel {
+    session: Session | null;
+    turns: Turn[];
+    isRunning: boolean;
+    auth: LocalChatAuthDetection | null;
+    error: Error | null;
+    sendMessage(message: string): Promise<void>;
+    abort(): Promise<void>;
+    respondToPermission(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
+}
+interface UseAgentChatSessionOptions {
+    runtime: LocalChatSessionRuntime;
+    workspaceId?: string;
+    workspaceName?: string;
+}
+interface TimelineChatPanelModel {
+    session: Session;
+    turns: Turn[];
+}
+type TimelineDetailKind = 'permission' | 'runtime' | 'source' | 'skill' | 'automation' | 'host' | 'tool';
+interface TimelineDetailItem {
+    id: string;
+    kind: TimelineDetailKind;
+    title: string;
+    summary?: string;
+    status?: string;
+    timestamp: number;
+    detail: unknown;
+    envelope: TimelineEnvelope;
+}
+interface TimelineAgentChatSessionModel extends TimelineChatPanelModel {
+    timeline: TimelineEnvelope[];
+    isRunning: boolean;
+    isConnected: boolean;
+    isReconnecting: boolean;
+    hasGap: boolean;
+    capabilityReport: RuntimeCapabilityReport | null;
+    error: Error | null;
+    sendMessage(message: string): Promise<void>;
+    abort(): Promise<void>;
+    respondToPermission(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
+}
+interface UseTimelineAgentChatSessionOptions {
+    runtime: AgentRuntime;
+    workspaceId?: string;
+    workspaceName?: string;
+}
+declare function createAgentChatPanelModel(args: {
+    session: Session | null;
+    runtime: LocalChatSessionRuntime;
+    auth?: LocalChatAuthDetection | null;
+    error?: Error | null;
+}): Pick<AgentChatSessionModel, 'turns' | 'isRunning' | 'auth' | 'error'>;
+declare function createAgentChatPanelModelFromTimeline(args: {
+    timeline: TimelineEnvelope[];
+    sessionId: string;
+    workspaceId: string;
+    workspaceName?: string;
+}): TimelineChatPanelModel;
+declare function createTimelineAgentChatPanelModel(args: {
+    timeline: TimelineEnvelope[];
+    sessionId: string;
+    workspaceId: string;
+    workspaceName?: string;
+    runtimeState: AgentRuntimeState;
+    capabilityReport: RuntimeCapabilityReport | null;
+    error: Error | null;
+}): Pick<TimelineAgentChatSessionModel, 'session' | 'turns' | 'isRunning' | 'capabilityReport' | 'error'>;
+declare function createTimelineDetailItems(timeline: TimelineEnvelope[]): TimelineDetailItem[];
+declare function useAgentChatSession(options: UseAgentChatSessionOptions): AgentChatSessionModel;
+declare function useTimelineAgentChatSession(options: UseTimelineAgentChatSessionOptions): TimelineAgentChatSessionModel;
+
+interface AgentChatPanelProps {
+    runtime: LocalChatSessionRuntime;
+    workspaceId?: string;
+    workspaceName?: string;
+    platformActions?: PlatformActions;
+    placeholder?: string;
+    className?: string;
+}
+declare function AgentChatPanel({ runtime, workspaceId, workspaceName, platformActions, placeholder, className, }: AgentChatPanelProps): react_jsx_runtime.JSX.Element;
+
+interface TimelineAgentChatPanelProps {
+    /** Agent runtime instance from runtime-core */
+    runtime: AgentRuntime;
+    /** Workspace identifier */
+    workspaceId?: string;
+    /** Workspace display name */
+    workspaceName?: string;
+    /** Platform actions for file/URL handling */
+    platformActions?: PlatformActions;
+    /** Placeholder text for the input area */
+    placeholder?: string;
+    /** Whether to show the runtime status bar */
+    showStatusBar?: boolean;
+    /** Whether to show the runtime detail sidebar panel */
+    showDetailPanel?: boolean;
+    /** Additional className */
+    className?: string;
+}
+declare function TimelineAgentChatPanel({ runtime, workspaceId, workspaceName, platformActions, placeholder, showStatusBar, showDetailPanel, className, }: TimelineAgentChatPanelProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Find the active (unresolved) permission request from timeline envelopes.
+ *
+ * Walks the timeline backwards to find the most recent permission_requested
+ * envelope that has not been resolved by a matching permission_resolved.
+ */
+declare function findActivePermissionRequest(timeline: TimelineEnvelope[]): {
+    requestId: string;
+    toolName: string;
+    input?: Record<string, unknown>;
+    reason?: string;
+    scope?: {
+        type: string;
+        label?: string;
+    };
+} | null;
+
+/**
+ * Convert a processor Session (returned by useAgentChatSession) into a
+ * StoredSession that SessionViewer can render.
+ *
+ * Consumers embedding AgentChatPanel don't need this — it's called internally.
+ * This utility is exported for consumers who use useAgentChatSession directly
+ * and build their own panel around SessionViewer.
+ */
+declare function toStoredSession(session: Session, fallbackWorkspaceId?: string): StoredSession;
+/**
+ * Build an empty StoredSession placeholder for the initial state
+ * before the event processor has received any events.
+ */
+declare function createEmptyStoredSession(sessionId: string, workspaceId?: string, workspaceName?: string): StoredSession;
+
+export { AgentChatPanel, type AgentChatPanelProps, type AgentChatSessionModel, type LocalChatAuthDetection, type LocalChatCommandSink, type LocalChatEventSource, type LocalChatRuntimeState, type LocalChatSessionRuntime, TimelineAgentChatPanel, type TimelineAgentChatPanelProps, type TimelineAgentChatSessionModel, type TimelineChatPanelModel, type TimelineDetailItem, type TimelineDetailKind, type UseAgentChatSessionOptions, type UseTimelineAgentChatSessionOptions, createAgentChatPanelModel, createAgentChatPanelModelFromTimeline, createEmptyStoredSession, createTimelineAgentChatPanelModel, createTimelineDetailItems, findActivePermissionRequest, toStoredSession, useAgentChatSession, useTimelineAgentChatSession };
+
+// ── inlined from @weft/provider-flitro ──
+// -- @weft/provider-flitro/index.d.ts --
+import { FlitroHttpClient, FlitroClientOptions } from '@percena/weft-client';
+export { FlitroCapabilityReport, FlitroClientOptions, FlitroFetchSseTimelineStream, FlitroHttpClient, FlitroModelInfo, FlitroModelListResult, FlitroPatchSessionOptions, FlitroRun, FlitroSession, FlitroSseTimelineStream, FlitroSseTimelineStreamOptions, FlitroTimelineFetchResult, FlitroTimelineItem, TimelineSubscription, WeftClient, WeftClientOptions, createFlitroTimelineStream } from '@percena/weft-client';
+
+/**
+ * FlitroProviderRuntimeDriver
+ *
+ * Sends messages to the Flitro Go server and routes permission responses back.
+ * Implements the same driver interface pattern as provider-claude's
+ * ClaudeProviderRuntimeDriver.
+ */
+
+interface FlitroDriverInput {
+    message: string;
+    options?: SendMessageOptions;
+}
+interface FlitroProviderRuntimeDriver {
+    sendMessage(input: FlitroDriverInput, sequencer: TimelineSequencer): Promise<void>;
+    abort?(reason?: string): Promise<void>;
+    respondToPermission?(requestId: string, allowed: boolean, remember?: boolean): Promise<void>;
+    resumeTool?(runId: string, resumeData: Record<string, unknown>): Promise<void>;
+    dispose?(): Promise<void>;
+}
+interface CreateFlitroDriverOptions {
+    client: FlitroHttpClient;
+    sessionId: string;
+    /** LLM model override sent to Flitro */
+    model?: string;
+    /** Skill names to activate for each message */
+    skillNames?: string[];
+    /** MCP server names to attach */
+    mcpServerNames?: string[];
+    /** Default approval policy: "auto", "require_all", "deny_all" */
+    approvalPolicy?: string;
+}
+/**
+ * Creates a runtime driver that delegates to the Flitro server.
+ *
+ * sendMessage creates a Flitro Run (one message = one turn = one Run).
+ * The timeline events flow back via the SSE stream set up separately.
+ */
+declare function createFlitroDriver(options: CreateFlitroDriverOptions): FlitroProviderRuntimeDriver;
+
+/**
+ * FlitroCapabilityProbe
+ *
+ * Detects whether a Flitro server is reachable and authenticated, then
+ * builds the RuntimeCandidate list for createFlitroRuntimeCapabilityReport.
+ */
+
+interface FlitroCapabilityProbeResult {
+    serverAvailable: boolean;
+    authenticated: boolean;
+    serverReason?: string;
+    authReason?: string;
+    candidates: RuntimeCandidate[];
+    auth: RuntimeAuthDetection;
+}
+/**
+ * Probe the Flitro server and return availability + auth candidates.
+ *
+ * Flitro is always an "app-server" runtime kind — it runs as an external
+ * process (the Go agentd binary) that the TypeScript provider communicates
+ * with over HTTP.
+ */
+declare function probeFlitroCapabilities(client: FlitroHttpClient): Promise<FlitroCapabilityProbeResult>;
+
+/**
+ * @weft/provider-flitro
+ *
+ * Weft Runtime Provider for the Flitro Go Agent Server.
+ *
+ * Flitro is the 3rd AgentRuntime alongside Claude and Codex:
+ *  - provider-claude  → Claude Agent SDK (native-sdk) / claude -p (cli-fallback)
+ *  - provider-codex   → Codex app-server / codex exec (cli-fallback)
+ *  - provider-flitro  → Flitro agentd HTTP API (app-server)
+ *
+ * Integration model:
+ *  - Flitro runs as the Go backend (stateful, multi-tenant, concurrent)
+ *  - This provider wraps Flitro's REST+SSE API as a Weft AgentRuntime
+ *  - Weft policy, sources, and skills are forwarded as API parameters
+ *  - The Weft UI (TurnCard, etc.) consumes the canonical timeline
+ */
+
+interface CreateFlitroRuntimeCandidatesOptions {
+    appServerAvailable: boolean;
+    appServerReason?: string;
+}
+declare function createFlitroRuntimeCandidates(options: CreateFlitroRuntimeCandidatesOptions): RuntimeCandidate[];
+interface CreateFlitroRuntimeCapabilityReportOptions {
+    candidates: RuntimeCandidate[];
+    auth: RuntimeAuthDetection;
+    allowFallback?: boolean;
+    extensions?: RuntimeExtensionContext;
+}
+declare function createFlitroRuntimeCapabilityReport(options: CreateFlitroRuntimeCapabilityReportOptions): RuntimeCapabilityReport;
+interface CreateFlitroProviderRuntimeOptions extends CreateFlitroRuntimeCapabilityReportOptions {
+    /** Flitro server connection options */
+    server: FlitroClientOptions;
+    /** Session ID — if omitted a new session is created on first sendMessage */
+    sessionId?: string;
+    /** Epoch string for the timeline (default: derived from sessionId) */
+    epoch?: string;
+    now?: () => number;
+    /** LLM model to use */
+    model?: string;
+    /** Skills to activate per turn */
+    skillNames?: string[];
+    /** MCP servers to attach per turn */
+    mcpServerNames?: string[];
+    /** Approval policy */
+    approvalPolicy?: string;
+    /** Injected runtime extensions (policy, sources, etc.) */
+    extensions?: RuntimeExtensionContext;
+    /** Pre-built driver (for testing) */
+    driver?: FlitroProviderRuntimeDriver;
+}
+/**
+ * Create a Weft AgentRuntime backed by the Flitro Go server.
+ *
+ * Usage:
+ * ```ts
+ * const runtime = createFlitroProviderRuntime({
+ *   server: { baseUrl: 'http://localhost:8080', apiKey: 'secret' },
+ *   candidates: [{ kind: 'app-server', available: true }],
+ *   auth: { mode: 'provider-owned', configured: true, source: 'flitro' },
+ *   sessionId: 'my-session',
+ * })
+ * await runtime.preflight()
+ * await runtime.commands.sendMessage('Hello!')
+ * ```
+ */
+declare function createFlitroProviderRuntime(options: CreateFlitroProviderRuntimeOptions): AgentRuntime;
+interface CreateFlitroEmbedRuntimeOptions {
+    /** Flitro server base URL, as returned by `POST /v1/embed/sessions`. */
+    baseUrl: string;
+    /** Scoped session token, as returned by `POST /v1/embed/sessions`. */
+    token: string;
+    /** Session bound to the token, as returned by `POST /v1/embed/sessions`. */
+    sessionId: string;
+    /** Re-fetch a token from the host backend when the current one expires. */
+    onTokenExpired?: () => Promise<string | undefined> | string | undefined;
+    epoch?: string;
+    now?: () => number;
+    extensions?: RuntimeExtensionContext;
+}
+/**
+ * Create an AgentRuntime for an embedded (third-party website) chat panel.
+ *
+ * The host backend bootstraps the session via Flitro's `POST /v1/embed/sessions`
+ * (with its developer API key) and hands `{ baseUrl, token, sessionId }` to the
+ * browser. Execution mode, permission envelope, approval policy, and the tool
+ * whitelist are fixed server-side, so no runtime auth or policy configuration
+ * is needed here.
+ */
+declare function createFlitroEmbedRuntime(options: CreateFlitroEmbedRuntimeOptions): AgentRuntime;
+interface CreateFlitroRuntimeOptions {
+    /** Flitro server connection options */
+    server: FlitroClientOptions;
+    sessionId?: string;
+    epoch?: string;
+    now?: () => number;
+    model?: string;
+    skillNames?: string[];
+    mcpServerNames?: string[];
+    approvalPolicy?: string;
+    allowFallback?: boolean;
+    extensions?: RuntimeExtensionContext;
+}
+/**
+ * High-level factory: probes the Flitro server, then creates the runtime.
+ *
+ * Equivalent to the pattern used by createHostAgentRuntime() in runtime-factory.
+ */
+declare function createFlitroRuntime(options: CreateFlitroRuntimeOptions): Promise<AgentRuntime>;
+
+export { type CreateFlitroDriverOptions, type CreateFlitroEmbedRuntimeOptions, type CreateFlitroProviderRuntimeOptions, type CreateFlitroRuntimeCandidatesOptions, type CreateFlitroRuntimeCapabilityReportOptions, type CreateFlitroRuntimeOptions, type FlitroCapabilityProbeResult, type FlitroProviderRuntimeDriver, createFlitroDriver, createFlitroEmbedRuntime, createFlitroProviderRuntime, createFlitroRuntime, createFlitroRuntimeCandidates, createFlitroRuntimeCapabilityReport, probeFlitroCapabilities };