@hyperdrive.bot/fleet-client 0.3.99

package/dist/daemon-client.d.ts

@@ -0,0 +1,1530 @@
+import type { z } from "zod";
+import { type ClientCapability } from "@hyperdrive.bot/fleet-protocol/client-capabilities";
+import { AgentRefreshedStatusPayloadSchema, CheckoutRenameBranchResponseSchema, RenameTerminalResponseSchema, RestartRequestedStatusPayloadSchema, ShutdownRequestedStatusPayloadSchema, DaemonUpdateResponseSchema, type ServerInfoStatusPayload } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { SourceKind } from "@hyperdrive.bot/fleet-protocol/ingestion/types";
+import type { FilterDraft, FilterPatch } from "@hyperdrive.bot/fleet-protocol/ingestion/rpc-schemas";
+import type { ScheduleCadence } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+import type { AgentStreamEventPayload, InstalledExtension, AgentSnapshotPayload, ProjectPlacementPayload, AgentPermissionResolvedMessage, CreateAgentRequestMessage, CreatePaseoWorktreeRequest, FileDownloadTokenResponse, FileExplorerResponse, FetchAgentTimelineResponseMessage, AgentForkContextResponseMessage, GitSetupOptions, CheckoutStatusResponse, CheckoutCommitResponse, CheckoutMergeResponse, CheckoutMergeFromBaseResponse, CheckoutPullResponse, CheckoutPushResponse, CheckoutRefreshResponse, CheckoutPrCreateResponse, CheckoutPrMergeResponse, CheckoutPrMergeMethod, CheckoutGithubSetAutoMergeResponse, CheckoutGithubGetCheckDetailsResponse, CheckoutPrStatusResponse, PullRequestTimelineResponse, CheckoutSwitchBranchResponse, StashSaveResponse, StashPopResponse, StashListResponse, ValidateBranchResponse, BranchSuggestionsResponse, GitHubSearchResponse, GitHubSearchRequest, DirectorySuggestionsResponse, PaseoWorktreeListResponse, PaseoWorktreeArchiveResponse, ProjectIconResponse, ProjectAddResponse, OpenProjectResponseMessage, ArchiveWorkspaceResponseMessage, WorkspaceSetupStatusResponseMessage, ListCommandsResponse, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ListProviderModesResponseMessage, ListAvailableProvidersResponse, GetProvidersSnapshotResponseMessage, RefreshProvidersSnapshotResponseMessage, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, DaemonGetStatusResponse, DaemonGetPairingOfferResponse, DiagnosticsResponse, AgentRewindResponseMessage, ListTerminalsResponse, CreateTerminalResponse, SubscribeTerminalResponse, SubscribeTerminalRequest, CloseItemsResponse, KillTerminalResponse, CaptureAgentPaneResponse, CaptureTerminalResponse, TerminalInput, SessionInboundMessage, SessionOutboundMessage, SendAgentMessageRequest, PaseoConfigRaw, PaseoConfigRevision, ProjectRenameResponse, BackgroundTaskPayload, ReferenceEnrichment, SessionDigest, SessionDigestLink, WatchNotificationActionMessage, WatchSessionSearchMessage, WatchComposerDictateMessage, WorkflowAgentPreset, WorkflowSnapshot, WorkflowStatus, WorkflowTaskGraph, WorkspaceCreateRequest, PendingDecision } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { AgentPermissionRequest, AgentPermissionResponse, AgentPersistenceHandle, AgentProviderNotice, AgentProvider, AgentSessionConfig } from "@hyperdrive.bot/fleet-protocol/agent-types";
+import type { MutableDaemonConfig, MutableDaemonConfigPatch, ProvidersReloadConfigPayload } from "@hyperdrive.bot/fleet-protocol/messages";
+import type { FileUploadErrorCode } from "@hyperdrive.bot/fleet-protocol/messages";
+import { type DaemonTransportFactory, type WebSocketFactory } from "./daemon-client-transport.js";
+import { type TerminalStreamEvent } from "./terminal-stream-router.js";
+import type { BrowserAutomationExecuteRequest, BrowserAutomationExecuteResponse } from "@hyperdrive.bot/fleet-protocol/browser-automation/rpc-schemas";
+export interface Logger {
+    debug(obj: object, msg?: string): void;
+    info(obj: object, msg?: string): void;
+    warn(obj: object, msg?: string): void;
+    error(obj: object, msg?: string): void;
+}
+interface ImportAgentInputBase {
+    cwd?: string;
+    labels?: Record<string, string>;
+}
+export type ImportAgentInput = (ImportAgentInputBase & {
+    providerId: string;
+    providerHandleId: string;
+}) | (ImportAgentInputBase & {
+    provider: AgentProvider;
+    sessionId: string;
+});
+export type { DaemonTransport, DaemonTransportFactory, WebSocketFactory, WebSocketLike, } from "./daemon-client-transport.js";
+export type { TerminalStreamEvent };
+export type ConnectionState = {
+    status: "idle";
+} | {
+    status: "connecting";
+    attempt: number;
+} | {
+    status: "connected";
+} | {
+    status: "disconnected";
+    reason?: string;
+} | {
+    status: "disposed";
+};
+export type DaemonEvent = {
+    type: "agent_update";
+    agentId: string;
+    payload: Extract<SessionOutboundMessage, {
+        type: "agent_update";
+    }>["payload"];
+} | {
+    type: "workspace_update";
+    workspaceId: string;
+    payload: Extract<SessionOutboundMessage, {
+        type: "workspace_update";
+    }>["payload"];
+} | {
+    type: "workspace_setup_progress";
+    workspaceId: string;
+    payload: Extract<SessionOutboundMessage, {
+        type: "workspace_setup_progress";
+    }>["payload"];
+} | {
+    type: "agent_stream";
+    agentId: string;
+    event: AgentStreamEventPayload;
+    timestamp: string;
+    seq?: number;
+    epoch?: string;
+} | {
+    type: "status";
+    payload: {
+        status: string;
+    } & Record<string, unknown>;
+} | {
+    type: "agent_deleted";
+    agentId: string;
+} | {
+    type: "agent_permission_request";
+    agentId: string;
+    request: AgentPermissionRequest;
+} | {
+    type: "agent_permission_resolved";
+    agentId: string;
+    requestId: string;
+    resolution: AgentPermissionResponse;
+} | {
+    type: "providers_snapshot_update";
+    payload: Extract<SessionOutboundMessage, {
+        type: "providers_snapshot_update";
+    }>["payload"];
+} | {
+    type: "error";
+    message: string;
+};
+export type DaemonEventHandler = (event: DaemonEvent) => void;
+export type BrowserAutomationExecuteRequestMessage = BrowserAutomationExecuteRequest;
+export type BrowserAutomationExecuteResponseMessage = BrowserAutomationExecuteResponse;
+export interface DaemonClientConfig {
+    url: string;
+    clientId: string;
+    clientType?: "mobile" | "browser" | "cli" | "mcp";
+    appVersion?: string;
+    runtimeGeneration?: number | null;
+    password?: string;
+    authHeader?: string;
+    suppressSendErrors?: boolean;
+    transportFactory?: DaemonTransportFactory;
+    webSocketFactory?: WebSocketFactory;
+    logger?: Logger;
+    connectTimeoutMs?: number;
+    e2ee?: {
+        enabled?: boolean;
+        daemonPublicKeyB64?: string;
+    };
+    reconnect?: {
+        enabled?: boolean;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+    };
+    runtimeMetricsIntervalMs?: number;
+    runtimeMetricsWindowMs?: number;
+    /**
+     * Override for how long a queued message waits for the WebSocket connection
+     * before its send is rejected with "Timed out waiting for connection".
+     * Defaults to {@link DEFAULT_SEND_QUEUE_TIMEOUT_MS} (10s). The mobile/host
+     * runtime ships a 2s override (Story B.2 / FR2.2) so the UI can render a
+     * "Reconnecting to daemon…" Suspense fallback quickly when the daemon is
+     * unreachable, instead of blocking the JS thread for ~10s per failing RPC.
+     */
+    defaultSendQueueTimeoutMs?: number;
+    capabilities?: Partial<Record<ClientCapability, unknown>>;
+}
+export interface SendMessageOptions {
+    messageId?: string;
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+    attachments?: SendAgentMessageRequest["attachments"];
+}
+type AgentConfigOverrides = Partial<Omit<AgentSessionConfig, "provider" | "cwd">>;
+export interface CreateAgentRequestOptions extends AgentConfigOverrides {
+    config?: AgentSessionConfig;
+    provider?: AgentProvider;
+    cwd?: string;
+    env?: CreateAgentRequestMessage["env"];
+    workspaceId?: string;
+    initialPrompt?: string;
+    clientMessageId?: string;
+    outputSchema?: Record<string, unknown>;
+    images?: CreateAgentRequestMessage["images"];
+    attachments?: CreateAgentRequestMessage["attachments"];
+    git?: GitSetupOptions;
+    worktree?: CreateAgentRequestMessage["worktree"];
+    autoArchive?: CreateAgentRequestMessage["autoArchive"];
+    worktreeName?: string;
+    requestId?: string;
+    labels?: Record<string, string>;
+    resumeSessionId?: string;
+    routine?: CreateAgentRequestMessage["routine"];
+}
+export interface CreatePaseoWorktreeInput extends Pick<CreatePaseoWorktreeRequest, "cwd" | "projectId" | "worktreeSlug" | "firstAgentContext" | "refName" | "action" | "githubPrNumber"> {
+}
+type CheckoutStatusPayload = CheckoutStatusResponse["payload"];
+type SubscribeCheckoutDiffPayload = Extract<SessionOutboundMessage, {
+    type: "subscribe_checkout_diff_response";
+}>["payload"];
+type CheckoutDiffPayload = Omit<SubscribeCheckoutDiffPayload, "subscriptionId">;
+type CheckoutCommitPayload = CheckoutCommitResponse["payload"];
+type CheckoutMergePayload = CheckoutMergeResponse["payload"];
+type CheckoutMergeFromBasePayload = CheckoutMergeFromBaseResponse["payload"];
+type CheckoutPullPayload = CheckoutPullResponse["payload"];
+type CheckoutPushPayload = CheckoutPushResponse["payload"];
+type CheckoutRefreshPayload = CheckoutRefreshResponse["payload"];
+type CheckoutPrCreatePayload = CheckoutPrCreateResponse["payload"];
+type CheckoutPrMergePayload = CheckoutPrMergeResponse["payload"];
+type CheckoutGithubSetAutoMergePayload = CheckoutGithubSetAutoMergeResponse["payload"];
+type CheckoutGithubGetCheckDetailsPayload = CheckoutGithubGetCheckDetailsResponse["payload"];
+type CheckoutPrStatusPayload = CheckoutPrStatusResponse["payload"];
+type PullRequestTimelinePayload = PullRequestTimelineResponse["payload"];
+type CheckoutSwitchBranchPayload = CheckoutSwitchBranchResponse["payload"];
+export type RenameBranchResult = z.infer<typeof CheckoutRenameBranchResponseSchema>["payload"];
+type StashSavePayload = StashSaveResponse["payload"];
+type StashPopPayload = StashPopResponse["payload"];
+type StashListPayload = StashListResponse["payload"];
+type ValidateBranchPayload = ValidateBranchResponse["payload"];
+type BranchSuggestionsPayload = BranchSuggestionsResponse["payload"];
+type GitHubSearchPayload = GitHubSearchResponse["payload"];
+type DirectorySuggestionsPayload = DirectorySuggestionsResponse["payload"];
+type PaseoWorktreeListPayload = PaseoWorktreeListResponse["payload"];
+type PaseoWorktreeArchivePayload = PaseoWorktreeArchiveResponse["payload"];
+type CreatePaseoWorktreePayload = Extract<SessionOutboundMessage, {
+    type: "create_paseo_worktree_response";
+}>["payload"];
+type WorkspaceCreatePayload = Extract<SessionOutboundMessage, {
+    type: "workspace.create.response";
+}>["payload"];
+type FileExplorerPayload = FileExplorerResponse["payload"];
+export type FileExplorerDirectoryPayload = NonNullable<FileExplorerPayload["directory"]>;
+type LegacyFileExplorerFilePayload = NonNullable<FileExplorerPayload["file"]>;
+export interface FileReadResult {
+    bytes: Uint8Array;
+    mime: string;
+    size: number;
+    path: string;
+    kind: LegacyFileExplorerFilePayload["kind"];
+    modifiedAt: string;
+}
+type FileDownloadTokenPayload = FileDownloadTokenResponse["payload"];
+type ListProviderFeaturesPayload = ListProviderFeaturesResponseMessage["payload"];
+type ListProviderModelsPayload = ListProviderModelsResponseMessage["payload"];
+type ListProviderModesPayload = ListProviderModesResponseMessage["payload"];
+type ListAvailableProvidersPayload = ListAvailableProvidersResponse["payload"];
+type GetProvidersSnapshotPayload = GetProvidersSnapshotResponseMessage["payload"];
+type RefreshProvidersSnapshotPayload = RefreshProvidersSnapshotResponseMessage["payload"];
+type ProviderDiagnosticPayload = ProviderDiagnosticResponseMessage["payload"];
+type ProviderUsageListPayload = ProviderUsageListResponseMessage["payload"];
+type DaemonStatusPayload = DaemonGetStatusResponse["payload"];
+type DaemonPairingOfferPayload = DaemonGetPairingOfferResponse["payload"];
+type DiagnosticsPayload = DiagnosticsResponse["payload"];
+type ReadProjectConfigPayload = Extract<SessionOutboundMessage, {
+    type: "read_project_config_response";
+}>["payload"];
+type WriteProjectConfigPayload = Extract<SessionOutboundMessage, {
+    type: "write_project_config_response";
+}>["payload"];
+type ListCommandsPayload = ListCommandsResponse["payload"];
+type ListCommandsDraftConfig = Pick<AgentSessionConfig, "provider" | "cwd" | "modeId" | "model" | "thinkingOptionId" | "featureValues">;
+export interface WriteProjectConfigInput {
+    repoRoot: string;
+    config: PaseoConfigRaw;
+    expectedRevision: PaseoConfigRevision | null;
+    requestId?: string;
+}
+interface ListCommandsOptions {
+    agentId: string;
+    requestId?: string;
+    draftConfig?: ListCommandsDraftConfig;
+}
+type LegacyListCommandsOptions = Omit<ListCommandsOptions, "agentId">;
+type SetVoiceModePayload = Extract<SessionOutboundMessage, {
+    type: "set_voice_mode_response";
+}>["payload"];
+type AgentPermissionResolvedPayload = AgentPermissionResolvedMessage["payload"];
+type ListTerminalsPayload = ListTerminalsResponse["payload"];
+type CreateTerminalPayload = CreateTerminalResponse["payload"];
+export type RenameTerminalResult = z.infer<typeof RenameTerminalResponseSchema>["payload"];
+type SubscribeTerminalPayload = SubscribeTerminalResponse["payload"];
+type CloseItemsPayload = CloseItemsResponse["payload"];
+type KillTerminalPayload = KillTerminalResponse["payload"];
+type CaptureTerminalPayload = CaptureTerminalResponse["payload"];
+type CaptureAgentPanePayload = CaptureAgentPaneResponse["payload"];
+type ChatCreatePayload = Extract<SessionOutboundMessage, {
+    type: "chat/create/response";
+}>["payload"];
+type ChatListPayload = Extract<SessionOutboundMessage, {
+    type: "chat/list/response";
+}>["payload"];
+type ChatInspectPayload = Extract<SessionOutboundMessage, {
+    type: "chat/inspect/response";
+}>["payload"];
+type ChatDeletePayload = Extract<SessionOutboundMessage, {
+    type: "chat/delete/response";
+}>["payload"];
+type ChatPostPayload = Extract<SessionOutboundMessage, {
+    type: "chat/post/response";
+}>["payload"];
+type ChatReadPayload = Extract<SessionOutboundMessage, {
+    type: "chat/read/response";
+}>["payload"];
+type ChatWaitPayload = Extract<SessionOutboundMessage, {
+    type: "chat/wait/response";
+}>["payload"];
+type LoopRunPayload = Extract<SessionOutboundMessage, {
+    type: "loop/run/response";
+}>["payload"];
+type LoopListPayload = Extract<SessionOutboundMessage, {
+    type: "loop/list/response";
+}>["payload"];
+type LoopInspectPayload = Extract<SessionOutboundMessage, {
+    type: "loop/inspect/response";
+}>["payload"];
+type LoopLogsPayload = Extract<SessionOutboundMessage, {
+    type: "loop/logs/response";
+}>["payload"];
+type LoopStopPayload = Extract<SessionOutboundMessage, {
+    type: "loop/stop/response";
+}>["payload"];
+type FleetListPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/list/response";
+}>["payload"];
+type FleetInspectPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/inspect/response";
+}>["payload"];
+type FleetRunNowPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/run-now/response";
+}>["payload"];
+type FleetPausePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/pause/response";
+}>["payload"];
+type FleetResumePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/resume/response";
+}>["payload"];
+type FleetAskPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/ask/response";
+}>["payload"];
+type FleetDecisionsPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/decisions/response";
+}>["payload"];
+type FleetResolveDecisionPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/resolve-decision/response";
+}>["payload"];
+type FleetSetParamsPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/set-params/response";
+}>["payload"];
+type FleetSetModePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/set-mode/response";
+}>["payload"];
+type FleetCreatePayload = Extract<SessionOutboundMessage, {
+    type: "fleet/create/response";
+}>["payload"];
+type FleetExecutionsPayload = Extract<SessionOutboundMessage, {
+    type: "fleet/executions/response";
+}>["payload"];
+export interface InspectFleetLoopOptions {
+    requestId?: string;
+    name: string;
+}
+export interface SetFleetLoopModeOptions {
+    requestId?: string;
+    name: string;
+    mode: "live" | "dry-run";
+}
+export interface AskFleetDecisionOptions {
+    requestId?: string;
+    name: string;
+    kind: "gate-approval" | "action-approval" | "outcome-review";
+    question: string;
+    posture: "blocking" | "deferring" | "advisory";
+    options: Array<{
+        id: string;
+        label: string;
+        effect: {
+            kind: "act" | "rehearse" | "defer" | "suppress";
+            reversibility: "reversible" | "compensable" | "irreversible";
+            compensatingAction?: string;
+        };
+    }>;
+    runId?: string;
+    itemKey?: string;
+    evidence?: string;
+    onExpiry?: string;
+    expiresInMs?: number;
+}
+export interface ListFleetDecisionsOptions {
+    requestId?: string;
+    name?: string;
+    includeResolved?: boolean;
+}
+export interface ResolveFleetDecisionOptions {
+    requestId?: string;
+    decisionId: string;
+    optionId: string;
+}
+export interface SetFleetLoopParamsOptions {
+    requestId?: string;
+    name: string;
+    values: Record<string, string | number | boolean | string[]>;
+}
+export interface CreateFleetLoopOptions {
+    requestId?: string;
+    name: string;
+    description: string;
+    cron: string;
+    action: string;
+    mode?: "live" | "dry-run";
+    rails?: string;
+    allowed?: string;
+}
+type ScheduleCreatePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/create/response";
+}>["payload"];
+type ScheduleListPayload = Extract<SessionOutboundMessage, {
+    type: "schedule/list/response";
+}>["payload"];
+type IngestionBackfillPayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/backfill/response";
+}>["payload"];
+export type IngestionApplyPayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/apply/response";
+}>["payload"];
+export type IngestionCohortInspectPayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/cohort/inspect/response";
+}>["payload"];
+export type IngestionCohortCancelPayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/cohort/cancel/response";
+}>["payload"];
+/** Exported because `packages/app` (Story 6.3) renders this payload directly. */
+export type IngestionRunsPayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/runs/response";
+}>["payload"];
+export interface IngestionRunsOptions {
+    requestId?: string;
+    filterId: string;
+    /**
+     * Include the runs reconciliation has closed. Defaults to false at the daemon.
+     *
+     * Omit it. The Inbox wants open obligations, and the daemon's default is the
+     * one that cannot render a stale row by accident.
+     */
+    includeClosed?: boolean;
+}
+type ScheduleInspectPayload = Extract<SessionOutboundMessage, {
+    type: "schedule/inspect/response";
+}>["payload"];
+type ScheduleLogsPayload = Extract<SessionOutboundMessage, {
+    type: "schedule/logs/response";
+}>["payload"];
+type SchedulePausePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/pause/response";
+}>["payload"];
+type ScheduleResumePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/resume/response";
+}>["payload"];
+type ScheduleDeletePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/delete/response";
+}>["payload"];
+type ScheduleRunOncePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/run-once/response";
+}>["payload"];
+type ScheduleUpdatePayload = Extract<SessionOutboundMessage, {
+    type: "schedule/update/response";
+}>["payload"];
+type SourceCataloguePayload = Extract<SessionOutboundMessage, {
+    type: "source/catalogue/response";
+}>["payload"];
+type SourceConnectPayload = Extract<SessionOutboundMessage, {
+    type: "source/connect/response";
+}>["payload"];
+type SourceListPayload = Extract<SessionOutboundMessage, {
+    type: "source/list/response";
+}>["payload"];
+type SourceCheckPayload = Extract<SessionOutboundMessage, {
+    type: "source/check/response";
+}>["payload"];
+export type IngestionFilterListPayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/filter/list/response";
+}>["payload"];
+export type IngestionFilterCreatePayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/filter/create/response";
+}>["payload"];
+export type IngestionFilterUpdatePayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/filter/update/response";
+}>["payload"];
+export type IngestionFilterDeletePayload = Extract<SessionOutboundMessage, {
+    type: "ingestion/filter/delete/response";
+}>["payload"];
+export type FetchAgentTimelinePayload = FetchAgentTimelineResponseMessage["payload"];
+export type AgentForkContextPayload = AgentForkContextResponseMessage["payload"];
+export type FetchAgentTimelineDirection = FetchAgentTimelinePayload["direction"];
+export type FetchAgentTimelineProjection = FetchAgentTimelinePayload["projection"];
+export type FetchAgentTimelineCursor = NonNullable<FetchAgentTimelinePayload["startCursor"]>;
+export interface FetchAgentOptions {
+    agentId: string;
+    requestId?: string;
+    timeout?: number;
+}
+type LegacyFetchAgentOptions = Omit<FetchAgentOptions, "agentId">;
+export interface FetchAgentTimelineOptions {
+    direction?: FetchAgentTimelineDirection;
+    cursor?: FetchAgentTimelineCursor;
+    limit?: number;
+    projection?: FetchAgentTimelineProjection;
+    requestId?: string;
+    timeout?: number;
+}
+export interface AgentForkContextOptions {
+    boundaryMessageId?: string;
+    requestId?: string;
+}
+type AgentRefreshedStatusPayload = z.infer<typeof AgentRefreshedStatusPayloadSchema>;
+type RestartRequestedStatusPayload = z.infer<typeof RestartRequestedStatusPayloadSchema>;
+type ShutdownRequestedStatusPayload = z.infer<typeof ShutdownRequestedStatusPayloadSchema>;
+export interface ShutdownServerOptions {
+    requestId?: string;
+    timeout?: number;
+}
+export interface DaemonStatusOptions {
+    requestId?: string;
+    timeout?: number;
+}
+export interface DaemonPairingOfferOptions {
+    requestId?: string;
+    timeout?: number;
+}
+type DaemonUpdateResponse = z.infer<typeof DaemonUpdateResponseSchema>;
+type FetchAgentsPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_agents_response";
+}>["payload"];
+type FetchAgentsRequest = Extract<SessionInboundMessage, {
+    type: "fetch_agents_request";
+}>;
+export type FetchAgentsOptions = Omit<FetchAgentsRequest, "type" | "requestId"> & {
+    requestId?: string;
+    timeout?: number;
+};
+export type FetchAgentsEntry = FetchAgentsPayload["entries"][number];
+export type FetchAgentsPageInfo = FetchAgentsPayload["pageInfo"];
+type FetchAgentHistoryPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_agent_history_response";
+}>["payload"];
+type FetchAgentHistoryRequest = Extract<SessionInboundMessage, {
+    type: "fetch_agent_history_request";
+}>;
+export type FetchAgentHistoryOptions = Omit<FetchAgentHistoryRequest, "type" | "requestId"> & {
+    requestId?: string;
+};
+export type FetchAgentHistoryEntry = FetchAgentHistoryPayload["entries"][number];
+export type FetchAgentHistoryPageInfo = FetchAgentHistoryPayload["pageInfo"];
+type FetchRecentProviderSessionsPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_recent_provider_sessions_response";
+}>["payload"];
+type FetchRecentProviderSessionsRequest = Extract<SessionInboundMessage, {
+    type: "fetch_recent_provider_sessions_request";
+}>;
+export type FetchRecentProviderSessionsOptions = Omit<FetchRecentProviderSessionsRequest, "type" | "requestId"> & {
+    requestId?: string;
+};
+export type FetchRecentProviderSessionEntry = FetchRecentProviderSessionsPayload["entries"][number];
+type FetchWorkspacesPayload = Extract<SessionOutboundMessage, {
+    type: "fetch_workspaces_response";
+}>["payload"];
+type FetchWorkspacesRequest = Extract<SessionInboundMessage, {
+    type: "fetch_workspaces_request";
+}>;
+export type FetchWorkspacesOptions = Omit<FetchWorkspacesRequest, "type" | "requestId"> & {
+    requestId?: string;
+};
+export type FetchWorkspacesEntry = FetchWorkspacesPayload["entries"][number];
+export type FetchWorkspacesPageInfo = FetchWorkspacesPayload["pageInfo"];
+export interface CreateChatRoomOptions {
+    name: string;
+    purpose?: string | null;
+    requestId?: string;
+}
+export interface InspectChatRoomOptions {
+    room: string;
+    requestId?: string;
+}
+export interface DeleteChatRoomOptions {
+    room: string;
+    requestId?: string;
+}
+export interface PostChatMessageOptions {
+    room: string;
+    body: string;
+    authorAgentId?: string;
+    replyToMessageId?: string | null;
+    requestId?: string;
+}
+export interface ReadChatMessagesOptions {
+    room: string;
+    limit?: number;
+    since?: string;
+    authorAgentId?: string;
+    requestId?: string;
+    timeout?: number;
+}
+export interface WaitForChatMessagesOptions {
+    room: string;
+    afterMessageId?: string | null;
+    timeoutMs?: number;
+    requestId?: string;
+}
+export interface RunLoopOptions {
+    prompt: string;
+    cwd: string;
+    provider?: string;
+    model?: string;
+    modeId?: string;
+    verifierProvider?: string;
+    verifierModel?: string;
+    verifierModeId?: string;
+    verifyPrompt?: string | null;
+    verifyChecks?: string[];
+    name?: string | null;
+    sleepMs?: number;
+    maxIterations?: number;
+    maxTimeMs?: number;
+    requestId?: string;
+}
+export interface InspectLoopOptions {
+    id: string;
+    requestId?: string;
+}
+export interface LoopLogsOptions {
+    id: string;
+    afterSeq?: number;
+    requestId?: string;
+}
+export interface StopLoopOptions {
+    id: string;
+    requestId?: string;
+}
+export interface CreateScheduleOptions {
+    prompt: string;
+    name?: string | null;
+    cadence: ScheduleCadence;
+    target: {
+        type: "self";
+        agentId: string;
+    } | {
+        type: "agent";
+        agentId: string;
+    } | {
+        type: "new-agent";
+        config: {
+            provider: AgentProvider;
+            cwd: string;
+            modeId?: string;
+            model?: string;
+            thinkingOptionId?: string;
+            title?: string | null;
+            approvalPolicy?: string;
+            sandboxMode?: string;
+            networkAccess?: boolean;
+            webSearch?: boolean;
+            extra?: AgentSessionConfig["extra"];
+            systemPrompt?: string;
+            mcpServers?: AgentSessionConfig["mcpServers"];
+        };
+    };
+    maxRuns?: number;
+    expiresAt?: string;
+    runOnCreate?: boolean;
+    requestId?: string;
+}
+export interface InspectScheduleOptions {
+    id: string;
+    requestId?: string;
+}
+export interface SourceCatalogueOptions {
+    kind: SourceKind;
+    query: string;
+    /** Opaque aggregator cursor from a previous page. Pass it back untouched, never parse it. */
+    cursor?: string;
+    requestId?: string;
+}
+export interface SourceConnectOptions {
+    kind: SourceKind;
+    appSlug: string;
+    requestId?: string;
+}
+export interface SourceCheckOptions {
+    sourceId: string;
+    requestId?: string;
+}
+export interface IngestionFilterListOptions {
+    /** Absent means every filter on the daemon. */
+    sourceId?: string;
+    requestId?: string;
+}
+export interface IngestionFilterCreateOptions {
+    draft: FilterDraft;
+    requestId?: string;
+}
+export interface IngestionFilterUpdateOptions {
+    filterId: string;
+    patch: FilterPatch;
+    requestId?: string;
+}
+export interface IngestionFilterDeleteOptions {
+    filterId: string;
+    requestId?: string;
+}
+export interface UpdateScheduleNewAgentConfig {
+    provider?: string;
+    model?: string | null;
+    modeId?: string | null;
+    cwd?: string;
+}
+export interface UpdateScheduleOptions {
+    id: string;
+    name?: string | null;
+    prompt?: string;
+    cadence?: ScheduleCadence;
+    newAgentConfig?: UpdateScheduleNewAgentConfig;
+    maxRuns?: number | null;
+    expiresAt?: string | null;
+    requestId?: string;
+}
+export interface RenameBranchInput {
+    cwd: string;
+    branch: string;
+    requestId?: string;
+}
+export interface RenameTerminalInput {
+    terminalId: string;
+    title: string;
+    requestId?: string;
+}
+type OpenProjectPayload = OpenProjectResponseMessage["payload"];
+type ProjectAddPayload = ProjectAddResponse["payload"];
+type ArchiveWorkspacePayload = ArchiveWorkspaceResponseMessage["payload"];
+type WorkspaceSetupStatusPayload = WorkspaceSetupStatusResponseMessage["payload"];
+export interface FetchAgentResult {
+    agent: AgentSnapshotPayload;
+    project: ProjectPlacementPayload | null;
+}
+export interface WaitForFinishResult {
+    status: "idle" | "error" | "permission" | "timeout";
+    final: AgentSnapshotPayload | null;
+    error: string | null;
+    lastMessage: string | null;
+}
+/**
+ * Thrown when an in-flight `uploadFile()` is cancelled via its `AbortSignal`.
+ * Distinct from {@link UploadCapExceededError} and {@link UploadFailedError} so
+ * Epic 5's attachment-chip UI can render the "cancelled" state specifically.
+ */
+export declare class UploadCancelledError extends Error {
+    readonly uploadId: string;
+    constructor(uploadId: string);
+}
+/**
+ * Thrown when the daemon rejects an upload because it exceeds the size cap —
+ * either the declared-size early reject at begin, or an incremental reject
+ * mid-stream (story 2.2). Carries the `too_large` code and any daemon detail.
+ */
+export declare class UploadCapExceededError extends Error {
+    readonly uploadId: string;
+    readonly code: Extract<FileUploadErrorCode, "too_large">;
+    constructor(uploadId: string, detail?: string);
+}
+/**
+ * Thrown for any other upload failure — transport error, `write_failed`,
+ * `checksum_mismatch`, or an unexpected daemon error. The third distinguishable
+ * reject path alongside cancelled and cap-exceeded.
+ */
+export declare class UploadFailedError extends Error {
+    readonly uploadId: string;
+    readonly code?: FileUploadErrorCode;
+    constructor(uploadId: string, message: string, code?: FileUploadErrorCode);
+}
+export declare class DaemonClient {
+    private config;
+    private transport;
+    private transportCleanup;
+    private rawMessageListeners;
+    private messageHandlers;
+    private eventListeners;
+    private waiters;
+    private checkoutStatusInFlight;
+    private connectionListeners;
+    private reconnectTimeout;
+    private connectTimeout;
+    private pendingGenericTransportErrorTimeout;
+    private reconnectAttempt;
+    private shouldReconnect;
+    private connectPromise;
+    private connectResolve;
+    private connectReject;
+    private lastErrorValue;
+    private connectionState;
+    private checkoutDiffSubscriptions;
+    private terminalDirectorySubscriptions;
+    private readonly terminalStreams;
+    private pendingBinaryFileReads;
+    private activeBinaryFileTransfers;
+    private completedBinaryFileReads;
+    private logger;
+    private pendingSendQueue;
+    private readonly logConnectionPath;
+    private readonly logServerId;
+    private readonly logClientIdHash;
+    private readonly logGeneration;
+    private lastServerInfoMessage;
+    private runtimeMetricsInterval;
+    private runtimeMetrics;
+    private pingProbe;
+    private livenessHeartbeatTimer;
+    private lastLivenessRttMs;
+    private consecutiveLivenessFailures;
+    constructor(config: DaemonClientConfig);
+    connect(): Promise<void>;
+    private attemptConnect;
+    private resolveConnect;
+    private rejectConnect;
+    close(): Promise<void>;
+    ensureConnected(): void;
+    getConnectionState(): ConnectionState;
+    subscribeConnectionStatus(listener: (status: ConnectionState) => void): () => void;
+    get isConnected(): boolean;
+    get isConnecting(): boolean;
+    get lastError(): string | null;
+    getLastLivenessRttMs(): number | null;
+    subscribe(handler: DaemonEventHandler): () => void;
+    subscribeRawMessages(handler: (message: SessionOutboundMessage) => void): () => void;
+    on<TType extends SessionOutboundMessage["type"]>(type: TType, handler: (message: Extract<SessionOutboundMessage, {
+        type: TType;
+    }>) => void): () => void;
+    on(handler: DaemonEventHandler): () => void;
+    /**
+     * Send a session message. For fire-and-forget messages (heartbeats, etc.),
+     * failures are suppressed if `suppressSendErrors` is configured.
+     * For RPC methods that wait for responses, use `sendSessionMessageOrThrow` instead.
+     */
+    private sendSessionMessage;
+    private sendBinaryFrame;
+    /**
+     * Send a session message for RPC methods that create waiters.
+     * If the connection is still being established ("connecting"), the message
+     * is queued and will be sent once connected (or rejected after timeout).
+     * This prevents waiters from hanging forever when called during connection.
+     */
+    private sendSessionMessageOrThrow;
+    /**
+     * Flush pending send queue - called when connection is established.
+     */
+    private flushPendingSendQueue;
+    /**
+     * Reject all pending sends - called when connection fails or is closed.
+     */
+    private rejectPendingSendQueue;
+    protected sendRequest<T>(params: {
+        requestId: string;
+        message: SessionInboundMessage;
+        timeout?: number;
+        select: (msg: SessionOutboundMessage) => T | null;
+        options?: {
+            skipQueue?: boolean;
+        };
+    }): Promise<T>;
+    private sendCorrelatedRequest;
+    private sendCorrelatedSessionRequest;
+    private sendNamespacedCorrelatedSessionRequest;
+    private sendSessionMessageStrict;
+    clearAgentAttention(agentId: string | string[]): Promise<void>;
+    clearWorkspaceAttention(workspaceId: string | string[]): Promise<void>;
+    sendHeartbeat(params: {
+        deviceType: "web" | "mobile";
+        focusedAgentId: string | null;
+        focusedTerminalId?: string | null;
+        lastActivityAt: string;
+        appVisible: boolean;
+        appVisibilityChangedAt?: string;
+    }): void;
+    registerPushToken(token: string): void;
+    /**
+     * Relay a watch-originated action (`watch.*`) over the existing WebSocket
+     * session transport. Fire-and-forget: the watch message types are already
+     * members of `SessionInboundMessageSchema`, so this forwards straight to the
+     * private `sendSessionMessage` path (`{ type: "session", message }`) — never
+     * an HTTP route, never a response-waiting RPC.
+     */
+    sendWatchAction(message: WatchNotificationActionMessage | WatchSessionSearchMessage | WatchComposerDictateMessage): void;
+    ping(params?: {
+        requestId?: string;
+        timeoutMs?: number;
+    }): Promise<{
+        requestId: string;
+        clientSentAt: number;
+        serverReceivedAt: number;
+        serverSentAt: number;
+        rttMs: number;
+    }>;
+    measureLatency(params?: {
+        timeoutMs?: number;
+    }): Promise<number>;
+    private livenessPing;
+    private sendPingAwaitRtt;
+    private startLivenessHeartbeat;
+    private stopLivenessHeartbeat;
+    private scheduleNextLivenessHeartbeat;
+    fetchAgents(options?: FetchAgentsOptions): Promise<FetchAgentsPayload>;
+    fetchAgentHistory(options?: FetchAgentHistoryOptions): Promise<FetchAgentHistoryPayload>;
+    fetchRecentProviderSessions(options?: FetchRecentProviderSessionsOptions): Promise<FetchRecentProviderSessionsPayload>;
+    fetchWorkspaces(options?: FetchWorkspacesOptions): Promise<FetchWorkspacesPayload>;
+    openProject(cwd: string, requestId?: string): Promise<OpenProjectPayload>;
+    addProject(cwd: string, requestId?: string): Promise<ProjectAddPayload>;
+    startWorkspaceScript(workspaceId: string, scriptName: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
+        type: "start_workspace_script_response";
+    }>["payload"]>;
+    archiveWorkspace(workspaceId: string, requestId?: string): Promise<ArchiveWorkspacePayload>;
+    /**
+     * Set or clear the user's custom project name override. Pass `null` (or an
+     * empty/whitespace string, which the server normalizes to `null`) to clear
+     * the override and fall back to the derived project name.
+     */
+    renameProject(projectId: string, customName: string | null, requestId?: string): Promise<ProjectRenameResponse["payload"]>;
+    fetchWorkspaceSetupStatus(workspaceId: string, requestId?: string): Promise<WorkspaceSetupStatusPayload>;
+    fetchAgent(options: FetchAgentOptions): Promise<FetchAgentResult | null>;
+    fetchAgent(agentId: string, requestId?: string): Promise<FetchAgentResult | null>;
+    fetchAgent(agentId: string, options?: LegacyFetchAgentOptions): Promise<FetchAgentResult | null>;
+    private resubscribeCheckoutDiffSubscriptions;
+    private resubscribeTerminalDirectorySubscriptions;
+    createAgent(options: CreateAgentRequestOptions): Promise<AgentSnapshotPayload>;
+    /**
+     * Create an agent and its standing routine in ONE request.
+     *
+     * Split from `createAgent` only because the caller needs the scheduleId back:
+     * `createAgent`'s return type has always been the bare snapshot, and widening
+     * it would ripple through every call site for a field almost none of them
+     * want. Both go through the same request, so there is no second code path for
+     * the daemon to disagree with.
+     */
+    createAgentWithRoutine(options: CreateAgentRequestOptions & {
+        routine: NonNullable<CreateAgentRequestOptions["routine"]>;
+    }): Promise<{
+        agent: AgentSnapshotPayload;
+        routine: {
+            scheduleId: string;
+            nextRunAt: string | null;
+        };
+    }>;
+    private createAgentRequest;
+    deleteAgent(agentId: string): Promise<void>;
+    archiveAgent(agentId: string): Promise<{
+        archivedAt: string;
+    }>;
+    /**
+     * Dismiss a live background shell. For Claude Code agents this drives the
+     * CLI's own `ctrl+x ctrl+k` kill chord over the PTY (kills it inside Claude
+     * Code). Resolves to whether the dismiss was delivered.
+     */
+    /**
+     * List background shells -- one agent's, or every agent's when `agentId` is
+     * omitted. These are commands the provider launched with `run_in_background`
+     * so they outlive the turn; the rows carry the command, status and start time
+     * so the client can show what is running and for how long.
+     */
+    listBackgroundTasks(agentId?: string): Promise<BackgroundTaskPayload[]>;
+    /**
+     * Record session context (links + non-live credentials) onto an agent's
+     * digest. Used by the context hook, which runs beside an agent rather than
+     * inside it and so cannot reach the agent-scoped `set_session_digest` MCP
+     * tool.
+     *
+     * Returns how many secrets the daemon had to mask, so a caller can report
+     * that it handed over something it should not have.
+     */
+    setAgentContext(input: {
+        agentId: string;
+        links?: {
+            kind: SessionDigestLink["kind"];
+            url: string;
+            label?: string;
+        }[];
+        secrets?: {
+            label: string;
+            value: string;
+            source?: string;
+        }[];
+    }): Promise<{
+        digest: SessionDigest | null;
+        maskedCount: number;
+        error?: string;
+    }>;
+    /**
+     * Ask the daemon what it can see about external reference URLs -- a GitLab
+     * pipeline's status, a merge request's state, a Jira issue's column.
+     *
+     * The provider credentials live on the daemon, so the app never holds one.
+     * An entry the daemon could not look up still comes back, carrying
+     * `unavailableReason`, so a card can say what it could not see instead of
+     * spinning. See docs/session-context-rail.md.
+     */
+    enrichReferences(urls: string[]): Promise<ReferenceEnrichment[]>;
+    /**
+     * Read a background shell's captured output. Resolves with `text: null` when
+     * the daemon does not know the shell or it captured nothing. The daemon tails
+     * and redacts before sending.
+     */
+    readBackgroundTaskOutput(agentId: string, taskId: string, options?: {
+        maxBytes?: number;
+    }): Promise<{
+        text: string | null;
+        truncated: boolean;
+        byteSize: number;
+    }>;
+    dismissBackgroundTask(agentId: string, taskId: string): Promise<{
+        dismissed: boolean;
+    }>;
+    detachAgent(agentId: string): Promise<void>;
+    /**
+     * `labels` is a PATCH: a string sets the key, `null` DELETES it, and an absent
+     * key is left untouched. Never pass a rebuilt whole bag - the daemon owns keys
+     * the client does not know about (schedules, loops, workflows, kanban).
+     *
+     * This method is the compat boundary. Callers get one coherent patch; the wire
+     * carries the deletions in a separate additive `labelsRemove` array, so an
+     * older daemon strips them instead of rejecting the whole request. Keeping the
+     * split here means no UI code has to know the encoding.
+     */
+    updateAgent(agentId: string, updates: {
+        name?: string;
+        labels?: Record<string, string | null>;
+    }): Promise<void>;
+    rewindSession(agentId: string, turnId: string): Promise<{
+        newSessionId: string;
+    }>;
+    editMessage(agentId: string, turnId: string, newContent: string): Promise<{
+        newSessionId: string;
+        adopted: boolean;
+    }>;
+    listWorkspaceSessions(workspaceId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<Array<{
+        sid: string;
+        title: string | null;
+        lastActivity: string;
+        cwd: string;
+        agentName: string | null;
+    }>>;
+    subscribePush(subscription: {
+        type: "expo";
+        token: string;
+    } | {
+        type: "web";
+        subscription: {
+            endpoint: string;
+            keys: {
+                p256dh: string;
+                auth: string;
+            };
+            expirationTime?: number | null;
+        };
+    }): Promise<{
+        ok: boolean;
+        vapidPublicKey?: string;
+    }>;
+    getVapidPublicKey(): Promise<string | null>;
+    listAllSessions(options?: {
+        signal?: AbortSignal;
+    }): Promise<Array<{
+        sid: string;
+        title: string | null;
+        lastActivity: string;
+        cwd: string;
+        agentName: string | null;
+    }>>;
+    listWorkflows(): Promise<WorkflowSnapshot[]>;
+    getWorkflow(workflowId: string): Promise<WorkflowSnapshot | null>;
+    cancelWorkflow(workflowId: string): Promise<WorkflowSnapshot>;
+    startWorkflow(input: {
+        graph: WorkflowTaskGraph;
+        provider: string;
+        cwd: string;
+        model?: string;
+        title?: string;
+        labels?: Record<string, string>;
+        agentPresets?: Record<string, WorkflowAgentPreset>;
+    }): Promise<{
+        workflowId: string;
+        childAgentIds: string[];
+        status: WorkflowStatus;
+    }>;
+    listExtensions(): Promise<InstalledExtension[]>;
+    executeExtensionCommand(commandId: string, args?: unknown[]): Promise<unknown>;
+    searchSessions(params: {
+        query: string;
+        limit?: number;
+        sources?: readonly string[];
+        signal?: AbortSignal;
+    }): Promise<Array<{
+        sid: string;
+        source: string;
+        cwd: string;
+        timestamp: string;
+        snippet: string;
+        resumeCommand: string;
+    }>>;
+    /**
+     * Derive the daemon's HTTP base URL from the WebSocket URL we connected with.
+     * Works for direct (ws://host:port/ws) and same-origin (web served by
+     * daemon). For relay-mode (wss://relay.../ws), HTTP routes against the
+     * daemon are not addressable — throws so callers fall back gracefully.
+     */
+    private getHttpBaseUrl;
+    private buildAuthHeader;
+    private daemonHttpJson;
+    removeProject(projectId: string, requestId?: string): Promise<{
+        removedWorkspaceIds: string[];
+    }>;
+    setWorkspaceTitle(workspaceId: string, title: string | null, requestId?: string): Promise<{
+        title: string | null;
+    }>;
+    /**
+     * Answer a decision the agent parked on its digest. `optionId: null` with a
+     * note is a free-text answer — an option the agent did not list.
+     */
+    answerAgentDecision(agentId: string, decisionId: string, optionId: string | null, note: string | null, requestId?: string): Promise<{
+        decision: PendingDecision | null;
+    }>;
+    resumeAgent(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>): Promise<AgentSnapshotPayload>;
+    importAgent(input: ImportAgentInput): Promise<AgentSnapshotPayload>;
+    refreshAgent(agentId: string, requestId?: string): Promise<AgentRefreshedStatusPayload>;
+    fetchAgentTimeline(agentId: string, options?: FetchAgentTimelineOptions): Promise<FetchAgentTimelinePayload>;
+    buildAgentForkContext(agentId: string, options?: AgentForkContextOptions): Promise<AgentForkContextPayload>;
+    sendAgentMessage(agentId: string, text: string, options?: SendMessageOptions): Promise<void>;
+    sendMessage(agentId: string, text: string, options?: SendMessageOptions): Promise<void>;
+    rewindAgent(agentId: string, messageId: string, mode: "conversation" | "files" | "both"): Promise<AgentRewindResponseMessage["payload"]>;
+    cancelAgent(agentId: string): Promise<void>;
+    setAgentMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
+    setAgentModel(agentId: string, modelId: string | null): Promise<void>;
+    /**
+     * Hot-swap a running agent's provider to a compatible one (e.g. Claude →
+     * Claude (Pool)). Throws if the swap is rejected by the daemon (incompatible
+     * wireFamily, target not in compatibleProviders list, target unavailable).
+     */
+    swapAgentProvider(agentId: string, newProviderId: string, overrides?: {
+        model?: string | null;
+        modeId?: string;
+    }): Promise<void>;
+    setAgentFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
+    setAgentThinkingOption(agentId: string, thinkingOptionId: string | null): Promise<AgentProviderNotice | null>;
+    restartServer(reason?: string, requestId?: string): Promise<RestartRequestedStatusPayload>;
+    shutdownServer(options?: ShutdownServerOptions): Promise<ShutdownRequestedStatusPayload>;
+    updateDaemon(requestId?: string): Promise<DaemonUpdateResponse["payload"]>;
+    setVoiceMode(enabled: boolean, agentId?: string, language?: string): Promise<SetVoiceModePayload>;
+    sendVoiceAudioChunk(audio: string, format: string, isLast?: boolean): Promise<void>;
+    startDictationStream(dictationId: string, format: string, language?: string): Promise<void>;
+    sendDictationStreamChunk(dictationId: string, seq: number, audio: string, format: string): void;
+    finishDictationStream(dictationId: string, finalSeq: number): Promise<{
+        dictationId: string;
+        text: string;
+    }>;
+    cancelDictationStream(dictationId: string): void;
+    abortRequest(): Promise<void>;
+    audioPlayed(id: string): Promise<void>;
+    getCheckoutStatus(cwd: string, options?: {
+        requestId?: string;
+    }): Promise<CheckoutStatusPayload>;
+    private normalizeCheckoutDiffCompare;
+    getCheckoutDiff(cwd: string, compare: {
+        mode: "uncommitted" | "base";
+        baseRef?: string;
+        ignoreWhitespace?: boolean;
+    }, requestId?: string): Promise<CheckoutDiffPayload>;
+    subscribeCheckoutDiff(cwd: string, compare: {
+        mode: "uncommitted" | "base";
+        baseRef?: string;
+        ignoreWhitespace?: boolean;
+    }, options?: {
+        subscriptionId?: string;
+        requestId?: string;
+    }): Promise<SubscribeCheckoutDiffPayload>;
+    unsubscribeCheckoutDiff(subscriptionId: string): void;
+    checkoutCommit(cwd: string, input: {
+        message?: string;
+        addAll?: boolean;
+    }, requestId?: string): Promise<CheckoutCommitPayload>;
+    checkoutMerge(cwd: string, input: {
+        baseRef?: string;
+        strategy?: "merge" | "squash";
+        requireCleanTarget?: boolean;
+    }, requestId?: string): Promise<CheckoutMergePayload>;
+    checkoutMergeFromBase(cwd: string, input: {
+        baseRef?: string;
+        requireCleanTarget?: boolean;
+    }, requestId?: string): Promise<CheckoutMergeFromBasePayload>;
+    checkoutPull(cwd: string, requestId?: string): Promise<CheckoutPullPayload>;
+    checkoutPush(cwd: string, requestId?: string): Promise<CheckoutPushPayload>;
+    checkoutRefresh(cwd: string, requestId?: string): Promise<CheckoutRefreshPayload>;
+    checkoutPrCreate(cwd: string, input: {
+        title?: string;
+        body?: string;
+        baseRef?: string;
+    }, requestId?: string): Promise<CheckoutPrCreatePayload>;
+    checkoutPrMerge(cwd: string, input: {
+        method: CheckoutPrMergeMethod;
+    }, requestId?: string): Promise<CheckoutPrMergePayload>;
+    checkoutGithubSetAutoMerge(cwd: string, input: {
+        enabled: true;
+        method: CheckoutPrMergeMethod;
+    } | {
+        enabled: false;
+    }, requestId?: string): Promise<CheckoutGithubSetAutoMergePayload>;
+    checkoutGithubGetCheckDetails(input: {
+        cwd: string;
+        repoOwner: string;
+        repoName: string;
+        checkRunId: number;
+        workflowRunId?: number;
+    }, requestId?: string): Promise<CheckoutGithubGetCheckDetailsPayload>;
+    checkoutPrStatus(cwd: string, requestId?: string): Promise<CheckoutPrStatusPayload>;
+    pullRequestTimeline(input: {
+        cwd: string;
+        prNumber: number;
+        repoOwner: string;
+        repoName: string;
+    }, requestId?: string): Promise<PullRequestTimelinePayload>;
+    checkoutSwitchBranch(cwd: string, branch: string, requestId?: string): Promise<CheckoutSwitchBranchPayload>;
+    renameBranch(input: RenameBranchInput): Promise<RenameBranchResult>;
+    stashSave(cwd: string, options?: {
+        branch?: string;
+    }, requestId?: string): Promise<StashSavePayload>;
+    stashPop(cwd: string, stashIndex: number, requestId?: string): Promise<StashPopPayload>;
+    stashList(cwd: string, options?: {
+        paseoOnly?: boolean;
+    }, requestId?: string): Promise<StashListPayload>;
+    getPaseoWorktreeList(input: {
+        cwd?: string;
+        repoRoot?: string;
+    }, requestId?: string): Promise<PaseoWorktreeListPayload>;
+    archivePaseoWorktree(input: {
+        worktreePath?: string;
+        repoRoot?: string;
+        branchName?: string;
+        workspaceId?: string;
+        scope?: "workspace" | "worktree";
+    }, requestId?: string): Promise<PaseoWorktreeArchivePayload>;
+    createPaseoWorktree(input: CreatePaseoWorktreeInput, requestId?: string): Promise<CreatePaseoWorktreePayload>;
+    createWorkspace(input: {
+        source: WorkspaceCreateRequest["source"];
+        title?: string;
+        firstAgentContext?: WorkspaceCreateRequest["firstAgentContext"];
+    }, requestId?: string): Promise<WorkspaceCreatePayload>;
+    validateBranch(options: {
+        cwd: string;
+        branchName: string;
+    }, requestId?: string): Promise<ValidateBranchPayload>;
+    getBranchSuggestions(options: {
+        cwd: string;
+        query?: string;
+        limit?: number;
+    }, requestId?: string): Promise<BranchSuggestionsPayload>;
+    searchGitHub(options: {
+        cwd: string;
+        query: string;
+        limit?: number;
+        kinds?: GitHubSearchRequest["kinds"];
+    }, requestId?: string): Promise<GitHubSearchPayload>;
+    getDirectorySuggestions(options: {
+        query: string;
+        limit?: number;
+        cwd?: string;
+        includeFiles?: boolean;
+        includeDirectories?: boolean;
+        matchMode?: "fuzzy" | "suffix";
+    }, requestId?: string): Promise<DirectorySuggestionsPayload>;
+    private requestFileExplorer;
+    listDirectory(cwd: string, path: string, requestId?: string): Promise<FileExplorerDirectoryPayload>;
+    readFile(cwd: string, path: string, requestId?: string): Promise<FileReadResult>;
+    requestDownloadToken(cwd: string, path: string, requestId?: string): Promise<FileDownloadTokenPayload>;
+    requestProjectIcon(cwd: string, requestId?: string): Promise<ProjectIconResponse["payload"]>;
+    listProviderModels(provider: AgentProvider, options?: {
+        cwd?: string;
+        requestId?: string;
+    }): Promise<ListProviderModelsPayload>;
+    listProviderModes(provider: AgentProvider, options?: {
+        cwd?: string;
+        requestId?: string;
+    }): Promise<ListProviderModesPayload>;
+    listProviderFeatures(draftConfig: ListCommandsDraftConfig, options?: {
+        requestId?: string;
+    }): Promise<ListProviderFeaturesPayload>;
+    listAvailableProviders(options?: {
+        requestId?: string;
+    }): Promise<ListAvailableProvidersPayload>;
+    getProvidersSnapshot(options?: {
+        cwd?: string;
+        requestId?: string;
+    }): Promise<GetProvidersSnapshotPayload>;
+    /**
+     * Re-read `agents.providers` from the daemon's config.json into its live
+     * provider registry. No restart. Returns the add/update/remove diff.
+     */
+    reloadProviderConfig(options?: {
+        requestId?: string;
+    }): Promise<ProvidersReloadConfigPayload>;
+    getDaemonConfig(requestId?: string): Promise<{
+        requestId: string;
+        config: MutableDaemonConfig;
+    }>;
+    getDaemonStatus(options?: DaemonStatusOptions): Promise<DaemonStatusPayload>;
+    getDaemonPairingOffer(options?: DaemonPairingOfferOptions): Promise<DaemonPairingOfferPayload>;
+    collectDiagnostics(requestId?: string): Promise<DiagnosticsPayload>;
+    patchDaemonConfig(config: MutableDaemonConfigPatch, requestId?: string): Promise<{
+        requestId: string;
+        config: MutableDaemonConfig;
+    }>;
+    sendBrowserAutomationExecuteResponse(response: BrowserAutomationExecuteResponse): void;
+    readProjectConfig(repoRoot: string, requestId?: string): Promise<ReadProjectConfigPayload>;
+    writeProjectConfig(input: WriteProjectConfigInput): Promise<WriteProjectConfigPayload>;
+    refreshProvidersSnapshot(options?: {
+        cwd?: string;
+        providers?: AgentProvider[];
+        requestId?: string;
+    }): Promise<RefreshProvidersSnapshotPayload>;
+    getProviderDiagnostic(provider: AgentProvider, options?: {
+        requestId?: string;
+    }): Promise<ProviderDiagnosticPayload>;
+    listProviderUsage(options?: {
+        requestId?: string;
+    }): Promise<ProviderUsageListPayload>;
+    listCommands(options: ListCommandsOptions): Promise<ListCommandsPayload>;
+    listCommands(agentId: string, requestId?: string): Promise<ListCommandsPayload>;
+    listCommands(agentId: string, options?: LegacyListCommandsOptions): Promise<ListCommandsPayload>;
+    respondToPermission(agentId: string, requestId: string, response: AgentPermissionResponse): Promise<void>;
+    respondToPermissionAndWait(agentId: string, requestId: string, response: AgentPermissionResponse, timeout?: number): Promise<AgentPermissionResolvedPayload>;
+    waitForAgentUpsert(agentId: string, predicate: (snapshot: AgentSnapshotPayload) => boolean, timeout?: number): Promise<AgentSnapshotPayload>;
+    waitForFinish(agentId: string, timeout?: number): Promise<WaitForFinishResult>;
+    subscribeTerminals(input: {
+        cwd: string;
+        workspaceId?: string;
+    }): void;
+    unsubscribeTerminals(input: {
+        cwd: string;
+        workspaceId?: string;
+    }): void;
+    listTerminals(cwd?: string, requestId?: string, options?: {
+        workspaceId?: string;
+    }): Promise<ListTerminalsPayload>;
+    createTerminal(cwd: string, name?: string, requestId?: string, options?: {
+        agentId?: string;
+        command?: string;
+        args?: string[];
+        workspaceId?: string;
+    }): Promise<CreateTerminalPayload>;
+    renameTerminal(input: RenameTerminalInput): Promise<RenameTerminalResult>;
+    subscribeTerminal(terminalId: string, optionsOrRequestId?: {
+        restore?: SubscribeTerminalRequest["restore"];
+        requestId?: string;
+    } | string): Promise<SubscribeTerminalPayload>;
+    unsubscribeTerminal(terminalId: string): void;
+    sendTerminalInput(terminalId: string, message: TerminalInput["message"]): void;
+    killTerminal(terminalId: string, requestId?: string): Promise<KillTerminalPayload>;
+    closeItems(input: {
+        agentIds?: string[];
+        terminalIds?: string[];
+    }, requestId?: string): Promise<CloseItemsPayload>;
+    captureTerminal(terminalId: string, options?: {
+        start?: number;
+        end?: number;
+        stripAnsi?: boolean;
+    }, requestId?: string): Promise<CaptureTerminalPayload>;
+    /**
+     * Read an agent's rendered terminal screen.
+     *
+     * `payload.screen` is null when the agent has no readable pane (SDK transport, or a PTY
+     * without tmux). That is the normal negative answer, not an error, so callers branch on it
+     * rather than catching.
+     */
+    captureAgentPane(agentId: string, options?: {
+        ansi?: boolean;
+        scrollbackLines?: number;
+    }, requestId?: string): Promise<CaptureAgentPanePayload>;
+    createChatRoom(options: CreateChatRoomOptions): Promise<ChatCreatePayload>;
+    listChatRooms(requestId?: string): Promise<ChatListPayload>;
+    inspectChatRoom(options: InspectChatRoomOptions): Promise<ChatInspectPayload>;
+    deleteChatRoom(options: DeleteChatRoomOptions): Promise<ChatDeletePayload>;
+    postChatMessage(options: PostChatMessageOptions): Promise<ChatPostPayload>;
+    readChatMessages(options: ReadChatMessagesOptions): Promise<ChatReadPayload>;
+    waitForChatMessages(options: WaitForChatMessagesOptions): Promise<ChatWaitPayload>;
+    scheduleCreate(options: CreateScheduleOptions): Promise<ScheduleCreatePayload>;
+    scheduleList(requestId?: string): Promise<ScheduleListPayload>;
+    /**
+     * Preview what a filter would have matched over a window of its source's
+     * history. A READ: the daemon side of this arms nothing, mints no session and
+     * writes no ledger row.
+     *
+     * `payload.result` and `payload.error` are both nullable and exactly one is
+     * populated, so a caller can tell "the window held nothing" from "the read
+     * failed" - a distinction a bare empty array would destroy.
+     */
+    ingestionBackfill(options: {
+        filterId: string;
+        windowDays: 1 | 7 | 30 | 90;
+        requestId?: string;
+    }): Promise<IngestionBackfillPayload>;
+    /**
+     * Dispatch a selection, or ask the daemon what dispatching it would cost.
+     *
+     * TWO calls for anything that collapses to more than one session: the first
+     * omits `confirmedGroups` and comes back `needs-confirmation` carrying the
+     * daemon's own `collapse` and `report`; the second echoes
+     * `collapse.groups` verbatim. The client never computes that number and never
+     * adjusts it - the daemon recomputes on arrival and answers `stale-plan` on any
+     * mismatch, which is the whole point of sending it.
+     */
+    ingestionApply(options: {
+        requestId?: string;
+        filterId: string;
+        itemKeys: string[];
+        mode: "dry-run" | "apply";
+        confirmedGroups?: number;
+    }): Promise<IngestionApplyPayload>;
+    /**
+     * Read one cohort's progress. A READ, and the only way to get one.
+     *
+     * `payload.cohort` and `payload.error` are both nullable and their pairing is
+     * the message: a null cohort with a null error means this cohort does not
+     * exist, and a null cohort with an error means the read failed. A caller that
+     * cannot tell those apart renders a broken daemon as a finished batch.
+     */
+    ingestionCohortInspect(options: {
+        cohortId: string;
+        requestId?: string;
+    }): Promise<IngestionCohortInspectPayload>;
+    /**
+     * Cancel a cohort's PENDING groups. Never its running ones.
+     *
+     * There is no field here through which a caller could ask for a live session to
+     * be interrupted, because a running group may be mid-write to Gmail or GitLab
+     * and the half-drafted email is the failure this whole path exists to avoid.
+     * The response's `stillRunning` is the receipt for what was left alone.
+     */
+    ingestionCohortCancel(options: {
+        cohortId: string;
+        requestId?: string;
+    }): Promise<IngestionCohortCancelPayload>;
+    /**
+     * The STORED verification state of one filter's ingestion runs.
+     *
+     * A read, and only a read: the daemon answers from the ledger and issues no
+     * source round-trip, so this is safe to call on a render. `runs: []` with
+     * `error: null` is a real answer meaning "this filter has no source
+     * schedule"; `[]` beside a non-null error means the read failed. A caller
+     * that collapses the two shows a broken daemon as an idle filter.
+     */
+    ingestionRuns(options: IngestionRunsOptions): Promise<IngestionRunsPayload>;
+    fleetList(requestId?: string): Promise<FleetListPayload>;
+    fleetInspect(options: InspectFleetLoopOptions): Promise<FleetInspectPayload>;
+    fleetRunNow(options: InspectFleetLoopOptions): Promise<FleetRunNowPayload>;
+    fleetPause(options: InspectFleetLoopOptions): Promise<FleetPausePayload>;
+    /** Raise a typed question from a loop. */
+    fleetAsk(options: AskFleetDecisionOptions): Promise<FleetAskPayload>;
+    /** Decisions loops are waiting on a person for, most urgent first. */
+    fleetDecisions(options?: ListFleetDecisionsOptions): Promise<FleetDecisionsPayload>;
+    /** Answer one decision as the human. */
+    fleetResolveDecision(options: ResolveFleetDecisionOptions): Promise<FleetResolveDecisionPayload>;
+    /** Persist a loop's declared parameters. */
+    fleetSetParams(options: SetFleetLoopParamsOptions): Promise<FleetSetParamsPayload>;
+    /** Promote a loop to live, or demote it to dry-run. */
+    fleetSetMode(options: SetFleetLoopModeOptions): Promise<FleetSetModePayload>;
+    fleetResume(options: InspectFleetLoopOptions): Promise<FleetResumePayload>;
+    fleetCreate(options: CreateFleetLoopOptions): Promise<FleetCreatePayload>;
+    fleetExecutions(options: InspectFleetLoopOptions): Promise<FleetExecutionsPayload>;
+    scheduleInspect(options: InspectScheduleOptions): Promise<ScheduleInspectPayload>;
+    scheduleLogs(options: InspectScheduleOptions): Promise<ScheduleLogsPayload>;
+    schedulePause(options: InspectScheduleOptions): Promise<SchedulePausePayload>;
+    scheduleResume(options: InspectScheduleOptions): Promise<ScheduleResumePayload>;
+    scheduleDelete(options: InspectScheduleOptions): Promise<ScheduleDeletePayload>;
+    scheduleRunOnce(options: InspectScheduleOptions): Promise<ScheduleRunOncePayload>;
+    scheduleUpdate(options: UpdateScheduleOptions): Promise<ScheduleUpdatePayload>;
+    sourceCatalogue(options: SourceCatalogueOptions): Promise<SourceCataloguePayload>;
+    sourceConnect(options: SourceConnectOptions): Promise<SourceConnectPayload>;
+    sourceList(requestId?: string): Promise<SourceListPayload>;
+    sourceCheck(options: SourceCheckOptions): Promise<SourceCheckPayload>;
+    /**
+     * FILTER AUTHORING (Epic 7).
+     *
+     * `ingestionFilterUpdate` is not a new name: `packages/app/src/components/
+     * ingestion/filter-detail-sheet.tsx` has probed for this exact method since
+     * Epic 6 and renders "Editing the brief needs a newer paseo host" when it is
+     * absent. Every shipped daemon lacked it, so that control has been disabled
+     * on every host that exists. This is the method it was waiting for.
+     */
+    ingestionFilterList(options?: IngestionFilterListOptions): Promise<IngestionFilterListPayload>;
+    ingestionFilterCreate(options: IngestionFilterCreateOptions): Promise<IngestionFilterCreatePayload>;
+    ingestionFilterUpdate(options: IngestionFilterUpdateOptions): Promise<IngestionFilterUpdatePayload>;
+    ingestionFilterDelete(options: IngestionFilterDeleteOptions): Promise<IngestionFilterDeletePayload>;
+    loopRun(options: RunLoopOptions): Promise<LoopRunPayload>;
+    loopList(requestId?: string): Promise<LoopListPayload>;
+    loopInspect(options: string | InspectLoopOptions): Promise<LoopInspectPayload>;
+    loopLogs(options: string | LoopLogsOptions, afterSeq?: number): Promise<LoopLogsPayload>;
+    loopStop(options: string | StopLoopOptions): Promise<LoopStopPayload>;
+    onTerminalStreamEvent(handler: (event: TerminalStreamEvent) => void): () => void;
+    waitForTerminalStreamEvent(predicate: (event: TerminalStreamEvent) => boolean, timeout?: number): Promise<TerminalStreamEvent>;
+    /**
+     * Upload a file to an agent's workspace as a windowed, cancellable,
+     * progress-reporting stream of {@link UPLOAD_CHUNK_SIZE_BYTES} `FileChunk`
+     * frames with ack-based flow control. Resolves `{ fileId, path, size,
+     * mimeType }` once the daemon finalizes the file.
+     *
+     * Purely additive over the receive path (`activeBinaryFileTransfers`): this
+     * method only sends. It never buffers more than {@link UPLOAD_WINDOW_SIZE}
+     * chunks in flight, so it cannot approach the relay's `MAX_PENDING_SENDS`
+     * ceiling.
+     *
+     * @throws {UploadCancelledError} when `opts.signal` aborts
+     * @throws {UploadCapExceededError} when the daemon rejects on the size cap
+     * @throws {UploadFailedError} for any other transfer failure
+     */
+    uploadFile(file: {
+        bytes: Uint8Array;
+        path: string;
+        mime: string;
+        modifiedAt: string;
+    }, opts: {
+        agentId: string;
+        onProgress?: (bytesSent: number, totalBytes: number) => void;
+        signal?: AbortSignal;
+    }): Promise<{
+        fileId: string;
+        path: string;
+        size: number;
+        mimeType: string;
+    }>;
+    protected createRequestId(requestId?: string): string;
+    getLastServerInfoMessage(): ServerInfoStatusPayload | null;
+    getFileUploadsCapability(): boolean;
+    private resolveTransportUrlForAttempt;
+    private sendHelloMessage;
+    private disposeTransport;
+    private cleanupTransport;
+    private resetConnectTimeout;
+    private handleTransportMessage;
+    private handleJsonPayload;
+    private tryHandleBinaryFrame;
+    private handleFileTransferFrame;
+    private updateConnectionState;
+    setReconnectEnabled(enabled: boolean): void;
+    private scheduleReconnect;
+    private emitDisconnectedStateForReconnect;
+    private armReconnectTimer;
+    private resolvePingProbe;
+    private clearPingProbe;
+    private rejectPingProbe;
+    private recordLivenessFailure;
+    private handleSessionMessage;
+    private resolveWaiters;
+    private clearWaiters;
+    private toEvent;
+    private waitForWithCancel;
+}
+//# sourceMappingURL=daemon-client.d.ts.map