@getpaseo/server 0.1.2 → 0.1.4

package/dist/server/server/session.js

@@ -6,7 +6,7 @@ import { promisify } from "util";
 import { join, resolve, sep } from "path";
 import { z } from "zod";
 import { serializeAgentStreamEvent, } from "./messages.js";
-import { parseAndHighlightDiff } from "./utils/diff-highlighter.js";
+import { BinaryMuxChannel, TerminalBinaryFlags, TerminalBinaryMessageType, } from "../shared/binary-mux.js";
 import { TTSManager } from "./agent/tts-manager.js";
 import { STTManager } from "./agent/stt-manager.js";
 import { maybePersistTtsDebugAudio } from "./agent/tts-debug.js";
@@ -17,13 +17,14 @@ import { experimental_createMCPClient } from "ai";
 import { buildProviderRegistry } from "./agent/provider-registry.js";
 import { scheduleAgentMetadataGeneration } from "./agent/agent-metadata-generator.js";
 import { toAgentPayload } from "./agent/agent-projections.js";
+import { projectTimelineRows } from "./agent/timeline-projection.js";
 import { StructuredAgentResponseError, generateStructuredAgentResponse, } from "./agent/agent-response-loop.js";
 import { isValidAgentProvider, AGENT_PROVIDER_IDS } from "./agent/provider-manifest.js";
 import { buildVoiceAgentMcpServerConfig, buildVoiceModeSystemPrompt, stripVoiceModeSystemPrompt, } from "./voice-config.js";
 import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
 import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from "./file-explorer/service.js";
 import { createWorktree, runWorktreeSetupCommands, WorktreeSetupError, slugify, validateBranchSlug, listPaseoWorktrees, deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, } from "../utils/worktree.js";
-import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from "../utils/checkout-git.js";
+import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from "../utils/checkout-git.js";
 import { getProjectIcon } from "../utils/project-icon.js";
 import { expandTilde } from "../utils/path.js";
 import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from "./speech/providers/local/models.js";
@@ -40,6 +41,9 @@ const PROJECT_PLACEMENT_CACHE_TTL_MS = 10000;
 const MAX_AGENTS_PER_PROJECT = 5;
 const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
 const CHECKOUT_DIFF_FALLBACK_REFRESH_MS = 5000;
+const TERMINAL_STREAM_WINDOW_BYTES = 256 * 1024;
+const TERMINAL_STREAM_MAX_PENDING_BYTES = 2 * 1024 * 1024;
+const TERMINAL_STREAM_MAX_PENDING_CHUNKS = 2048;
 /**
  * Default model used for auto-generating commit messages and PR descriptions.
  * Uses Claude Haiku for speed and cost efficiency.
@@ -117,6 +121,15 @@ const VOICE_INTERNAL_DICTATION_ID_PREFIX = "__voice_turn__:";
 const SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9._\/-]+$/;
 const AgentIdSchema = z.string().uuid();
 const VOICE_MCP_SERVER_NAME = "paseo_voice";
+class VoiceFeatureUnavailableError extends Error {
+    constructor(context) {
+        super(context.message);
+        this.name = "VoiceFeatureUnavailableError";
+        this.reasonCode = context.reasonCode;
+        this.retryable = context.retryable;
+        this.missingModelIds = [...context.missingModelIds];
+    }
+}
 function convertPCMToWavBuffer(pcmBuffer, sampleRate, channels, bitsPerSample) {
     const headerSize = 44;
     const wavBuffer = Buffer.alloc(headerSize + pcmBuffer.length);
@@ -200,14 +213,18 @@ export class Session {
         this.clientActivity = null;
         this.MOBILE_BACKGROUND_STREAM_GRACE_MS = 60000;
         this.terminalSubscriptions = new Map();
+        this.terminalStreams = new Map();
+        this.terminalStreamByTerminalId = new Map();
+        this.nextTerminalStreamId = 1;
         this.checkoutDiffSubscriptions = new Map();
         this.checkoutDiffTargets = new Map();
         this.voiceModeAgentId = null;
         this.voiceModeBaseConfig = null;
-        const { clientId, onMessage, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
+        const { clientId, onMessage, onBinaryMessage, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
         this.clientId = clientId;
         this.sessionId = uuidv4();
         this.onMessage = onMessage;
+        this.onBinaryMessage = onBinaryMessage ?? null;
         this.downloadTokenStore = downloadTokenStore;
         this.pushTokenStore = pushTokenStore;
         this.paseoHome = paseoHome;
@@ -231,6 +248,7 @@ export class Session {
         this.unregisterVoiceCallerContext = voiceBridge?.unregisterVoiceCallerContext;
         this.ensureVoiceMcpSocketForAgent = voiceBridge?.ensureVoiceMcpSocketForAgent;
         this.removeVoiceMcpSocketForAgent = voiceBridge?.removeVoiceMcpSocketForAgent;
+        this.getSpeechReadiness = dictation?.getSpeechReadiness;
         this.agentProviderRuntimeSettings = agentProviderRuntimeSettings;
         this.abortController = new AbortController();
         this.sessionLogger = logger.child({
@@ -261,7 +279,7 @@ export class Session {
         // Initialize agent MCP client asynchronously
         void this.initializeAgentMcp();
         this.subscribeToAgentEvents();
-        this.sessionLogger.info("Session created");
+        this.sessionLogger.trace("Session created");
     }
     /**
      * Get the client's current activity state
@@ -331,11 +349,11 @@ export class Session {
     /**
      * Start streaming an agent run and forward results via the websocket broadcast
      */
-    startAgentStream(agentId, prompt) {
+    startAgentStream(agentId, prompt, runOptions) {
         this.sessionLogger.info({ agentId }, `Starting agent stream for ${agentId}`);
         let iterator;
         try {
-            iterator = this.agentManager.streamAgent(agentId, prompt);
+            iterator = this.agentManager.streamAgent(agentId, prompt, runOptions);
         }
         catch (error) {
             this.handleAgentRunError(agentId, error, "Failed to start agent run");
@@ -379,7 +397,7 @@ export class Session {
             });
             this.agentTools = (await this.agentMcpClient.tools());
             const agentToolCount = Object.keys(this.agentTools ?? {}).length;
-            this.sessionLogger.info({ agentToolCount }, `Agent MCP initialized with ${agentToolCount} tools`);
+            this.sessionLogger.trace({ agentToolCount }, `Agent MCP initialized with ${agentToolCount} tools`);
         }
         catch (error) {
             this.sessionLogger.error({ err: error }, "Failed to initialize Agent MCP");
@@ -416,9 +434,7 @@ export class Session {
             }
             // Reduce bandwidth/CPU on mobile: only forward high-frequency agent stream events
             // for the focused agent, with a short grace window while backgrounded.
-            //
-            // History catch-up is handled via explicit `initialize_agent_request` which emits a
-            // batched `agent_stream_snapshot`.
+            // History catch-up is handled via pull-based `fetch_agent_timeline_request`.
             const activity = this.clientActivity;
             if (activity?.deviceType === "mobile") {
                 if (!activity.focusedAgentId) {
@@ -442,6 +458,8 @@ export class Session {
                 agentId: event.agentId,
                 event: serializedEvent,
                 timestamp: new Date().toISOString(),
+                ...(typeof event.seq === "number" ? { seq: event.seq } : {}),
+                ...(typeof event.epoch === "string" ? { epoch: event.epoch } : {}),
             };
             this.emit({
                 type: "agent_stream",
@@ -534,10 +552,12 @@ export class Session {
             let snapshot;
             if (handle) {
                 snapshot = await this.agentManager.resumeAgentFromPersistence(handle, buildConfigOverrides(record), agentId, extractTimestamps(record));
+                this.sessionLogger.info({ agentId, provider: record.provider }, "Agent resumed from persistence");
             }
             else {
                 const config = buildSessionConfig(record);
                 snapshot = await this.agentManager.createAgent(config, agentId, { labels: record.labels });
+                this.sessionLogger.info({ agentId, provider: record.provider }, "Agent created from stored config");
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
             return this.agentManager.getAgent(agentId) ?? snapshot;
@@ -685,6 +705,9 @@ export class Session {
                 case "archive_agent_request":
                     await this.handleArchiveAgentRequest(msg.agentId, msg.requestId);
                     break;
+                case "update_agent_request":
+                    await this.handleUpdateAgentRequest(msg.agentId, msg.name, msg.labels, msg.requestId);
+                    break;
                 case "set_voice_mode":
                     await this.handleSetVoiceMode(msg.enabled, msg.agentId, msg.requestId);
                     break;
@@ -695,6 +718,22 @@ export class Session {
                     await this.handleWaitForFinish(msg.agentId, msg.requestId, msg.timeoutMs);
                     break;
                 case "dictation_stream_start":
+                    {
+                        const unavailable = this.resolveVoiceFeatureUnavailableContext("dictation");
+                        if (unavailable) {
+                            this.emit({
+                                type: "dictation_stream_error",
+                                payload: {
+                                    dictationId: msg.dictationId,
+                                    error: unavailable.message,
+                                    retryable: unavailable.retryable,
+                                    reasonCode: unavailable.reasonCode,
+                                    missingModelIds: unavailable.missingModelIds,
+                                },
+                            });
+                            break;
+                        }
+                    }
                     await this.dictationStreamManager.handleStart(msg.dictationId, msg.format);
                     break;
                 case "dictation_stream_chunk":
@@ -726,8 +765,8 @@ export class Session {
                 case "restart_server_request":
                     await this.handleRestartServerRequest(msg.requestId, msg.reason);
                     break;
-                case "initialize_agent_request":
-                    await this.handleInitializeAgentRequest(msg.agentId, msg.requestId);
+                case "fetch_agent_timeline_request":
+                    await this.handleFetchAgentTimelineRequest(msg);
                     break;
                 case "set_agent_mode_request":
                     await this.handleSetAgentModeRequest(msg.agentId, msg.modeId, msg.requestId);
@@ -741,15 +780,15 @@ export class Session {
                 case "agent_permission_response":
                     await this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
                     break;
-                case "git_diff_request":
-                    await this.handleGitDiffRequest(msg.agentId, msg.requestId);
-                    break;
                 case "checkout_status_request":
                     await this.handleCheckoutStatusRequest(msg);
                     break;
                 case "validate_branch_request":
                     await this.handleValidateBranchRequest(msg);
                     break;
+                case "branch_suggestions_request":
+                    await this.handleBranchSuggestionsRequest(msg);
+                    break;
                 case "subscribe_checkout_diff_request":
                     await this.handleSubscribeCheckoutDiffRequest(msg);
                     break;
@@ -780,9 +819,6 @@ export class Session {
                 case "paseo_worktree_archive_request":
                     await this.handlePaseoWorktreeArchiveRequest(msg);
                     break;
-                case "highlighted_diff_request":
-                    await this.handleHighlightedDiffRequest(msg.agentId, msg.requestId);
-                    break;
                 case "file_explorer_request":
                     await this.handleFileExplorerRequest(msg);
                     break;
@@ -795,6 +831,9 @@ export class Session {
                 case "list_provider_models_request":
                     await this.handleListProviderModelsRequest(msg);
                     break;
+                case "list_available_providers_request":
+                    await this.handleListAvailableProvidersRequest(msg);
+                    break;
                 case "speech_models_list_request":
                     await this.handleSpeechModelsListRequest(msg);
                     break;
@@ -847,6 +886,12 @@ export class Session {
                 case "kill_terminal_request":
                     await this.handleKillTerminalRequest(msg);
                     break;
+                case "attach_terminal_stream_request":
+                    await this.handleAttachTerminalStreamRequest(msg);
+                    break;
+                case "detach_terminal_stream_request":
+                    this.handleDetachTerminalStreamRequest(msg);
+                    break;
             }
         }
         catch (error) {
@@ -880,6 +925,58 @@ export class Session {
             });
         }
     }
+    handleBinaryFrame(frame) {
+        switch (frame.channel) {
+            case BinaryMuxChannel.Terminal:
+                this.handleTerminalBinaryFrame(frame);
+                break;
+            default:
+                this.sessionLogger.warn({ channel: frame.channel, messageType: frame.messageType }, "Unhandled binary mux channel");
+                break;
+        }
+    }
+    handleTerminalBinaryFrame(frame) {
+        if (frame.messageType === TerminalBinaryMessageType.InputUtf8) {
+            const binding = this.terminalStreams.get(frame.streamId);
+            if (!binding) {
+                this.sessionLogger.warn({ streamId: frame.streamId }, "Terminal stream not found for input");
+                return;
+            }
+            if (!this.terminalManager) {
+                return;
+            }
+            const session = this.terminalManager.getTerminal(binding.terminalId);
+            if (!session) {
+                this.detachTerminalStream(frame.streamId, { emitExit: true });
+                return;
+            }
+            const payload = frame.payload ?? new Uint8Array(0);
+            if (payload.byteLength === 0) {
+                return;
+            }
+            const text = Buffer.from(payload).toString("utf8");
+            if (!text) {
+                return;
+            }
+            session.send({ type: "input", data: text });
+            return;
+        }
+        if (frame.messageType === TerminalBinaryMessageType.Ack) {
+            const binding = this.terminalStreams.get(frame.streamId);
+            if (binding) {
+                if (!Number.isFinite(frame.offset) || frame.offset < 0) {
+                    return;
+                }
+                const nextAckOffset = Math.max(binding.lastAckOffset, Math.min(Math.floor(frame.offset), binding.lastOutputOffset));
+                if (nextAckOffset > binding.lastAckOffset) {
+                    binding.lastAckOffset = nextAckOffset;
+                    this.flushPendingTerminalStreamChunks(frame.streamId, binding);
+                }
+            }
+            return;
+        }
+        this.sessionLogger.warn({ streamId: frame.streamId, messageType: frame.messageType }, "Unhandled terminal binary frame");
+    }
     async handleRestartServerRequest(requestId, reason) {
         if (restartRequested) {
             this.sessionLogger.debug("Restart already requested, ignoring duplicate");
@@ -965,12 +1062,123 @@ export class Session {
             },
         });
     }
+    async handleUpdateAgentRequest(agentId, name, labels, requestId) {
+        this.sessionLogger.info({ agentId, requestId, hasName: typeof name === "string", labelCount: labels ? Object.keys(labels).length : 0 }, "session: update_agent_request");
+        const normalizedName = name?.trim();
+        const normalizedLabels = labels && Object.keys(labels).length > 0 ? labels : undefined;
+        if (!normalizedName && !normalizedLabels) {
+            this.emit({
+                type: "update_agent_response",
+                payload: {
+                    requestId,
+                    agentId,
+                    accepted: false,
+                    error: "Nothing to update (provide name and/or labels)",
+                },
+            });
+            return;
+        }
+        try {
+            const liveAgent = this.agentManager.getAgent(agentId);
+            if (liveAgent) {
+                if (normalizedName) {
+                    await this.agentManager.setTitle(agentId, normalizedName);
+                }
+                if (normalizedLabels) {
+                    await this.agentManager.setLabels(agentId, normalizedLabels);
+                }
+            }
+            else {
+                const existing = await this.agentStorage.get(agentId);
+                if (!existing) {
+                    throw new Error(`Agent not found: ${agentId}`);
+                }
+                await this.agentStorage.upsert({
+                    ...existing,
+                    ...(normalizedName ? { title: normalizedName } : {}),
+                    ...(normalizedLabels
+                        ? { labels: { ...existing.labels, ...normalizedLabels } }
+                        : {}),
+                });
+            }
+            this.emit({
+                type: "update_agent_response",
+                payload: { requestId, agentId, accepted: true, error: null },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId, requestId }, "session: update_agent_request error");
+            this.emit({
+                type: "activity_log",
+                payload: {
+                    id: uuidv4(),
+                    timestamp: new Date(),
+                    type: "error",
+                    content: `Failed to update agent: ${error.message}`,
+                },
+            });
+            this.emit({
+                type: "update_agent_response",
+                payload: {
+                    requestId,
+                    agentId,
+                    accepted: false,
+                    error: error?.message ? String(error.message) : "Failed to update agent",
+                },
+            });
+        }
+    }
+    toVoiceFeatureUnavailableContext(state) {
+        return {
+            reasonCode: state.reasonCode,
+            message: state.message,
+            retryable: state.retryable,
+            missingModelIds: [...state.missingModelIds],
+        };
+    }
+    resolveModeReadinessState(readiness, mode) {
+        if (mode === "voice_mode") {
+            return readiness.realtimeVoice;
+        }
+        return readiness.dictation;
+    }
+    getVoiceFeatureUnavailableResponseMetadata(error) {
+        if (!(error instanceof VoiceFeatureUnavailableError)) {
+            return {};
+        }
+        return {
+            reasonCode: error.reasonCode,
+            retryable: error.retryable,
+            missingModelIds: error.missingModelIds,
+        };
+    }
+    resolveVoiceFeatureUnavailableContext(mode) {
+        const readiness = this.getSpeechReadiness?.();
+        if (!readiness) {
+            return null;
+        }
+        const modeReadiness = this.resolveModeReadinessState(readiness, mode);
+        if (!modeReadiness.enabled) {
+            return this.toVoiceFeatureUnavailableContext(modeReadiness);
+        }
+        if (!readiness.voiceFeature.available) {
+            return this.toVoiceFeatureUnavailableContext(readiness.voiceFeature);
+        }
+        if (!modeReadiness.available) {
+            return this.toVoiceFeatureUnavailableContext(modeReadiness);
+        }
+        return null;
+    }
     /**
      * Handle voice mode toggle
      */
     async handleSetVoiceMode(enabled, agentId, requestId) {
         try {
             if (enabled) {
+                const unavailable = this.resolveVoiceFeatureUnavailableContext("voice_mode");
+                if (unavailable) {
+                    throw new VoiceFeatureUnavailableError(unavailable);
+                }
                 const normalizedAgentId = this.parseVoiceTargetAgentId(agentId ?? "", "set_voice_mode");
                 if (this.isVoiceMode &&
                     this.voiceModeAgentId &&
@@ -1017,6 +1225,7 @@ export class Session {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "Failed to set voice mode";
+            const unavailable = this.getVoiceFeatureUnavailableResponseMetadata(error);
             this.sessionLogger.error({
                 err: error,
                 enabled,
@@ -1031,6 +1240,7 @@ export class Session {
                         agentId: this.voiceModeAgentId,
                         accepted: false,
                         error: errorMessage,
+                        ...unavailable,
                     },
                 });
                 return;
@@ -1318,7 +1528,7 @@ export class Session {
     /**
      * Handle text message to agent (with optional image attachments)
      */
-    async handleSendAgentMessage(agentId, text, messageId, images) {
+    async handleSendAgentMessage(agentId, text, messageId, images, runOptions) {
         this.sessionLogger.info({ agentId, textPreview: text.substring(0, 50), imageCount: images?.length ?? 0 }, `Sending text to agent ${agentId}${images && images.length > 0 ? ` with ${images.length} image attachment(s)` : ''}`);
         try {
             await this.ensureAgentLoaded(agentId);
@@ -1341,46 +1551,13 @@ export class Session {
         catch (error) {
             this.sessionLogger.error({ err: error, agentId }, `Failed to record user message for agent ${agentId}`);
         }
-        this.startAgentStream(agentId, prompt);
-    }
-    /**
-     * Handle on-demand agent initialization request from client
-     */
-    async handleInitializeAgentRequest(agentId, requestId) {
-        this.sessionLogger.info({ agentId }, `Initializing agent ${agentId} on demand`);
-        try {
-            const snapshot = await this.ensureAgentLoaded(agentId);
-            await this.forwardAgentUpdate(snapshot);
-            // Send timeline snapshot after hydration (if any)
-            const timelineSize = this.emitAgentTimelineSnapshot(snapshot);
-            this.emit({
-                type: "initialize_agent_request",
-                payload: {
-                    agentId,
-                    agentStatus: snapshot.lifecycle,
-                    timelineSize,
-                    requestId,
-                },
-            });
-            this.sessionLogger.info({ agentId, timelineSize, status: snapshot.lifecycle }, `Agent ${agentId} initialized with ${timelineSize} timeline item(s); status=${snapshot.lifecycle}`);
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to initialize agent ${agentId}`);
-            this.emit({
-                type: "initialize_agent_request",
-                payload: {
-                    agentId,
-                    requestId,
-                    error: error?.message ?? "Failed to initialize agent",
-                },
-            });
-        }
+        this.startAgentStream(agentId, prompt, runOptions);
     }
     /**
      * Handle create agent request
      */
     async handleCreateAgentRequest(msg) {
-        const { config, worktreeName, requestId, initialPrompt, git, images, labels } = msg;
+        const { config, worktreeName, requestId, initialPrompt, outputSchema, git, images, labels } = msg;
         this.sessionLogger.info({ cwd: config.cwd, provider: config.provider, worktreeName }, `Creating agent in ${config.cwd} (${config.provider})${worktreeName ? ` with worktree ${worktreeName}` : ""}`);
         try {
             const { sessionConfig, worktreeConfig } = await this.buildAgentSessionConfig(config, git, worktreeName, labels);
@@ -1398,7 +1575,7 @@ export class Session {
                     logger: this.sessionLogger,
                 });
                 try {
-                    await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, uuidv4(), images);
+                    await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, uuidv4(), images, outputSchema ? { outputSchema } : undefined);
                 }
                 catch (promptError) {
                     this.sessionLogger.error({ err: promptError, agentId: snapshot.id }, `Failed to run initial prompt for agent ${snapshot.id}`);
@@ -1476,7 +1653,7 @@ export class Session {
             const snapshot = await this.agentManager.resumeAgentFromPersistence(handle, overrides);
             await this.agentManager.hydrateTimelineFromProvider(snapshot.id);
             await this.forwardAgentUpdate(snapshot);
-            const timelineSize = this.emitAgentTimelineSnapshot(snapshot);
+            const timelineSize = this.agentManager.getTimeline(snapshot.id).length;
             if (requestId) {
                 const agentPayload = await this.getAgentPayloadById(snapshot.id);
                 if (!agentPayload) {
@@ -1535,7 +1712,7 @@ export class Session {
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
             await this.forwardAgentUpdate(snapshot);
-            const timelineSize = this.emitAgentTimelineSnapshot(snapshot);
+            const timelineSize = this.agentManager.getTimeline(agentId).length;
             if (requestId) {
                 this.emit({
                     type: "status",
@@ -1752,6 +1929,33 @@ export class Session {
             });
         }
     }
+    async handleListAvailableProvidersRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        try {
+            const providers = await this.agentManager.listProviderAvailability();
+            this.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers,
+                    error: null,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error }, "Failed to list provider availability");
+            this.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers: [],
+                    error: error?.message ?? String(error),
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
     async handleSpeechModelsListRequest(msg) {
         const modelsDir = this.localSpeechModelsDir;
         const models = await Promise.all(listLocalSpeechModels().map(async (model) => {
@@ -2377,52 +2581,6 @@ export class Session {
             throw error;
         }
     }
-    /**
-     * Handle git diff request for an agent
-     */
-    async handleGitDiffRequest(agentId, requestId) {
-        this.sessionLogger.debug({ agentId }, `Handling git diff request for agent ${agentId}`);
-        try {
-            const agents = this.agentManager.listAgents();
-            const agent = agents.find((a) => a.id === agentId);
-            if (!agent) {
-                this.emit({
-                    type: "git_diff_response",
-                    payload: {
-                        agentId,
-                        diff: "",
-                        error: `Agent not found: ${agentId}`,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            const diffResult = await getCheckoutDiff(agent.cwd, { mode: "uncommitted" }, { paseoHome: this.paseoHome });
-            const combinedDiff = diffResult.diff;
-            this.emit({
-                type: "git_diff_response",
-                payload: {
-                    agentId,
-                    diff: combinedDiff,
-                    error: null,
-                    requestId,
-                },
-            });
-            this.sessionLogger.debug({ agentId, diffBytes: combinedDiff.length }, `Git diff for agent ${agentId} completed (${combinedDiff.length} bytes)`);
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to get git diff for agent ${agentId}`);
-            this.emit({
-                type: "git_diff_response",
-                payload: {
-                    agentId,
-                    diff: "",
-                    error: error.message,
-                    requestId,
-                },
-            });
-        }
-    }
     async handleCheckoutStatusRequest(msg) {
         const { cwd, requestId } = msg;
         try {
@@ -2581,6 +2739,31 @@ export class Session {
             });
         }
     }
+    async handleBranchSuggestionsRequest(msg) {
+        const { cwd, query, limit, requestId } = msg;
+        try {
+            const resolvedCwd = expandTilde(cwd);
+            const branches = await listBranchSuggestions(resolvedCwd, { query, limit });
+            this.emit({
+                type: "branch_suggestions_response",
+                payload: {
+                    branches,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: "branch_suggestions_response",
+                payload: {
+                    branches: [],
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
     normalizeCheckoutDiffCompare(compare) {
         if (compare.mode === "uncommitted") {
             return { mode: "uncommitted" };
@@ -2752,30 +2935,42 @@ export class Session {
             latestPayload: null,
             latestFingerprint: null,
         };
-        const watchPaths = new Set([cwd]);
-        if (watchRoot) {
-            watchPaths.add(watchRoot);
-        }
+        const repoWatchPath = watchRoot ?? cwd;
+        const watchPaths = new Set([repoWatchPath]);
         const gitDir = await this.resolveCheckoutGitDir(cwd);
         if (gitDir) {
             watchPaths.add(gitDir);
         }
-        let hasWatchRootCoverage = false;
+        let hasRecursiveRepoCoverage = false;
+        const allowRecursiveRepoWatch = process.platform !== "linux";
         for (const watchPath of watchPaths) {
+            const shouldTryRecursive = watchPath === repoWatchPath && allowRecursiveRepoWatch;
             const createWatcher = (recursive) => watch(watchPath, { recursive }, () => {
                 this.scheduleCheckoutDiffTargetRefresh(target);
             });
             let watcher = null;
+            let watcherIsRecursive = false;
             try {
-                watcher = createWatcher(true);
+                if (shouldTryRecursive) {
+                    watcher = createWatcher(true);
+                    watcherIsRecursive = true;
+                }
+                else {
+                    watcher = createWatcher(false);
+                }
             }
             catch (error) {
-                try {
-                    watcher = createWatcher(false);
-                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff recursive watch unavailable; using non-recursive fallback");
+                if (shouldTryRecursive) {
+                    try {
+                        watcher = createWatcher(false);
+                        this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff recursive watch unavailable; using non-recursive fallback");
+                    }
+                    catch (fallbackError) {
+                        this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
+                    }
                 }
-                catch (fallbackError) {
-                    this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
+                else {
+                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
                 }
             }
             if (!watcher) {
@@ -2785,11 +2980,11 @@ export class Session {
                 this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff watcher error");
             });
             target.watchers.push(watcher);
-            if (watchRoot && watchPath === watchRoot) {
-                hasWatchRootCoverage = true;
+            if (watchPath === repoWatchPath && watcherIsRecursive) {
+                hasRecursiveRepoCoverage = true;
             }
         }
-        const missingRepoCoverage = Boolean(watchRoot) && !hasWatchRootCoverage;
+        const missingRepoCoverage = !hasRecursiveRepoCoverage;
         if (target.watchers.length === 0 || missingRepoCoverage) {
             target.fallbackRefreshInterval = setInterval(() => {
                 this.scheduleCheckoutDiffTargetRefresh(target);
@@ -2800,7 +2995,7 @@ export class Session {
                 intervalMs: CHECKOUT_DIFF_FALLBACK_REFRESH_MS,
                 reason: target.watchers.length === 0
                     ? "no_watchers"
-                    : "missing_repo_root_coverage",
+                    : "missing_recursive_repo_root_coverage",
             }, "Checkout diff watchers unavailable; using timed refresh fallback");
         }
         this.checkoutDiffTargets.set(targetKey, target);
@@ -3051,12 +3246,13 @@ export class Session {
     async handleCheckoutPrStatusRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            const status = await getPullRequestStatus(cwd);
+            const prStatus = await getPullRequestStatus(cwd);
             this.emit({
                 type: "checkout_pr_status_response",
                 payload: {
                     cwd,
-                    status,
+                    status: prStatus.status,
+                    githubFeaturesEnabled: prStatus.githubFeaturesEnabled,
                     error: null,
                     requestId,
                 },
@@ -3068,6 +3264,7 @@ export class Session {
                 payload: {
                     cwd,
                     status: null,
+                    githubFeaturesEnabled: true,
                     error: this.toCheckoutError(error),
                     requestId,
                 },
@@ -3223,185 +3420,6 @@ export class Session {
             });
         }
     }
-    /**
-     * Handle highlighted diff request - returns parsed and syntax-highlighted diff
-     */
-    async handleHighlightedDiffRequest(agentId, requestId) {
-        this.sessionLogger.debug({ agentId }, `Handling highlighted diff request for agent ${agentId}`);
-        // Maximum lines changed before we skip showing the diff content
-        const MAX_DIFF_LINES = 5000;
-        try {
-            const agents = this.agentManager.listAgents();
-            const agent = agents.find((a) => a.id === agentId);
-            if (!agent) {
-                this.emit({
-                    type: "highlighted_diff_response",
-                    payload: {
-                        agentId,
-                        files: [],
-                        error: `Agent not found: ${agentId}`,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            // Step 1: Get the list of changed files with their stats (numstat gives additions/deletions per file)
-            const { stdout: numstatOutput } = await execAsync("git diff --numstat HEAD", { cwd: agent.cwd });
-            // Get file statuses (A=added, D=deleted, M=modified) to detect deleted files
-            const { stdout: nameStatusOutput } = await execAsync("git diff --name-status HEAD", { cwd: agent.cwd });
-            const deletedFiles = new Set();
-            const addedFiles = new Set();
-            for (const line of nameStatusOutput.trim().split("\n").filter(Boolean)) {
-                const [status, ...pathParts] = line.split("\t");
-                const path = pathParts.join("\t");
-                if (status === "D") {
-                    deletedFiles.add(path);
-                }
-                else if (status === "A") {
-                    addedFiles.add(path);
-                }
-            }
-            const fileStats = [];
-            for (const line of numstatOutput.trim().split("\n").filter(Boolean)) {
-                const parts = line.split("\t");
-                if (parts.length >= 3) {
-                    const [addStr, delStr, ...pathParts] = parts;
-                    const path = pathParts.join("\t"); // Handle paths with tabs
-                    const isBinary = addStr === "-" && delStr === "-";
-                    fileStats.push({
-                        path,
-                        additions: isBinary ? 0 : parseInt(addStr, 10),
-                        deletions: isBinary ? 0 : parseInt(delStr, 10),
-                        isBinary,
-                        isTracked: true,
-                        isDeleted: deletedFiles.has(path),
-                        isNew: addedFiles.has(path),
-                    });
-                }
-            }
-            // Step 2: Get untracked files
-            try {
-                const { stdout: untrackedFiles } = await execAsync("git ls-files --others --exclude-standard", { cwd: agent.cwd });
-                for (const filePath of untrackedFiles.trim().split("\n").filter(Boolean)) {
-                    // Use git's numstat with --no-index to detect binary files (cross-platform)
-                    // Binary files show as "-\t-\tfilepath", text files show line counts
-                    try {
-                        const { stdout: numstatLine } = await execAsync(`git diff --numstat --no-index /dev/null "${filePath}" || true`, { cwd: agent.cwd });
-                        const parts = numstatLine.trim().split("\t");
-                        const isBinary = parts[0] === "-" && parts[1] === "-";
-                        const additions = isBinary ? 0 : (parseInt(parts[0], 10) || 0);
-                        fileStats.push({
-                            path: filePath,
-                            additions,
-                            deletions: 0,
-                            isBinary,
-                            isTracked: false,
-                            isDeleted: false,
-                            isNew: true,
-                        });
-                    }
-                    catch {
-                        // If we can't determine, assume text and try to get it
-                        fileStats.push({
-                            path: filePath,
-                            additions: 0,
-                            deletions: 0,
-                            isBinary: false,
-                            isTracked: false,
-                            isDeleted: false,
-                            isNew: true,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Ignore errors getting untracked files
-            }
-            // Step 3: Fetch diffs per-file, respecting limits
-            const allFiles = [];
-            for (const stats of fileStats) {
-                const totalLines = stats.additions + stats.deletions;
-                // Handle binary files
-                if (stats.isBinary) {
-                    allFiles.push({
-                        path: stats.path,
-                        isNew: stats.isNew,
-                        isDeleted: stats.isDeleted,
-                        additions: 0,
-                        deletions: 0,
-                        hunks: [],
-                        status: "binary",
-                    });
-                    continue;
-                }
-                // Handle files that are too large
-                if (totalLines > MAX_DIFF_LINES) {
-                    allFiles.push({
-                        path: stats.path,
-                        isNew: stats.isNew,
-                        isDeleted: stats.isDeleted,
-                        additions: stats.additions,
-                        deletions: stats.deletions,
-                        hunks: [],
-                        status: "too_large",
-                    });
-                    continue;
-                }
-                // Fetch the actual diff for this file
-                try {
-                    let fileDiff;
-                    if (stats.isTracked) {
-                        const { stdout } = await execAsync(`git diff HEAD -- "${stats.path}"`, { cwd: agent.cwd });
-                        fileDiff = stdout;
-                    }
-                    else {
-                        const { stdout } = await execAsync(`git diff --no-index /dev/null "${stats.path}" || true`, { cwd: agent.cwd });
-                        fileDiff = stdout;
-                    }
-                    if (fileDiff) {
-                        const parsedFiles = await parseAndHighlightDiff(fileDiff, agent.cwd);
-                        for (const file of parsedFiles) {
-                            allFiles.push({ ...file, status: "ok" });
-                        }
-                    }
-                }
-                catch {
-                    // If diff fails for this file, add it with empty hunks
-                    allFiles.push({
-                        path: stats.path,
-                        isNew: stats.isNew,
-                        isDeleted: stats.isDeleted,
-                        additions: stats.additions,
-                        deletions: stats.deletions,
-                        hunks: [],
-                        status: "ok",
-                    });
-                }
-            }
-            this.emit({
-                type: "highlighted_diff_response",
-                payload: {
-                    agentId,
-                    files: allFiles,
-                    error: null,
-                    requestId,
-                },
-            });
-            this.sessionLogger.debug({ agentId, fileCount: allFiles.length }, `Highlighted diff for agent ${agentId} completed (${allFiles.length} files)`);
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to get highlighted diff for agent ${agentId}`);
-            this.emit({
-                type: "highlighted_diff_response",
-                payload: {
-                    agentId,
-                    files: [],
-                    error: error.message,
-                    requestId,
-                },
-            });
-        }
-    }
     /**
      * Handle read-only file explorer requests scoped to an agent's cwd
      */
@@ -3737,6 +3755,77 @@ export class Session {
             payload: { requestId, agent, error: null },
         });
     }
+    async handleFetchAgentTimelineRequest(msg) {
+        const direction = msg.direction ?? (msg.cursor ? "after" : "tail");
+        const projection = msg.projection ?? "projected";
+        const limit = msg.limit ?? (direction === "after" ? 0 : undefined);
+        const cursor = msg.cursor
+            ? {
+                epoch: msg.cursor.epoch,
+                seq: msg.cursor.seq,
+            }
+            : undefined;
+        try {
+            const snapshot = await this.ensureAgentLoaded(msg.agentId);
+            const timeline = this.agentManager.fetchTimeline(msg.agentId, {
+                direction,
+                cursor,
+                limit,
+            });
+            const projected = projectTimelineRows(timeline.rows, snapshot.provider, projection);
+            const firstRow = timeline.rows[0];
+            const lastRow = timeline.rows[timeline.rows.length - 1];
+            const startCursor = firstRow
+                ? { epoch: timeline.epoch, seq: firstRow.seq }
+                : null;
+            const endCursor = lastRow
+                ? { epoch: timeline.epoch, seq: lastRow.seq }
+                : null;
+            this.emit({
+                type: "fetch_agent_timeline_response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    direction,
+                    projection,
+                    epoch: timeline.epoch,
+                    reset: timeline.reset,
+                    staleCursor: timeline.staleCursor,
+                    gap: timeline.gap,
+                    window: timeline.window,
+                    startCursor,
+                    endCursor,
+                    hasOlder: timeline.hasOlder,
+                    hasNewer: timeline.hasNewer,
+                    entries: projected,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle fetch_agent_timeline_request");
+            this.emit({
+                type: "fetch_agent_timeline_response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    direction,
+                    projection,
+                    epoch: "",
+                    reset: false,
+                    staleCursor: false,
+                    gap: false,
+                    window: { minSeq: 0, maxSeq: 0, nextSeq: 0 },
+                    startCursor: null,
+                    endCursor: null,
+                    hasOlder: false,
+                    hasNewer: false,
+                    entries: [],
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
     async handleSendAgentMessageRequest(msg) {
         const resolved = await this.resolveAgentIdentifier(msg.agentId);
         if (!resolved.ok) {
@@ -3825,7 +3914,7 @@ export class Session {
         if (!resolved.ok) {
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status: "error", final: null, error: resolved.error },
+                payload: { requestId, status: "error", final: null, error: resolved.error, lastMessage: null },
             });
             return;
         }
@@ -3841,6 +3930,7 @@ export class Session {
                         status: "error",
                         final: null,
                         error: `Agent not found: ${agentId}`,
+                        lastMessage: null,
                     },
                 });
                 return;
@@ -3853,7 +3943,7 @@ export class Session {
                     : "idle";
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status, final, error: null },
+                payload: { requestId, status, final, error: null, lastMessage: null },
             });
             return;
         }
@@ -3877,7 +3967,7 @@ export class Session {
                     : "idle";
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status, final, error: null },
+                payload: { requestId, status, final, error: null, lastMessage: result.lastMessage },
             });
         }
         catch (error) {
@@ -3894,6 +3984,7 @@ export class Session {
                         status: "error",
                         final,
                         error: message,
+                        lastMessage: null,
                     },
                 });
                 return;
@@ -3904,37 +3995,13 @@ export class Session {
             }
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status: "timeout", final, error: null },
+                payload: { requestId, status: "timeout", final, error: null, lastMessage: null },
             });
         }
         finally {
             clearTimeout(timeoutHandle);
         }
     }
-    emitAgentTimelineSnapshot(agent) {
-        const timeline = this.agentManager.getTimeline(agent.id);
-        const events = timeline.flatMap((item) => {
-            const serializedEvent = serializeAgentStreamEvent({
-                type: "timeline",
-                provider: agent.provider,
-                item,
-            });
-            if (!serializedEvent) {
-                return [];
-            }
-            return [
-                {
-                    event: serializedEvent,
-                    timestamp: new Date().toISOString(),
-                },
-            ];
-        });
-        this.emit({
-            type: "agent_stream_snapshot",
-            payload: { agentId: agent.id, events },
-        });
-        return timeline.length;
-    }
     /**
      * Handle audio chunk for buffering and transcription
      */
@@ -4386,11 +4453,22 @@ export class Session {
         }
         this.onMessage(msg);
     }
+    emitBinary(frame) {
+        if (!this.onBinaryMessage) {
+            return;
+        }
+        try {
+            this.onBinaryMessage(frame);
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error }, "Failed to emit binary frame");
+        }
+    }
     /**
      * Clean up session resources
      */
     async cleanup() {
-        this.sessionLogger.info("Cleaning up");
+        this.sessionLogger.trace("Cleaning up");
         if (this.unsubscribeAgentEvents) {
             this.unsubscribeAgentEvents();
             this.unsubscribeAgentEvents = null;
@@ -4428,6 +4506,7 @@ export class Session {
             unsubscribe();
         }
         this.terminalSubscriptions.clear();
+        this.detachAllTerminalStreams({ emitExit: false });
         for (const target of this.checkoutDiffTargets.values()) {
             this.closeCheckoutDiffWatchTarget(target);
         }
@@ -4601,6 +4680,10 @@ export class Session {
             unsubscribe();
             this.terminalSubscriptions.delete(msg.terminalId);
         }
+        const streamId = this.terminalStreamByTerminalId.get(msg.terminalId);
+        if (typeof streamId === "number") {
+            this.detachTerminalStream(streamId, { emitExit: true });
+        }
         this.terminalManager.killTerminal(msg.terminalId);
         this.emit({
             type: "kill_terminal_response",
@@ -4611,5 +4694,213 @@ export class Session {
             },
         });
     }
+    async handleAttachTerminalStreamRequest(msg) {
+        if (!this.terminalManager || !this.onBinaryMessage) {
+            this.emit({
+                type: "attach_terminal_stream_response",
+                payload: {
+                    terminalId: msg.terminalId,
+                    streamId: null,
+                    replayedFrom: 0,
+                    currentOffset: 0,
+                    earliestAvailableOffset: 0,
+                    reset: true,
+                    error: "Terminal streaming not available",
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        const session = this.terminalManager.getTerminal(msg.terminalId);
+        if (!session) {
+            this.emit({
+                type: "attach_terminal_stream_response",
+                payload: {
+                    terminalId: msg.terminalId,
+                    streamId: null,
+                    replayedFrom: 0,
+                    currentOffset: 0,
+                    earliestAvailableOffset: 0,
+                    reset: true,
+                    error: "Terminal not found",
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        if (msg.rows || msg.cols) {
+            const state = session.getState();
+            session.send({
+                type: "resize",
+                rows: msg.rows ?? state.rows,
+                cols: msg.cols ?? state.cols,
+            });
+        }
+        const existingStreamId = this.terminalStreamByTerminalId.get(msg.terminalId);
+        if (typeof existingStreamId === "number") {
+            this.detachTerminalStream(existingStreamId, { emitExit: false });
+        }
+        const streamId = this.allocateTerminalStreamId();
+        const initialOffset = Math.max(0, Math.floor(msg.resumeOffset ?? 0));
+        const binding = {
+            terminalId: msg.terminalId,
+            unsubscribe: () => { },
+            lastOutputOffset: initialOffset,
+            lastAckOffset: initialOffset,
+            pendingChunks: [],
+            pendingBytes: 0,
+        };
+        this.terminalStreams.set(streamId, binding);
+        this.terminalStreamByTerminalId.set(msg.terminalId, streamId);
+        let rawSub;
+        try {
+            rawSub = session.subscribeRaw((chunk) => {
+                const currentBinding = this.terminalStreams.get(streamId);
+                if (!currentBinding) {
+                    return;
+                }
+                this.enqueueOrEmitTerminalStreamChunk(streamId, currentBinding, {
+                    data: chunk.data,
+                    startOffset: chunk.startOffset,
+                    endOffset: chunk.endOffset,
+                    replay: chunk.replay,
+                });
+            }, { fromOffset: msg.resumeOffset ?? 0 });
+        }
+        catch (error) {
+            this.terminalStreams.delete(streamId);
+            this.terminalStreamByTerminalId.delete(msg.terminalId);
+            throw error;
+        }
+        binding.unsubscribe = rawSub.unsubscribe;
+        binding.lastAckOffset = rawSub.replayedFrom;
+        if (binding.lastOutputOffset < rawSub.replayedFrom) {
+            binding.lastOutputOffset = rawSub.replayedFrom;
+        }
+        this.flushPendingTerminalStreamChunks(streamId, binding);
+        this.emit({
+            type: "attach_terminal_stream_response",
+            payload: {
+                terminalId: msg.terminalId,
+                streamId,
+                replayedFrom: rawSub.replayedFrom,
+                currentOffset: rawSub.currentOffset,
+                earliestAvailableOffset: rawSub.earliestAvailableOffset,
+                reset: rawSub.reset,
+                error: null,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    getTerminalStreamChunkByteLength(chunk) {
+        return Math.max(0, chunk.endOffset - chunk.startOffset);
+    }
+    canEmitTerminalStreamChunk(binding, chunk) {
+        return chunk.startOffset < binding.lastAckOffset + TERMINAL_STREAM_WINDOW_BYTES;
+    }
+    emitTerminalStreamChunk(streamId, binding, chunk) {
+        const payload = new Uint8Array(Buffer.from(chunk.data, "utf8"));
+        this.emitBinary({
+            channel: BinaryMuxChannel.Terminal,
+            messageType: TerminalBinaryMessageType.OutputUtf8,
+            streamId,
+            offset: chunk.startOffset,
+            flags: chunk.replay ? TerminalBinaryFlags.Replay : 0,
+            payload,
+        });
+        binding.lastOutputOffset = chunk.endOffset;
+    }
+    enqueueOrEmitTerminalStreamChunk(streamId, binding, chunk) {
+        const chunkBytes = this.getTerminalStreamChunkByteLength(chunk);
+        if (binding.pendingChunks.length > 0 || !this.canEmitTerminalStreamChunk(binding, chunk)) {
+            if (binding.pendingChunks.length >= TERMINAL_STREAM_MAX_PENDING_CHUNKS ||
+                binding.pendingBytes + chunkBytes > TERMINAL_STREAM_MAX_PENDING_BYTES) {
+                this.sessionLogger.warn({
+                    streamId,
+                    pendingChunks: binding.pendingChunks.length,
+                    pendingBytes: binding.pendingBytes,
+                    chunkBytes,
+                }, "Terminal stream pending buffer overflow; closing stream");
+                this.detachTerminalStream(streamId, { emitExit: true });
+                return;
+            }
+            binding.pendingChunks.push(chunk);
+            binding.pendingBytes += chunkBytes;
+            return;
+        }
+        this.emitTerminalStreamChunk(streamId, binding, chunk);
+    }
+    flushPendingTerminalStreamChunks(streamId, binding) {
+        while (binding.pendingChunks.length > 0) {
+            const next = binding.pendingChunks[0];
+            if (!next || !this.canEmitTerminalStreamChunk(binding, next)) {
+                break;
+            }
+            binding.pendingChunks.shift();
+            binding.pendingBytes -= this.getTerminalStreamChunkByteLength(next);
+            if (binding.pendingBytes < 0) {
+                binding.pendingBytes = 0;
+            }
+            this.emitTerminalStreamChunk(streamId, binding, next);
+        }
+    }
+    handleDetachTerminalStreamRequest(msg) {
+        const success = this.detachTerminalStream(msg.streamId, { emitExit: false });
+        this.emit({
+            type: "detach_terminal_stream_response",
+            payload: {
+                streamId: msg.streamId,
+                success,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    detachAllTerminalStreams(options) {
+        for (const streamId of Array.from(this.terminalStreams.keys())) {
+            this.detachTerminalStream(streamId, options);
+        }
+    }
+    detachTerminalStream(streamId, options) {
+        const binding = this.terminalStreams.get(streamId);
+        if (!binding) {
+            return false;
+        }
+        try {
+            binding.unsubscribe();
+        }
+        catch (error) {
+            this.sessionLogger.warn({ err: error, streamId }, "Failed to unsubscribe terminal stream");
+        }
+        this.terminalStreams.delete(streamId);
+        if (this.terminalStreamByTerminalId.get(binding.terminalId) === streamId) {
+            this.terminalStreamByTerminalId.delete(binding.terminalId);
+        }
+        if (options?.emitExit) {
+            this.emit({
+                type: "terminal_stream_exit",
+                payload: {
+                    streamId,
+                    terminalId: binding.terminalId,
+                },
+            });
+        }
+        return true;
+    }
+    allocateTerminalStreamId() {
+        let attempts = 0;
+        while (attempts < 0xffffffff) {
+            const candidate = this.nextTerminalStreamId >>> 0;
+            this.nextTerminalStreamId = ((this.nextTerminalStreamId + 1) & 0xffffffff) >>> 0;
+            if (candidate === 0) {
+                attempts += 1;
+                continue;
+            }
+            if (!this.terminalStreams.has(candidate)) {
+                return candidate;
+            }
+            attempts += 1;
+        }
+        throw new Error("Unable to allocate terminal stream id");
+    }
 }
 //# sourceMappingURL=session.js.map