@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/session.d.ts

@@ -0,0 +1,677 @@
+import { type ClientCapability } from "@hyperdrive.bot/fleet-protocol/client-capabilities";
+import { type AgentSnapshotPayload, type SessionInboundMessage, type SessionOutboundMessage, type WorkspaceSetupSnapshot } from "./messages.js";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import { type FileTransferFrame } from "@hyperdrive.bot/fleet-protocol/binary-frames/index";
+import type { BinaryFrame } from "@hyperdrive.bot/fleet-protocol/binary-frames/index";
+import type { SpeechToTextProvider, TextToSpeechProvider } from "./speech/speech-provider.js";
+import type { TurnDetectionProvider } from "./speech/turn-detection-provider.js";
+import type { VoiceCallerContext, VoiceSpeakHandler } from "./voice-types.js";
+import type { ScriptHealthState } from "./script-health-monitor.js";
+import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
+import type { DaemonConfigStore } from "./daemon-config-store.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import { AgentManager } from "./agent/agent-manager.js";
+import type { WorkflowManager } from "./workflow/workflow-manager.js";
+import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
+import type { AgentStorage } from "./agent/agent-storage.js";
+import { type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegistry } from "./workspace-registry.js";
+import type { CohortRecorder } from "./ingestion/apply.js";
+import { CohortStore } from "./ingestion/cohort-store.js";
+import { type DaemonRuntimeConfig } from "./session/daemon/daemon-session.js";
+import type { DaemonWebSocketRuntimeDiagnosticSnapshot } from "./session/daemon/diagnostics.js";
+import { DownloadTokenStore } from "./file-download/token-store.js";
+import { PushTokenStore } from "./push/token-store.js";
+import type { PushSubscriptionStore } from "./push/subscriptions.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
+import { renameCurrentBranch as renameCurrentBranchDefault } from "../utils/checkout-git.js";
+import type { CheckoutDiffManager } from "./checkout-diff-manager.js";
+import type { Resolvable } from "./speech/provider-resolver.js";
+import type { SpeechReadinessSnapshot } from "./speech/speech-runtime.js";
+import type pino from "pino";
+import { FileBackedChatService } from "./chat/chat-service.js";
+import { LoopService } from "./loop-service.js";
+import { ScheduleService } from "./schedule/service.js";
+import type { IngestionService } from "./ingestion/service.js";
+import type { FilterStore } from "./ingestion/filters/store.js";
+import type { SourceStore } from "./ingestion/sources/store.js";
+import type { IngestionLedger } from "./ingestion/ledger.js";
+import type { SourceGateway, SourceKind } from "./ingestion/types.js";
+import type { FleetService } from "./fleet/fleet-service.js";
+import { type GitHubService } from "../services/github-service.js";
+import type { ProviderUsageService } from "../services/quota-fetcher/service.js";
+import { WorkspaceAutoName } from "./workspace-auto-name.js";
+export declare function resolveWaitForFinishError(options: {
+    status: "permission" | "error" | "idle";
+    final: AgentSnapshotPayload | null;
+}): string | null;
+export interface SessionRuntimeMetrics {
+    terminalDirectorySubscriptionCount: number;
+    terminalSubscriptionCount: number;
+    inflightRequests: number;
+    peakInflightRequests: number;
+}
+export interface SessionFileSystem {
+    isDirectory(path: string): Promise<boolean>;
+}
+type AgentMcpTransportFactory = () => Promise<unknown>;
+export interface SessionOptions {
+    clientId: string;
+    appVersion?: string | null;
+    clientCapabilities?: Record<string, unknown> | null;
+    onMessage: (msg: SessionOutboundMessage) => void;
+    onBinaryMessage?: (frame: Uint8Array) => void;
+    getTransportBufferedAmount?: () => number | null;
+    onLifecycleIntent?: (intent: SessionLifecycleIntent) => void;
+    logger: pino.Logger;
+    downloadTokenStore: DownloadTokenStore;
+    pushTokenStore: PushTokenStore;
+    paseoHome: string;
+    worktreesRoot?: string;
+    agentManager: AgentManager;
+    workflowManager?: WorkflowManager;
+    agentStorage: AgentStorage;
+    projectRegistry: ProjectRegistry;
+    workspaceRegistry: WorkspaceRegistry;
+    filesystem?: SessionFileSystem;
+    chatService: FileBackedChatService;
+    scheduleService: ScheduleService;
+    ingestionService: IngestionService;
+    /**
+     * The read-only ingestion PREVIEW collaborators. Optional as a group: a
+     * daemon wired without them answers `ingestion/backfill` with an error rather
+     * than failing to construct, and every other RPC is unaffected.
+     */
+    ingestionFilterStore?: FilterStore;
+    ingestionSourceStore?: SourceStore;
+    ingestionGatewayResolver?: (kind: SourceKind) => SourceGateway;
+    ingestionLedger?: IngestionLedger;
+    /**
+     * Where `ingestion/apply` records a cohort. Optional so a focused test can
+     * substitute a fake; absent means the sqlite store below, or - on a daemon
+     * with no ledger at all - the in-memory recorder, which is honest about not
+     * surviving a restart.
+     */
+    ingestionCohorts?: CohortRecorder;
+    /**
+     * The daemon's ONE `CohortStore`, over the same handle as `ingestionLedger`.
+     * Absent on a daemon whose sqlite could not be opened, in which case
+     * `ingestion/cohort/*` answers with an error rather than an empty cohort.
+     */
+    ingestionCohortStore?: CohortStore;
+    fleetService?: FleetService;
+    loopService: LoopService;
+    checkoutDiffManager: CheckoutDiffManager;
+    github?: GitHubService;
+    createAgentMcpTransport?: AgentMcpTransportFactory;
+    executeExtensionCommand?: (commandId: string, args: unknown[]) => Promise<unknown>;
+    renameCurrentBranch?: typeof renameCurrentBranchDefault;
+    workspaceGitService: WorkspaceGitService;
+    workspaceAutoName: WorkspaceAutoName;
+    daemonConfigStore: DaemonConfigStore;
+    mcpBaseUrl?: string | null;
+    stt: Resolvable<SpeechToTextProvider | null>;
+    sttLanguage?: string;
+    tts: Resolvable<TextToSpeechProvider | null>;
+    terminalManager: TerminalManager | null;
+    providerSnapshotManager: ProviderSnapshotManager;
+    providerUsageService: ProviderUsageService;
+    serviceProxy?: ServiceProxySubsystem;
+    scriptRuntimeStore?: WorkspaceScriptRuntimeStore;
+    workspaceSetupSnapshots?: Map<string, WorkspaceSetupSnapshot>;
+    onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void;
+    getDaemonTcpPort?: () => number | null;
+    getDaemonTcpHost?: () => string | null;
+    serviceProxyPublicBaseUrl?: string | null;
+    resolveScriptHealth?: (hostname: string) => ScriptHealthState | null;
+    voice?: {
+        turnDetection?: Resolvable<TurnDetectionProvider | null>;
+    };
+    voiceBridge?: {
+        registerVoiceSpeakHandler?: (agentId: string, handler: VoiceSpeakHandler) => void;
+        unregisterVoiceSpeakHandler?: (agentId: string) => void;
+        registerVoiceCallerContext?: (agentId: string, context: VoiceCallerContext) => void;
+        unregisterVoiceCallerContext?: (agentId: string) => void;
+    };
+    dictation?: {
+        finalTimeoutMs?: number;
+        stt?: Resolvable<SpeechToTextProvider | null>;
+        sttLanguage?: string;
+        getSpeechReadiness?: () => SpeechReadinessSnapshot;
+    };
+    serverId?: string;
+    daemonVersion?: string;
+    daemonRuntimeConfig?: DaemonRuntimeConfig;
+    getWebSocketRuntimeMetrics?: () => DaemonWebSocketRuntimeDiagnosticSnapshot | null;
+    /**
+     * Optional store for Web Push + Expo Push subscriptions (Story 1.2).
+     * Wired by bootstrap so the WebSocket bridge `subscribe_push_request` can
+     * persist subscriptions without round-tripping the HTTP /push/subscribe route
+     * (which is unreachable over the relay transport).
+     */
+    pushSubscriptionStore?: PushSubscriptionStore;
+    /**
+     * Optional VAPID public key returned by the WebSocket bridge
+     * `get_vapid_public_key_request`. Mirrors the HTTP `/push/vapid-public-key`
+     * route so relay clients can fetch it without HTTP.
+     */
+    vapidPublicKey?: string | null;
+}
+export type SessionLifecycleIntent = {
+    type: "shutdown";
+    clientId: string;
+    requestId: string;
+    reason: string;
+} | {
+    type: "restart";
+    clientId: string;
+    requestId: string;
+    reason: string;
+};
+/**
+ * Session represents a single connected client session.
+ * It owns all state management, orchestration logic, and message processing.
+ * Session has no knowledge of WebSockets - it only emits and receives messages.
+ */
+export declare class Session {
+    private readonly clientId;
+    private appVersion;
+    private clientCapabilities;
+    private readonly sessionId;
+    private readonly onMessage;
+    private readonly onBinaryMessage;
+    private readonly getTransportBufferedAmount;
+    private readonly onLifecycleIntent;
+    private readonly sessionLogger;
+    private readonly paseoHome;
+    private readonly worktreesRoot;
+    private readonly activeBinaryFileUploads;
+    private readonly completedUploads;
+    private readonly stagingService;
+    private isCleanedUp;
+    private readonly emittedWatchPushIds;
+    private agentManager;
+    private readonly watchNotifications;
+    private readonly workflowManager;
+    private readonly agentStorage;
+    /**
+     * Held for two things, both of which are the durable-agent predicate.
+     *
+     * READ: the agent projections join the schedule facts off it, `hasRoutine`
+     * (the half of the predicate that lives in the schedule store) and
+     * `nextFireAt` (what the row displays).
+     *
+     * WRITE: `create_agent_request` attaches a new agent's routine through it in
+     * the same call, so an agent is never briefly prompt-only and misclassified.
+     *
+     * Everything else about schedules is routed through `chatScheduleLoopSession`.
+     */
+    private readonly scheduleService;
+    private readonly projectRegistry;
+    private readonly workspaceRegistry;
+    private readonly executeExtensionCommand;
+    private readonly filesystem;
+    private readonly github;
+    private readonly renameCurrentBranch;
+    private readonly workspaceGitService;
+    private readonly workspaceAutoName;
+    private readonly gitMutation;
+    private readonly workspaceProvisioning;
+    private readonly daemonConfigStore;
+    private readonly pushTokenStore;
+    private unsubscribeAgentEvents;
+    private unsubscribeTerminalWorkspaceContributionEvents;
+    private readonly agentUpdates;
+    private workspaceUpdatesSubscription;
+    private clientActivity;
+    private readonly terminalManager;
+    private readonly providerSnapshotManager;
+    private readonly serviceProxy;
+    private readonly scriptRuntimeStore;
+    private readonly getDaemonTcpPort;
+    private readonly getDaemonTcpHost;
+    private readonly serviceProxyPublicBaseUrl;
+    private readonly resolveScriptHealth;
+    private readonly terminalController;
+    private inflightRequests;
+    private peakInflightRequests;
+    private readonly workspaceSetupSnapshots;
+    private readonly workspaceGitObserver;
+    private readonly workspaceDirectory;
+    private readonly voiceSession;
+    private readonly checkoutSession;
+    private readonly chatScheduleLoopSession;
+    private readonly sourceSession;
+    /**
+     * Null when the daemon was constructed without the preview collaborators.
+     * The router arm reports that plainly rather than throwing: the client shows
+     * the error on the backfill screen, which is exactly the AC-10 distinction
+     * between "the window held nothing" and "the read did not happen".
+     */
+    private readonly chatIngestionSession;
+    private readonly providerCatalogSession;
+    private readonly workspaceFilesSession;
+    private readonly agentConfigSession;
+    private readonly projectConfigSession;
+    private readonly daemonSession;
+    private readonly workspaceScripts;
+    private readonly createAgentLifecycleDispatch;
+    private readonly pushSubscriptionStore;
+    private readonly vapidPublicKey;
+    constructor(options: SessionOptions);
+    updateAppVersion(appVersion: string | null): void;
+    updateClientCapabilities(capabilities: Record<string, unknown> | null): void;
+    supports(capability: ClientCapability): boolean;
+    syncWorkspaceGitObserverForWorkspace(workspace: PersistedWorkspaceRecord): Promise<void>;
+    emitWorkspaceUpdateForWorkspaceId(workspaceId: string): Promise<void>;
+    archiveWorkspaceRecordForExternalMutation(workspaceId: string): Promise<void>;
+    markWorkspaceArchivingForExternalMutation(workspaceIds: Iterable<string>, archivingAt: string): void;
+    clearWorkspaceArchivingForExternalMutation(workspaceIds: Iterable<string>): void;
+    emitWorkspaceUpdatesForExternalWorkspaceIds(workspaceIds: Iterable<string>): Promise<void>;
+    warmWorkspaceGitDataForWorkspace(workspace: PersistedWorkspaceRecord): Promise<void>;
+    /**
+     * Get the client's current activity state
+     */
+    getClientActivity(): {
+        deviceType: "web" | "mobile";
+        focusedAgentId: string | null;
+        focusedTerminalId: string | null;
+        lastActivityAt: Date;
+        appVisible: boolean;
+        appVisibilityChangedAt: Date;
+    } | null;
+    private getFocusedAgentSelectionForCwd;
+    private readStructuredGenerationDaemonConfig;
+    getRuntimeMetrics(): SessionRuntimeMetrics;
+    emitServerMessage(message: SessionOutboundMessage): void;
+    /**
+     * Send initial state to client after connection
+     */
+    sendInitialState(): Promise<void>;
+    /**
+     * Normalize a user prompt (with optional image metadata) for AgentManager
+     */
+    private buildAgentPrompt;
+    /**
+     * Interrupt the agent's active run so the next prompt starts a fresh turn.
+     * Returns once the manager confirms the stream has been cancelled.
+     */
+    private interruptAgentIfRunning;
+    private hasActiveAgentRun;
+    private handleAgentRunError;
+    /**
+     * Subscribe to AgentManager events and forward them to the client
+     */
+    private subscribeToOptionalManagers;
+    private subscribeToAgentEvents;
+    /**
+     * Emit a `watch.actionablePush` for a freshly-raised agent permission request (story 1.5).
+     *
+     * De-duplicated per `notificationId` (== `request.id`): at most one push per pending id. The
+     * push mirrors the agent's allow/deny options; sparse requests (missing `actions`/`title`/
+     * `description`) fall back to defaults so this never throws inside the agent-stream callback —
+     * a throw here would propagate over the relay and break the phone↔daemon link for all traffic.
+     */
+    private emitWatchActionablePush;
+    /**
+     * Emit a `watch.actionableResolved` when a permission resolves, clearing the de-dup entry so a
+     * future raise of the same id pushes again (story 1.5). No-op for ids that were never pushed.
+     */
+    private emitWatchActionableResolved;
+    private buildAgentStreamPayload;
+    private buildAgentPayload;
+    private buildStoredAgentPayload;
+    private isProviderVisibleToClient;
+    private buildProjectPlacementForWorkspace;
+    private buildProjectPlacementForWorkspaceId;
+    /**
+     * Main entry point for processing session messages
+     */
+    handleMessage(msg: SessionInboundMessage): Promise<void>;
+    private dispatchInboundMessage;
+    private dispatchVoiceAndControlMessage;
+    private dispatchAgentRewindMessage;
+    /**
+     * Route `workflow.*` requests to their handlers. Returns `undefined` for any
+     * non-workflow message so the `??` router chain falls through to the next
+     * dispatcher (Epic 1, Story 1.3).
+     */
+    private dispatchWorkflowMessage;
+    private dispatchAgentRelationshipMessage;
+    /**
+     * Resolve the injected WorkflowManager, or emit an `rpc_error` and return
+     * `undefined` when the daemon was constructed without one (only happens in
+     * focused tests — the daemon always injects it).
+     */
+    private resolveWorkflowManager;
+    /** Emit the shared `rpc_error` outbound message for a failed workflow RPC. */
+    private emitWorkflowRpcError;
+    private handleWorkflowListRequest;
+    private handleWorkflowGetRequest;
+    /**
+     * Launch a task-graph workflow (Epic 3, Story 3.3). The client-facing twin of
+     * the `workflow_start` MCP tool: it delegates to the SAME daemon-owned
+     * `createWorkflow` + `startWorkflow` path (no sequencing/retry re-implemented
+     * here) so a CLI/app client can launch a daemon-owned, kill-proof run over RPC.
+     */
+    private handleWorkflowStartRequest;
+    private handleWorkflowCancelRequest;
+    private handleWorkflowEventsRequest;
+    private dispatchAgentTimelineMessage;
+    private dispatchAgentLifecycleMessage;
+    private dispatchAgentLifecycleMessageRest;
+    private dispatchWatchMessage;
+    private dispatchAgentConfigMessage;
+    private dispatchCheckoutMessage;
+    private dispatchWorkspaceAndProjectMessage;
+    /**
+     * Re-read `agents.providers` out of `$PASEO_HOME/config.json` and rebuild the
+     * provider registry live — the daemon-side half of `paseo provider reload`.
+     *
+     * Mirrors the daemonConfigStore.onChange path in websocket-server.ts (rebuild,
+     * then push the new state into AgentManager) but sources the base overrides
+     * from disk instead of a patch, so removals actually take effect.
+     */
+    private reloadProviderConfigFromDisk;
+    private dispatchProviderMessage;
+    private dispatchTerminalMessage;
+    private dispatchChatScheduleLoopMessage;
+    private dispatchMiscMessage;
+    resetPeakInflight(): void;
+    getSessionId(): string;
+    handleBinaryFrame(binaryFrame: BinaryFrame): Promise<void>;
+    /**
+     * Route an inbound file-transfer binary frame (client→daemon upload) to the matching
+     * per-opcode handler. Receive-direction twin of the download emit.
+     *
+     * Frames for a given transfer are serialized through a per-transfer promise tail so the
+     * async FileBegin staging-open always completes before any FileChunk writes — without it,
+     * a chunk arriving in the same tick as FileBegin would race a still-null writeStream and be
+     * dropped. The queue holds at most a tiny backlog (microtasks drain between socket message
+     * macrotasks), so it does NOT buffer the whole file — the bytes still stream to disk.
+     */
+    handleFileUploadFrame(frame: FileTransferFrame): void;
+    private processFileUploadFrame;
+    private dispatchFileUploadMessage;
+    /**
+     * JSON `files.upload.begin.request` → register the pending transfer and ack with
+     * `files.upload.begin.response`. `agentId` enters ONLY here (the binary FileBegin
+     * frame carries no agentId).
+     */
+    private handleFileUploadBeginRequest;
+    /**
+     * JSON `files.upload.complete.request` → drain queued chunks, flush + close the write stream,
+     * record the finalized upload (so a later `send_agent_message` can resolve the `fileId`), and
+     * emit `files.upload.complete.response`. This is the JSON-control-plane finalize counterpart of
+     * the binary `FileEnd` handler — the windowed client (story 4.1) finalizes via this message.
+     */
+    private handleFileUploadCompleteRequest;
+    /**
+     * Binary `FileBegin` → open the disk-backed staging write target via the staging seam.
+     */
+    private handleFileUploadBeginFrame;
+    /**
+     * Binary `FileChunk` → stream the payload to disk + emit exactly one
+     * `files.upload.chunk.ack`. A not-yet-open transfer (FileBegin never opened the stream)
+     * is inert (mirror daemon-client.ts:4831-4834).
+     *
+     * Honors write-stream backpressure: when `write()` reports the buffer is full, the per-
+     * transfer queue awaits `drain` before the next frame, so a fast client on a slow disk
+     * cannot grow the in-memory buffer past the stream's highWaterMark (NFR5 — never buffer
+     * the whole file).
+     */
+    private handleFileUploadChunkFrame;
+    /**
+     * Binary `FileEnd` → flush + close the stream (await `finish`), then emit
+     * `files.upload.complete.response`. On stream error, run abort cleanup and emit
+     * `files.upload.error` (write_failed) instead of completing.
+     */
+    private handleFileUploadEndFrame;
+    /**
+     * Attach a persistent `error` listener to an inbound upload's write stream. A stream
+     * destroyed mid-flight (size-cap trip or client abort) flushes its pending fs-write
+     * callback asynchronously, which throws `ERR_STREAM_DESTROYED` ("Cannot call write after a
+     * stream was destroyed"); with no listener attached at that instant Node re-raises it as an
+     * uncaught exception — crashing the daemon / failing the vitest run even though every test
+     * passes. Real write failures are still surfaced by the FileEnd + backpressure transient
+     * listeners that drive `write_failed` aborts; this guard only prevents the uncaught crash.
+     */
+    private guardInboundUploadStream;
+    /**
+     * Tear down an in-flight upload: destroy the write stream, unlink the partial, and
+     * drop the map entry. Idempotent — a double-abort / abort-then-disconnect does not throw.
+     * Emits `files.upload.error` only when `code` is non-null AND the socket is still open.
+     */
+    private abortFileUpload;
+    private handleRestartServerRequest;
+    private handleShutdownServerRequest;
+    private emitLifecycleIntent;
+    private handleDeleteAgentRequest;
+    private handleArchiveAgentRequest;
+    /**
+     * List background shells -- one agent's, or every agent's when `agentId` is
+     * omitted. Fetched on demand by the Background activity sheet, the same way
+     * it already fetches a workspace's terminals.
+     */
+    private handleListBackgroundTasksRequest;
+    /**
+     * Record session context onto an agent's digest on behalf of the context
+     * hook, which runs beside the agent rather than inside it.
+     *
+     * Masking happens HERE and cannot be skipped by the caller: a value that
+     * looks live is replaced before it is stored, so a hook that scrapes an
+     * environment too eagerly cannot put a working token into paseo. See
+     * packages/protocol/src/session-secrets.ts.
+     */
+    private handleSetAgentContextRequest;
+    /**
+     * Enrich external reference URLs (pipelines, MRs, PRs, tickets) for the
+     * session context rail. Credentials live here, never in the app, so the app
+     * sends URLs and receives status. See docs/session-context-rail.md.
+     */
+    private handleEnrichReferencesRequest;
+    /** Read one background shell's captured output (tailed and redacted). */
+    private handleBackgroundTaskOutputRequest;
+    private handleDismissBackgroundTaskRequest;
+    private archiveAgentForClose;
+    private handleDetachAgentRequest;
+    private handleCloseItemsRequest;
+    private unarchiveAgentByHandle;
+    /**
+     * agent.decision.answer.request — a human resolving a decision the agent
+     * parked on its digest.
+     *
+     * Reads the digest from the LIVE agent when there is one and falls back to the
+     * stored record otherwise: the sessions most likely to be sitting on an
+     * unanswered decision are exactly the ones that already went idle or closed
+     * waiting for it, and refusing to answer those would defeat the feature.
+     */
+    private handleAgentDecisionAnswerRequest;
+    /**
+     * Takes the request OBJECT, not positional arguments. `labelsRemove` was first
+     * added as a fourth positional parameter, which silently shifted `requestId`
+     * into it for every existing caller - a test passed a string where an array was
+     * expected and only blew up at `.map`. A named field cannot be shifted.
+     */
+    private handleUpdateAgentRequest;
+    private handleProjectRenameRequest;
+    private handleProjectRemoveRequest;
+    private handleWorkspaceTitleSetRequest;
+    /**
+     * Handle text message to agent (with optional image attachments)
+     */
+    private handleSendAgentMessage;
+    /**
+     * Handle create agent request
+     */
+    private ensureResumeSourceExists;
+    private emitAgentCreated;
+    private handleCreateAgentRequest;
+    private handleResumeAgentRequest;
+    private handleImportAgentRequest;
+    private handleRefreshAgentRequest;
+    private handleCancelAgentRequest;
+    /**
+     * Answer with the agent's rendered terminal screen, or with null when it has no pane.
+     *
+     * This never fails the request. A missing agent, a provider with no terminal and a tmux
+     * that did not answer are all `screen: null`, because the client's only decision is
+     * "render a screen or say there isn't one" -- an error response would make the viewer
+     * distinguish failures it cannot act on differently anyway. `capturedAt` is stamped here,
+     * on the daemon, so a polling viewer can tell a fresh identical screen from a stalled one.
+     */
+    private handleCaptureAgentPaneRequest;
+    private handleAgentRewindRequest;
+    private buildAgentSessionConfig;
+    private isPathWithinRoot;
+    /**
+     * Handle set agent mode request
+     */
+    private handleSwapAgentProviderRequest;
+    /**
+     * Handle clearing agent attention flag
+     */
+    private handleClearAgentAttention;
+    /**
+     * Handle client heartbeat for activity tracking
+     */
+    private handleClientHeartbeat;
+    private clearFocusedTerminalAttention;
+    /**
+     * Handle push token registration
+     */
+    private handleRegisterPushToken;
+    private handleRewindSessionRequest;
+    private handleEditMessageRequest;
+    private handleChatActionTruncate;
+    private emitChatActionError;
+    private handleListWorkspaceSessionsRequest;
+    private handleListAllSessionsRequest;
+    private handleListExtensionsRequest;
+    private handleExecuteExtensionCommandRequest;
+    private handleSearchSessionsRequest;
+    private handleWatchSessionSearch;
+    private handleSubscribePushRequest;
+    private handleGetVapidPublicKeyRequest;
+    /**
+     * Handle list commands request for an agent
+     */
+    private handleListCommandsRequest;
+    /**
+     * Handle agent permission response from user
+     */
+    private handleAgentPermissionResponse;
+    private handleWatchNotificationAction;
+    private handleWatchComposerDictate;
+    private handleDirectorySuggestionsRequest;
+    private handlePaseoWorktreeListRequest;
+    private handlePaseoWorktreeArchiveRequest;
+    /**
+     * Stream a file-explorer download as ≤256 KiB FileChunk frames (download-direction
+     * twin of the upload chunker) so large downloads stay under the relay's 32 MiB
+     * per-message cap and never head-of-line-block voice/terminal frames. The caller
+     * has already confirmed `acceptBinary` and a bound binary sink.
+     */
+    /**
+     * Handle read-only file explorer requests scoped to a workspace cwd
+     */
+    /**
+     * Handle project icon request for a given cwd
+     */
+    /**
+     * Handle file download token request scoped to a workspace cwd
+     */
+    private listTerminalActivityContributions;
+    /**
+     * Build the current agent list payload (live + persisted), optionally filtered by labels.
+     */
+    private listAgentPayloads;
+    /** Executions of a loop = paseo agents it spawned, labeled loop=<name>. Newest first. */
+    private listLoopExecutions;
+    private resolveAgentIdentifier;
+    private getAgentPayloadById;
+    private resolveDelegationRootWorkspaceId;
+    private buildActiveProjectPlacementsByWorkspaceId;
+    private collectFetchAgentsEntries;
+    private listFetchAgentsEntries;
+    private readonly agentsPager;
+    private decodeAgentCursor;
+    private describeWorkspaceRecord;
+    private buildWorkspaceGitRuntimePayload;
+    private buildWorkspaceGitHubRuntimePayload;
+    private describeWorkspaceRecordWithGitData;
+    private describeCreatedWorktreeWorkspace;
+    private buildWorkspaceDescriptor;
+    markWorkspaceArchiving(workspaceIds: Iterable<string>, archivingAt: string): void;
+    clearWorkspaceArchiving(workspaceIds: Iterable<string>): void;
+    private buildWorkspaceDescriptorMap;
+    private findWorkspaceIdForCwd;
+    private matchesWorkspaceFilter;
+    private listFetchWorkspacesEntries;
+    private bufferOrEmitWorkspaceUpdate;
+    private flushBootstrappedWorkspaceUpdates;
+    private buildProjectDescriptor;
+    private unarchiveOwningWorkspaceForAgent;
+    private recreateOwningWorktreeForRestore;
+    private createPaseoWorktree;
+    private listActiveWorkspaceRefs;
+    private archiveWorkspaceRecord;
+    private teardownArchivedWorkspace;
+    private reconcileAndEmitWorkspaceUpdates;
+    private reconcileActiveWorkspaceRecords;
+    private emitWorkspaceUpdatesForWorkspaceIds;
+    private buildWorkspaceRemoveUpdatePayload;
+    private resolveProjectWithoutActiveWorkspacesForArchivedWorkspace;
+    private emitWorkspaceUpdateForTerminalContribution;
+    private emitWorkspaceUpdateForCwd;
+    private handleFetchAgents;
+    private handleFetchAgentHistory;
+    private handleFetchRecentProviderSessions;
+    private handleFetchWorkspacesRequest;
+    private buildBootstrapSnapshot;
+    private registerWorkspaceForImportedAgent;
+    private handleWorkspaceCreateRequest;
+    private handleWorkspaceCreateLocal;
+    private handleWorkspaceCreateWorktree;
+    private resolveWorktreeSourceCwd;
+    private handleOpenProjectRequest;
+    private handleProjectAddRequest;
+    private buildWorkspaceScriptPayloadSnapshot;
+    private handleStartWorkspaceScriptRequest;
+    private handleLegacyListAvailableEditorsRequest;
+    private handleLegacyOpenInEditorRequest;
+    private handleCreatePaseoWorktreeRequest;
+    private createPaseoWorktreeWorkflow;
+    private handleWorkspaceSetupStatusRequest;
+    private handleArchiveWorkspaceRequest;
+    private handleWorkspaceClearAttentionRequest;
+    private handleFetchAgent;
+    private shouldUseFullTimelineForProjectedPage;
+    private selectCanonicalTimelineProjection;
+    private selectProjectedTimelineProjection;
+    private selectTimelineProjection;
+    private handleFetchAgentTimelineRequest;
+    /**
+     * Validate every `file` attachment against this Session's completed-uploads registry
+     * before a prompt is dispatched (story 2.3). For each `att.type === "file"`, the staged
+     * file must exist, belong to `agentId` (the client-supplied scope key), and resolve inside
+     * the agent's staging dir; on success the attachment's `path` is overwritten with the
+     * canonical realpath (the client-supplied `path` is never trusted). All other attachment
+     * variants and `msg.images` pass through untouched. Fails closed on the first bad `file`
+     * entry — a user's attachment is never silently dropped.
+     */
+    private validateFileAttachments;
+    private handleAgentForkContextRequest;
+    private handleSendAgentMessageRequest;
+    private handleWaitForFinish;
+    /**
+     * Emit a message to the client
+     */
+    private emit;
+    private emitBinary;
+    /**
+     * Clean up session resources
+     */
+    cleanup(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=session.d.ts.map