@getpaseo/server 0.1.63 → 0.1.65

package/dist/server/server/session.js

@@ -6,10 +6,12 @@ import { realpathSync } from "node:fs";
 import { basename, resolve, sep } from "path";
 import { homedir } from "node:os";
 import { z } from "zod";
+import { CLIENT_CAPS } from "../shared/client-capabilities.js";
 import { isLegacyEditorTargetId, serializeAgentStreamEvent, } from "./messages.js";
-import { captureTerminalLines } from "../terminal/terminal.js";
-import { TerminalOutputCoalescer } from "../terminal/terminal-output-coalescer.js";
-import { TerminalStreamOpcode, encodeTerminalSnapshotPayload, encodeTerminalStreamFrame, decodeTerminalResizePayload, } from "../shared/terminal-stream-protocol.js";
+import { TerminalSessionController } from "../terminal/terminal-session-controller.js";
+import { encodeFileTransferFrame, FileTransferOpcode, } from "../shared/binary-frames/index.js";
+import { CursorError } from "./pagination/cursor.js";
+import { SortablePager } from "./pagination/sortable-pager.js";
 import { TTSManager } from "./agent/tts-manager.js";
 import { STTManager } from "./agent/stt-manager.js";
 import { maybePersistTtsDebugAudio } from "./agent/tts-debug.js";
@@ -22,7 +24,7 @@ import { ensureAgentLoaded } from "./agent/agent-loading.js";
 import { sendPromptToAgent, unarchiveAgentState } from "./agent/mcp-shared.js";
 import { experimental_createMCPClient } from "ai";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { buildWorkspaceScriptPayloads } from "./script-status-projection.js";
+import { buildWorkspaceScriptPayloads, readPaseoConfigForProjection, } from "./script-status-projection.js";
 import { deriveProjectSlug } from "./workspace-git-metadata.js";
 import { spawnWorkspaceScript } from "./worktree-bootstrap.js";
 import { applyMutableProviderConfigToOverrides } from "./daemon-config-store.js";
@@ -38,9 +40,8 @@ import { checkoutLiteFromGitSnapshot, normalizeWorkspaceId as normalizePersisted
 import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "./workspace-registry.js";
 import { buildVoiceModeSystemPrompt, stripVoiceModeSystemPrompt, wrapSpokenInput, } from "./voice-config.js";
 import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
-import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from "./file-explorer/service.js";
+import { listDirectoryEntries, readExplorerFile, readExplorerFileBytes, getDownloadableFileInfo, } from "./file-explorer/service.js";
 import { readPaseoConfigForEdit, writePaseoConfigForEdit, } from "../utils/paseo-config-file.js";
-import { runAsyncWorktreeBootstrap } from "./worktree-bootstrap.js";
 import { archivePersistedWorkspaceRecord } from "./workspace-archive-service.js";
 import { WorkspaceReconciliationService } from "./workspace-reconciliation-service.js";
 import { checkoutResolvedBranch, commitChanges, mergeToBase, mergeFromBase, pullCurrentBranch, pushCurrentBranch, createPullRequest, } from "../utils/checkout-git.js";
@@ -54,10 +55,10 @@ import { ChatServiceError } from "./chat/chat-service.js";
 import { notifyChatMentions } from "./chat/chat-mentions.js";
 import { execCommand } from "../utils/spawn.js";
 import { createGitHubService, } from "../services/github-service.js";
-import { createPaseoWorktree, } from "./paseo-worktree-service.js";
+import { summarizeFetchWorkspacesEntries, WorkspaceDirectory, } from "./workspace-directory.js";
+import { attemptFirstAgentBranchAutoName, createPaseoWorktree, } from "./paseo-worktree-service.js";
 import { createWorktreeCoreDeps } from "./worktree-core.js";
-import { assertSafeGitRef as assertWorktreeSafeGitRef, buildAgentSessionConfig as buildWorktreeAgentSessionConfig, runWorktreeSetupInBackground as runWorktreeSetupInBackgroundSession, handleCreatePaseoWorktreeRequest as handleCreateWorktreeRequest, handlePaseoWorktreeArchiveRequest as handleWorktreeArchiveRequest, handlePaseoWorktreeListRequest as handleWorktreeListRequest, handleWorkspaceSetupStatusRequest as handleWorkspaceSetupStatusRequestMessage, } from "./worktree-session.js";
-import { killTerminalsUnderPath as killWorktreeTerminalsUnderPath } from "./paseo-worktree-archive-service.js";
+import { assertSafeGitRef as assertWorktreeSafeGitRef, buildAgentSessionConfig as buildWorktreeAgentSessionConfig, createPaseoWorktreeWorkflow as createWorktreeWorkflow, handleCreatePaseoWorktreeRequest as handleCreateWorktreeRequest, handlePaseoWorktreeArchiveRequest as handleWorktreeArchiveRequest, handlePaseoWorktreeListRequest as handleWorktreeListRequest, handleWorkspaceSetupStatusRequest as handleWorkspaceSetupStatusRequestMessage, } from "./worktree-session.js";
 import { toWorktreeWireError } from "./worktree-errors.js";
 const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
 const WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY = "__removed__";
@@ -175,7 +176,6 @@ function clientSupportsAllProviders(appVersion) {
 function clientSupportsFlexibleEditorIds(appVersion) {
     return isAppVersionAtLeast(appVersion, MIN_VERSION_FLEXIBLE_EDITOR_IDS);
 }
-const MAX_TERMINAL_STREAM_SLOTS = 256;
 function beginAgentDeleteIfSupported(agentStorage, agentId) {
     if ("beginDelete" in agentStorage && typeof agentStorage.beginDelete === "function") {
         agentStorage.beginDelete(agentId);
@@ -207,50 +207,19 @@ export function resolveCreateAgentTitles(options) {
         provisionalTitle,
     };
 }
-function parseFetchWorkspacesCursorSort(raw) {
-    const cursorSort = [];
-    for (const item of raw) {
-        if (!item ||
-            typeof item !== "object" ||
-            typeof item.key !== "string" ||
-            typeof item.direction !== "string") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_workspaces cursor");
-        }
-        const key = item.key;
-        const direction = item.direction;
-        if ((key !== "status_priority" &&
-            key !== "activity_at" &&
-            key !== "name" &&
-            key !== "project_id") ||
-            (direction !== "asc" && direction !== "desc")) {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_workspaces cursor");
-        }
-        cursorSort.push({ key, direction });
-    }
-    return cursorSort;
-}
-function parseFetchAgentsCursorSort(raw) {
-    const cursorSort = [];
-    for (const item of raw) {
-        if (!item ||
-            typeof item !== "object" ||
-            typeof item.key !== "string" ||
-            typeof item.direction !== "string") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
-        }
-        const key = item.key;
-        const direction = item.direction;
-        if ((key !== "status_priority" &&
-            key !== "created_at" &&
-            key !== "updated_at" &&
-            key !== "title") ||
-            (direction !== "asc" && direction !== "desc")) {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
-        }
-        cursorSort.push({ key, direction });
-    }
-    return cursorSort;
+function getFirstUserMessageText(timeline) {
+    for (const item of timeline) {
+        if (item.type !== "user_message") {
+            continue;
+        }
+        const text = item.text.trim();
+        if (text) {
+            return text;
+        }
+    }
+    return null;
 }
+const FETCH_AGENTS_SORT_KEYS = ["status_priority", "created_at", "updated_at", "title"];
 export function resolveWaitForFinishError(options) {
     if (options.status !== "error") {
         return null;
@@ -258,27 +227,6 @@ export function resolveWaitForFinishError(options) {
     const message = options.final?.lastError;
     return typeof message === "string" && message.trim().length > 0 ? message : "Agent failed";
 }
-function summarizeFetchWorkspacesEntries(entries) {
-    const workspaces = Array.from(entries, (entry) => ({
-        id: entry.id,
-        projectId: entry.projectId,
-        projectDisplayName: entry.projectDisplayName,
-        name: entry.name,
-        status: entry.status,
-        workspaceKind: entry.workspaceKind,
-        activityAt: entry.activityAt,
-    }));
-    const statusCounts = new Map();
-    for (const workspace of workspaces) {
-        statusCounts.set(workspace.status, (statusCounts.get(workspace.status) ?? 0) + 1);
-    }
-    return {
-        count: workspaces.length,
-        projectIds: [...new Set(workspaces.map((workspace) => workspace.projectId))],
-        statusCounts: Object.fromEntries(statusCounts),
-        workspaces,
-    };
-}
 class SessionRequestError extends Error {
     constructor(code, message) {
         super(message);
@@ -305,6 +253,31 @@ class VoiceFeatureUnavailableError extends Error {
         this.missingModelIds = [...context.missingModelIds];
     }
 }
+function buildImportPersistenceHandle(input) {
+    const cwd = input.cwd ?? process.cwd();
+    return {
+        provider: input.provider,
+        sessionId: input.sessionId,
+        nativeHandle: input.sessionId,
+        metadata: {
+            provider: input.provider,
+            cwd,
+        },
+    };
+}
+function applyImportCwdOverride(handle, cwd) {
+    if (!cwd) {
+        return handle;
+    }
+    return {
+        ...handle,
+        metadata: {
+            ...handle.metadata,
+            provider: handle.provider,
+            cwd,
+        },
+    };
+}
 function convertPCMToWavBuffer(pcmBuffer, sampleRate, channels, bitsPerSample) {
     const headerSize = 44;
     const wavBuffer = Buffer.alloc(headerSize + pcmBuffer.length);
@@ -326,6 +299,13 @@ function convertPCMToWavBuffer(pcmBuffer, sampleRate, channels, bitsPerSample) {
     pcmBuffer.copy(wavBuffer, 44);
     return wavBuffer;
 }
+function parseClientCapabilities(capabilities) {
+    if (!capabilities) {
+        return new Set();
+    }
+    const known = new Set(Object.values(CLIENT_CAPS));
+    return new Set(Object.entries(capabilities).flatMap(([key, value]) => value === true && known.has(key) ? [key] : []));
+}
 /**
  * Session represents a single connected client session.
  * It owns all state management, orchestration logic, and message processing.
@@ -358,12 +338,6 @@ export class Session {
         this.clientActivity = null;
         this.MOBILE_BACKGROUND_STREAM_GRACE_MS = 60000;
         this.unsubscribeProviderSnapshotEvents = null;
-        this.subscribedTerminalDirectories = new Set();
-        this.unsubscribeTerminalsChanged = null;
-        this.terminalExitSubscriptions = new Map();
-        this.activeTerminalStreams = new Map();
-        this.terminalIdToSlot = new Map();
-        this.nextTerminalSlot = 0;
         this.inflightRequests = 0;
         this.peakInflightRequests = 0;
         this.availableEditorTargetsCache = new TTLCache({
@@ -381,16 +355,28 @@ export class Session {
         this.workspaceGitSubscriptions = new Map();
         this.voiceModeAgentId = null;
         this.voiceModeBaseConfig = null;
-        this.workspaceStatePriority = {
-            needs_input: 0,
-            failed: 1,
-            running: 2,
-            attention: 3,
-            done: 4,
-        };
-        const { clientId, appVersion, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, tts, terminalManager, providerSnapshotManager, scriptRouteStore, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, voice, voiceBridge, dictation, agentProviderRuntimeSettings, providerOverrides, isDev, } = options;
+        this.agentsPager = new SortablePager({
+            validKeys: FETCH_AGENTS_SORT_KEYS,
+            defaultSort: [{ key: "updated_at", direction: "desc" }],
+            label: "fetch_agents",
+            getId: (agent) => agent.id,
+            getSortValue: (agent, key) => {
+                switch (key) {
+                    case "status_priority":
+                        return this.getStatusPriority(agent);
+                    case "created_at":
+                        return Date.parse(agent.createdAt);
+                    case "updated_at":
+                        return Date.parse(agent.updatedAt);
+                    case "title":
+                        return agent.title?.toLocaleLowerCase() ?? "";
+                }
+            },
+        });
+        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, tts, terminalManager, providerSnapshotManager, scriptRouteStore, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, voice, voiceBridge, dictation, agentProviderRuntimeSettings, providerOverrides, isDev, } = options;
         this.clientId = clientId;
         this.appVersion = appVersion ?? null;
+        this.clientCapabilities = parseClientCapabilities(clientCapabilities);
         this.sessionId = uuidv4();
         this.onMessage = onMessage;
         this.onBinaryMessage = onBinaryMessage ?? null;
@@ -416,6 +402,14 @@ export class Session {
         this.daemonConfigStore = daemonConfigStore;
         this.mcpBaseUrl = mcpBaseUrl ?? null;
         this.terminalManager = terminalManager;
+        this.terminalController = new TerminalSessionController({
+            terminalManager,
+            emit: (msg) => this.emit(msg),
+            emitBinary: (frame) => this.emitBinary(frame),
+            hasBinaryChannel: () => this.onBinaryMessage !== null,
+            isPathWithinRoot: (rootPath, candidatePath) => this.isPathWithinRoot(rootPath, candidatePath),
+            sessionLogger: this.sessionLogger,
+        });
         this.providerSnapshotManager = providerSnapshotManager ?? null;
         this.scriptRouteStore = scriptRouteStore ?? null;
         this.scriptRuntimeStore = scriptRuntimeStore ?? null;
@@ -430,6 +424,14 @@ export class Session {
         this.providerOverrides = providerOverrides;
         this.isDev = isDev === true;
         this.abortController = new AbortController();
+        this.workspaceDirectory = new WorkspaceDirectory({
+            logger: this.sessionLogger,
+            projectRegistry: this.projectRegistry,
+            workspaceRegistry: this.workspaceRegistry,
+            listAgentPayloads: () => this.listAgentPayloads(),
+            isProviderVisibleToClient: (provider) => this.isProviderVisibleToClient(provider),
+            buildWorkspaceDescriptor: (input) => this.buildWorkspaceDescriptor(input),
+        });
         this.initializePerSessionManagers({ tts, stt, dictation });
         // Initialize agent MCP client asynchronously
         void this.initializeAgentMcp();
@@ -441,6 +443,12 @@ export class Session {
             this.appVersion = appVersion;
         }
     }
+    updateClientCapabilities(capabilities) {
+        this.clientCapabilities = parseClientCapabilities(capabilities);
+    }
+    supports(capability) {
+        return this.clientCapabilities.has(capability);
+    }
     async syncWorkspaceGitObserverForWorkspace(workspace) {
         const descriptor = await this.describeWorkspaceRecordWithGitData(workspace);
         this.syncWorkspaceGitObservers([descriptor]);
@@ -451,8 +459,17 @@ export class Session {
     async archiveWorkspaceRecordForExternalMutation(workspaceId) {
         await this.archiveWorkspaceRecord(workspaceId);
     }
+    markWorkspaceArchivingForExternalMutation(workspaceIds, archivingAt) {
+        this.markWorkspaceArchiving(workspaceIds, archivingAt);
+    }
+    clearWorkspaceArchivingForExternalMutation(workspaceIds) {
+        this.clearWorkspaceArchiving(workspaceIds);
+    }
+    async emitWorkspaceUpdatesForExternalWorkspaceIds(workspaceIds) {
+        await this.emitWorkspaceUpdatesForWorkspaceIds(workspaceIds);
+    }
     async emitWorkspaceUpdatesForExternalCwds(cwds) {
-        await this.emitWorkspaceUpdatesForCwds(cwds);
+        await Promise.all(Array.from(cwds, (cwd) => this.emitWorkspaceUpdateForCwd(cwd)));
     }
     async warmWorkspaceGitDataForWorkspace(workspace) {
         await this.syncWorkspaceGitObserverForWorkspace(workspace);
@@ -465,9 +482,10 @@ export class Session {
         return this.clientActivity;
     }
     getRuntimeMetrics() {
+        const terminalMetrics = this.terminalController.getMetrics();
         return {
-            terminalDirectorySubscriptionCount: this.subscribedTerminalDirectories.size,
-            terminalSubscriptionCount: this.activeTerminalStreams.size,
+            terminalDirectorySubscriptionCount: terminalMetrics.directorySubscriptionCount,
+            terminalSubscriptionCount: terminalMetrics.streamSubscriptionCount,
             inflightRequests: this.inflightRequests,
             peakInflightRequests: this.peakInflightRequests,
         };
@@ -605,9 +623,7 @@ export class Session {
      * Subscribe to AgentManager events and forward them to the client
      */
     subscribeToOptionalManagers() {
-        if (this.terminalManager) {
-            this.unsubscribeTerminalsChanged = this.terminalManager.subscribeTerminalsChanged((event) => this.handleTerminalsChanged(event));
-        }
+        this.terminalController.start();
         if (this.providerSnapshotManager) {
             const handleProviderSnapshotChange = (entries, cwd) => {
                 // COMPAT(providersSnapshot): keep provider visibility gating for older clients.
@@ -1110,6 +1126,8 @@ export class Session {
                 return this.handleCreateAgentRequest(msg);
             case "resume_agent_request":
                 return this.handleResumeAgentRequest(msg);
+            case "import_agent_request":
+                return this.handleImportAgentRequest(msg);
             case "refresh_agent_request":
                 return this.handleRefreshAgentRequest(msg);
             case "cancel_agent_request":
@@ -1336,34 +1354,10 @@ export class Session {
         }
     }
     dispatchTerminalMessage(msg) {
-        switch (msg.type) {
-            case "subscribe_terminals_request":
-                this.handleSubscribeTerminalsRequest(msg);
-                return undefined;
-            case "unsubscribe_terminals_request":
-                this.handleUnsubscribeTerminalsRequest(msg);
-                return undefined;
-            case "list_terminals_request":
-                return this.handleListTerminalsRequest(msg);
-            case "create_terminal_request":
-                return this.handleCreateTerminalRequest(msg);
-            case "start_workspace_script_request":
-                return this.handleStartWorkspaceScriptRequest(msg);
-            case "subscribe_terminal_request":
-                return this.handleSubscribeTerminalRequest(msg);
-            case "unsubscribe_terminal_request":
-                this.handleUnsubscribeTerminalRequest(msg);
-                return undefined;
-            case "terminal_input":
-                this.handleTerminalInput(msg);
-                return undefined;
-            case "kill_terminal_request":
-                return this.handleKillTerminalRequest(msg);
-            case "capture_terminal_request":
-                return this.handleCaptureTerminalRequest(msg);
-            default:
-                return undefined;
+        if (msg.type === "start_workspace_script_request") {
+            return this.handleStartWorkspaceScriptRequest(msg);
         }
+        return this.terminalController.dispatch(msg);
     }
     dispatchChatScheduleLoopMessage(msg) {
         switch (msg.type) {
@@ -1423,38 +1417,7 @@ export class Session {
         this.peakInflightRequests = this.inflightRequests;
     }
     handleBinaryFrame(frame) {
-        const activeStream = this.activeTerminalStreams.get(frame.slot);
-        if (!activeStream || !this.terminalManager) {
-            return;
-        }
-        const terminal = this.terminalManager.getTerminal(activeStream.terminalId);
-        if (!terminal) {
-            this.detachTerminalStream(activeStream.terminalId, { emitExit: true });
-            return;
-        }
-        switch (frame.opcode) {
-            case TerminalStreamOpcode.Input: {
-                if (frame.payload.byteLength === 0) {
-                    return;
-                }
-                const text = Buffer.from(frame.payload).toString("utf8");
-                if (!text) {
-                    return;
-                }
-                terminal.send({ type: "input", data: text });
-                return;
-            }
-            case TerminalStreamOpcode.Resize: {
-                const resize = decodeTerminalResizePayload(frame.payload);
-                if (!resize) {
-                    return;
-                }
-                terminal.send({ type: "resize", rows: resize.rows, cols: resize.cols });
-                return;
-            }
-            default:
-                return;
-        }
+        this.terminalController.handleBinaryFrame(frame);
     }
     async handleRestartServerRequest(requestId, reason) {
         const payload = {
@@ -1633,7 +1596,7 @@ export class Session {
         const terminals = [];
         for (const terminalId of msg.terminalIds) {
             try {
-                terminals.push(this.killTerminalForClose(terminalId));
+                terminals.push(this.terminalController.killTerminalForClose(terminalId));
             }
             catch (error) {
                 this.sessionLogger.warn({ err: error, terminalId, requestId: msg.requestId }, "Failed to kill terminal during close_items batch");
@@ -2064,14 +2027,22 @@ export class Session {
                 ...config,
                 ...(provisionalTitle ? { title: provisionalTitle } : {}),
             };
-            const { sessionConfig, worktreeBootstrap } = await this.buildAgentSessionConfig(resolvedConfig, git, worktreeName, attachments);
-            const resolvedWorkspace = msg.workspaceId
+            const firstAgentContext = {
+                ...(trimmedPrompt ? { prompt: trimmedPrompt } : {}),
+                ...(attachments && attachments.length > 0 ? { attachments } : {}),
+            };
+            const { sessionConfig, setupContinuation } = await this.buildAgentSessionConfig(resolvedConfig, git, worktreeName, firstAgentContext);
+            let resolvedWorkspace = msg.workspaceId
                 ? await this.workspaceRegistry.get(msg.workspaceId)
                 : ((await this.findWorkspaceByDirectory(sessionConfig.cwd)) ??
                     (await this.findOrCreateWorkspaceForDirectory(sessionConfig.cwd)));
             if (!resolvedWorkspace) {
                 throw new Error(`Workspace not found: ${msg.workspaceId}`);
             }
+            resolvedWorkspace = await this.maybeAutoNameWorkspaceBranchForFirstAgent({
+                workspace: resolvedWorkspace,
+                firstAgentContext,
+            });
             const snapshot = await this.agentManager.createAgent({
                 ...sessionConfig,
                 cwd: resolvedWorkspace.cwd,
@@ -2102,25 +2073,9 @@ export class Session {
                     },
                 });
             }
-            if (worktreeBootstrap) {
-                void runAsyncWorktreeBootstrap({
-                    agentId: snapshot.id,
-                    worktree: worktreeBootstrap.worktree,
-                    shouldBootstrap: worktreeBootstrap.shouldBootstrap,
-                    terminalManager: this.terminalManager,
-                    appendTimelineItem: (item) => appendTimelineItemIfAgentKnown({
-                        agentManager: this.agentManager,
-                        agentId: snapshot.id,
-                        item,
-                    }),
-                    emitLiveTimelineItem: (item) => emitLiveTimelineItemIfAgentKnown({
-                        agentManager: this.agentManager,
-                        agentId: snapshot.id,
-                        item,
-                    }),
-                    logger: this.sessionLogger,
-                });
-            }
+            setupContinuation?.startAfterAgentCreate({
+                agentId: snapshot.id,
+            });
             this.sessionLogger.info({ agentId: snapshot.id, provider: snapshot.provider }, `Created agent ${snapshot.id} (${snapshot.provider})`);
         }
         catch (error) {
@@ -2164,9 +2119,6 @@ export class Session {
             explicitTitle: params.explicitTitle,
             paseoHome: this.paseoHome,
             logger: this.sessionLogger,
-            deps: {
-                workspaceGitService: this.workspaceGitService,
-            },
         });
         const started = await this.handleSendAgentMessage(snapshot.id, trimmedPrompt || "", resolveClientMessageId(clientMessageId), images, attachments, outputSchema ? { outputSchema } : undefined);
         if (!started.ok) {
@@ -2223,6 +2175,83 @@ export class Session {
             });
         }
     }
+    async handleImportAgentRequest(msg) {
+        const { provider, sessionId, cwd, labels, requestId } = msg;
+        this.sessionLogger.info({ sessionId, provider }, `Importing agent ${sessionId} (${provider})`);
+        try {
+            const descriptor = await this.agentManager.findPersistedAgent(provider, sessionId);
+            if (!descriptor && provider === "opencode" && !cwd) {
+                throw new Error("OpenCode sessions require --cwd when the session cannot be found in persisted agents");
+            }
+            const handle = descriptor
+                ? applyImportCwdOverride(descriptor.persistence, cwd)
+                : buildImportPersistenceHandle({ provider, sessionId, cwd });
+            const overrides = cwd ? { cwd } : undefined;
+            await this.unarchiveAgentByHandle(handle);
+            const snapshot = await this.agentManager.resumeAgentFromPersistence(handle, overrides, undefined, {
+                labels,
+            });
+            await unarchiveAgentState(this.agentStorage, this.agentManager, snapshot.id);
+            await this.agentManager.hydrateTimelineFromProvider(snapshot.id);
+            await this.applyImportedAgentTitle(snapshot);
+            await this.forwardAgentUpdate(snapshot);
+            const timelineSize = this.agentManager.getTimeline(snapshot.id).length;
+            const agentPayload = await this.buildAgentPayload(snapshot);
+            this.emit({
+                type: "status",
+                payload: {
+                    status: "agent_resumed",
+                    agentId: snapshot.id,
+                    requestId,
+                    timelineSize,
+                    agent: agentPayload,
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.sessionLogger.error({ err: error }, "Failed to import agent");
+            this.emit({
+                type: "status",
+                payload: {
+                    status: "agent_create_failed",
+                    requestId,
+                    error: message,
+                },
+            });
+            this.emit({
+                type: "activity_log",
+                payload: {
+                    id: uuidv4(),
+                    timestamp: new Date(),
+                    type: "error",
+                    content: `Failed to import agent: ${message}`,
+                },
+            });
+        }
+    }
+    async applyImportedAgentTitle(snapshot) {
+        const initialPrompt = getFirstUserMessageText(this.agentManager.getTimeline(snapshot.id));
+        if (!initialPrompt) {
+            return;
+        }
+        const { explicitTitle, provisionalTitle } = resolveCreateAgentTitles({
+            configTitle: snapshot.config.title,
+            initialPrompt,
+        });
+        if (!explicitTitle && provisionalTitle) {
+            await this.agentManager.setTitle(snapshot.id, provisionalTitle);
+        }
+        scheduleAgentMetadataGeneration({
+            agentManager: this.agentManager,
+            agentId: snapshot.id,
+            cwd: snapshot.cwd,
+            initialPrompt,
+            explicitTitle,
+            paseoHome: this.paseoHome,
+            logger: this.sessionLogger,
+        });
+    }
     async handleRefreshAgentRequest(msg) {
         const { agentId, requestId } = msg;
         this.sessionLogger.info({ agentId }, `Refreshing agent ${agentId} from persistence`);
@@ -2298,16 +2327,53 @@ export class Session {
             this.handleAgentRunError(agentId, error, "Failed to cancel running agent on request");
         }
     }
-    async buildAgentSessionConfig(config, gitOptions, legacyWorktreeName, attachments) {
+    async buildAgentSessionConfig(config, gitOptions, legacyWorktreeName, firstAgentContext) {
         return buildWorktreeAgentSessionConfig({
             paseoHome: this.paseoHome,
             sessionLogger: this.sessionLogger,
             workspaceGitService: this.workspaceGitService,
-            createPaseoWorktree: (input, serviceOptions) => this.createPaseoWorktree(input, serviceOptions),
+            createPaseoWorktree: (input, serviceOptions) => this.createPaseoWorktreeWorkflow(input, {
+                ...serviceOptions,
+                setupContinuation: {
+                    kind: "agent",
+                    terminalManager: this.terminalManager,
+                    appendTimelineItem: ({ agentId, item }) => appendTimelineItemIfAgentKnown({
+                        agentManager: this.agentManager,
+                        agentId,
+                        item,
+                    }),
+                    emitLiveTimelineItem: ({ agentId, item }) => emitLiveTimelineItemIfAgentKnown({
+                        agentManager: this.agentManager,
+                        agentId,
+                        item,
+                    }),
+                    logger: this.sessionLogger,
+                },
+            }),
             checkoutExistingBranch: (cwd, branch) => this.checkoutExistingBranch(cwd, branch),
             createBranchFromBase: (params) => this.createBranchFromBase(params),
             github: this.github,
-        }, config, gitOptions, legacyWorktreeName, attachments);
+        }, config, gitOptions, legacyWorktreeName, firstAgentContext);
+    }
+    async maybeAutoNameWorkspaceBranchForFirstAgent(input) {
+        const coreDeps = createWorktreeCoreDeps(this.github);
+        const result = await attemptFirstAgentBranchAutoName({
+            cwd: input.workspace.cwd,
+            firstAgentContext: input.firstAgentContext,
+            generateBranchName: coreDeps.generateBranchName,
+        });
+        if (!result.renamed || !result.branchName) {
+            return input.workspace;
+        }
+        const updatedWorkspace = {
+            ...input.workspace,
+            displayName: result.branchName,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.workspaceRegistry.upsert(updatedWorkspace);
+        await this.notifyGitMutation(input.workspace.cwd, "rename-branch");
+        await this.emitWorkspaceUpdateForCwd(input.workspace.cwd);
+        return updatedWorkspace;
     }
     emitProviderDisabledResponse(kind, provider, requestId, fetchedAt) {
         const payload = {
@@ -3970,16 +4036,13 @@ export class Session {
             workspaceGitService: this.workspaceGitService,
             agentManager: this.agentManager,
             agentStorage: this.agentStorage,
-            archiveWorkspaceRecord: async (workspaceDirectory) => {
-                const workspace = await this.findWorkspaceByDirectory(workspaceDirectory);
-                if (workspace) {
-                    await this.archiveWorkspaceRecord(workspace.workspaceId);
-                }
-            },
+            archiveWorkspaceRecord: (workspaceId) => this.archiveWorkspaceRecord(workspaceId),
             emit: (message) => this.emit(message),
-            emitWorkspaceUpdatesForCwds: (cwds) => this.emitWorkspaceUpdatesForCwds(cwds),
+            emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds) => this.emitWorkspaceUpdatesForWorkspaceIds(workspaceIds),
+            markWorkspaceArchiving: (workspaceIds, archivingAt) => this.markWorkspaceArchiving(workspaceIds, archivingAt),
+            clearWorkspaceArchiving: (workspaceIds) => this.clearWorkspaceArchiving(workspaceIds),
             isPathWithinRoot: (rootPath, candidatePath) => this.isPathWithinRoot(rootPath, candidatePath),
-            killTerminalsUnderPath: (rootPath) => this.killTerminalsUnderPath(rootPath),
+            killTerminalsUnderPath: (rootPath) => this.terminalController.killTerminalsUnderPath(rootPath),
             sessionLogger: this.sessionLogger,
         }, msg);
     }
@@ -4024,22 +4087,49 @@ export class Session {
                 });
             }
             else {
-                const file = await readExplorerFile({
-                    root: cwd,
-                    relativePath: requestedPath,
-                });
-                this.emit({
-                    type: "file_explorer_response",
-                    payload: {
-                        cwd,
-                        path: file.path,
-                        mode,
-                        directory: null,
-                        file,
-                        error: null,
+                if (request.acceptBinary && this.onBinaryMessage) {
+                    const file = await readExplorerFileBytes({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    this.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileBegin,
                         requestId,
-                    },
-                });
+                        metadata: {
+                            mime: file.mimeType,
+                            size: file.size,
+                            encoding: file.encoding,
+                            modifiedAt: file.modifiedAt,
+                        },
+                    }));
+                    this.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileChunk,
+                        requestId,
+                        payload: file.bytes,
+                    }));
+                    this.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileEnd,
+                        requestId,
+                    }));
+                }
+                else {
+                    const file = await readExplorerFile({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    this.emit({
+                        type: "file_explorer_response",
+                        payload: {
+                            cwd,
+                            path: file.path,
+                            mode,
+                            directory: null,
+                            file,
+                            error: null,
+                            requestId,
+                        },
+                    });
+                }
             }
         }
         catch (error) {
@@ -4237,22 +4327,6 @@ export class Session {
         const payload = this.buildStoredAgentPayload(record);
         return this.isProviderVisibleToClient(payload.provider) ? payload : null;
     }
-    normalizeFetchAgentsSort(sort) {
-        const fallback = [{ key: "updated_at", direction: "desc" }];
-        if (!sort || sort.length === 0) {
-            return fallback;
-        }
-        const deduped = [];
-        const seen = new Set();
-        for (const entry of sort) {
-            if (seen.has(entry.key)) {
-                continue;
-            }
-            seen.add(entry.key);
-            deduped.push(entry);
-        }
-        return deduped.length > 0 ? deduped : fallback;
-    }
     getStatusPriority(agent) {
         const attentionReason = agent.attentionReason ?? null;
         const hasPendingPermission = (agent.pendingPermissions?.length ?? 0) > 0;
@@ -4270,109 +4344,6 @@ export class Session {
         }
         return 4;
     }
-    getFetchAgentsSortValue(entry, key) {
-        switch (key) {
-            case "status_priority":
-                return this.getStatusPriority(entry.agent);
-            case "created_at":
-                return Date.parse(entry.agent.createdAt);
-            case "updated_at":
-                return Date.parse(entry.agent.updatedAt);
-            case "title":
-                return entry.agent.title?.toLocaleLowerCase() ?? "";
-        }
-    }
-    getFetchAgentsSortValueFromAgent(agent, key) {
-        switch (key) {
-            case "status_priority":
-                return this.getStatusPriority(agent);
-            case "created_at":
-                return Date.parse(agent.createdAt);
-            case "updated_at":
-                return Date.parse(agent.updatedAt);
-            case "title":
-                return agent.title?.toLocaleLowerCase() ?? "";
-        }
-    }
-    compareSortValues(left, right) {
-        if (left === right) {
-            return 0;
-        }
-        if (left === null) {
-            return -1;
-        }
-        if (right === null) {
-            return 1;
-        }
-        if (typeof left === "number" && typeof right === "number") {
-            return left < right ? -1 : 1;
-        }
-        return String(left).localeCompare(String(right));
-    }
-    compareFetchAgentsAgents(left, right, sort) {
-        for (const spec of sort) {
-            const leftValue = this.getFetchAgentsSortValueFromAgent(left, spec.key);
-            const rightValue = this.getFetchAgentsSortValueFromAgent(right, spec.key);
-            const base = this.compareSortValues(leftValue, rightValue);
-            if (base === 0) {
-                continue;
-            }
-            return spec.direction === "asc" ? base : -base;
-        }
-        return left.id.localeCompare(right.id);
-    }
-    encodeFetchAgentsCursor(entry, sort) {
-        const values = {};
-        for (const spec of sort) {
-            values[spec.key] = this.getFetchAgentsSortValue(entry, spec.key);
-        }
-        return Buffer.from(JSON.stringify({
-            sort,
-            values,
-            id: entry.agent.id,
-        }), "utf8").toString("base64url");
-    }
-    decodeFetchAgentsCursor(cursor, sort) {
-        let parsed;
-        try {
-            parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-        }
-        catch {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
-        }
-        if (!parsed || typeof parsed !== "object") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
-        }
-        const payload = parsed;
-        if (!Array.isArray(payload.sort) || typeof payload.id !== "string") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
-        }
-        if (!payload.values || typeof payload.values !== "object") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_agents cursor");
-        }
-        const cursorSort = parseFetchAgentsCursorSort(payload.sort);
-        if (cursorSort.length !== sort.length ||
-            cursorSort.some((entry, index) => entry.key !== sort[index]?.key || entry.direction !== sort[index]?.direction)) {
-            throw new SessionRequestError("invalid_cursor", "fetch_agents cursor does not match current sort");
-        }
-        return {
-            sort: cursorSort,
-            values: payload.values,
-            id: payload.id,
-        };
-    }
-    compareAgentWithCursor(agent, cursor, sort) {
-        for (const spec of sort) {
-            const leftValue = this.getFetchAgentsSortValueFromAgent(agent, spec.key);
-            const rightValue = cursor.values[spec.key] !== undefined ? (cursor.values[spec.key] ?? null) : null;
-            const base = this.compareSortValues(leftValue, rightValue);
-            if (base === 0) {
-                continue;
-            }
-            return spec.direction === "asc" ? base : -base;
-        }
-        return agent.id.localeCompare(cursor.id);
-    }
     async buildActiveProjectPlacementsByWorkspaceCwd() {
         const [persistedWorkspaces, persistedProjects] = await Promise.all([
             this.workspaceRegistry.list(),
@@ -4431,7 +4402,7 @@ export class Session {
             ? { ...request.filter, includeArchived: true }
             : request.filter;
         const scope = request.type === "fetch_agents_request" ? request.scope : undefined;
-        const sort = this.normalizeFetchAgentsSort(request.sort);
+        const sort = this.agentsPager.normalizeSort(request.sort);
         let agents = await this.listAgentPayloads({
             labels: filter?.labels,
             includeUnavailablePersisted: request.type === "fetch_agent_history_request",
@@ -4454,11 +4425,11 @@ export class Session {
             return placementPromise;
         };
         let candidates = [...agents];
-        candidates.sort((left, right) => this.compareFetchAgentsAgents(left, right, sort));
+        candidates.sort((left, right) => this.agentsPager.compare(left, right, sort));
         const cursorToken = request.page?.cursor;
         if (cursorToken) {
-            const cursor = this.decodeFetchAgentsCursor(cursorToken, sort);
-            candidates = candidates.filter((agent) => this.compareAgentWithCursor(agent, cursor, sort) > 0);
+            const cursor = this.decodeAgentCursor(cursorToken, sort);
+            candidates = candidates.filter((agent) => this.agentsPager.compareWithCursor(agent, cursor, sort) > 0);
         }
         const limit = request.page?.limit ?? 200;
         const matchedEntries = await this.collectFetchAgentsEntries({
@@ -4470,7 +4441,7 @@ export class Session {
         const pagedEntries = matchedEntries.slice(0, limit);
         const hasMore = matchedEntries.length > limit;
         const nextCursor = hasMore && pagedEntries.length > 0
-            ? this.encodeFetchAgentsCursor(pagedEntries[pagedEntries.length - 1], sort)
+            ? this.agentsPager.encode(pagedEntries[pagedEntries.length - 1].agent, sort)
             : null;
         return {
             entries: pagedEntries,
@@ -4481,21 +4452,16 @@ export class Session {
             },
         };
     }
-    deriveWorkspaceStateBucket(agent) {
-        const pendingPermissionCount = agent.pendingPermissions?.length ?? 0;
-        if (pendingPermissionCount > 0 || agent.attentionReason === "permission") {
-            return "needs_input";
-        }
-        if (agent.status === "error" || agent.attentionReason === "error") {
-            return "failed";
-        }
-        if (agent.status === "running") {
-            return "running";
+    decodeAgentCursor(token, sort) {
+        try {
+            return this.agentsPager.decode(token, sort);
         }
-        if (agent.requiresAttention) {
-            return "attention";
+        catch (error) {
+            if (error instanceof CursorError) {
+                throw new SessionRequestError("invalid_cursor", error.message);
+            }
+            throw error;
         }
-        return "done";
     }
     async describeWorkspaceRecord(workspace, projectRecord) {
         const resolvedProjectRecord = projectRecord ?? (await this.projectRegistry.get(workspace.projectId));
@@ -4513,6 +4479,7 @@ export class Session {
             projectKind: (resolvedProjectRecord?.kind ?? "directory") === "git" ? "git" : "non_git",
             workspaceKind: workspace.kind,
             name: workspace.displayName,
+            archivingAt: null,
             status: "done",
             activityAt: null,
             diffStat,
@@ -4520,6 +4487,7 @@ export class Session {
                 ? buildWorkspaceScriptPayloads({
                     workspaceId: workspace.workspaceId,
                     workspaceDirectory: workspace.cwd,
+                    paseoConfig: readPaseoConfigForProjection(workspace.cwd, this.sessionLogger),
                     routeStore: this.scriptRouteStore,
                     runtimeStore: this.scriptRuntimeStore,
                     daemonPort: this.getDaemonTcpPort?.() ?? null,
@@ -4582,6 +4550,7 @@ export class Session {
             projectKind: "git",
             workspaceKind: result.workspace.kind,
             name: result.worktree.branchName || result.workspace.displayName,
+            archivingAt: null,
             status: "done",
             activityAt: null,
             diffStat: { additions: 0, deletions: 0 },
@@ -4604,239 +4573,37 @@ export class Session {
         }
         return this.describeWorkspaceRecord(input.workspace, input.projectRecord);
     }
+    markWorkspaceArchiving(workspaceIds, archivingAt) {
+        this.workspaceDirectory.markArchiving(workspaceIds, archivingAt);
+    }
+    clearWorkspaceArchiving(workspaceIds) {
+        this.workspaceDirectory.clearArchiving(workspaceIds);
+    }
     async buildWorkspaceDescriptorMap(options) {
-        const [agents, persistedWorkspaces, persistedProjects] = await Promise.all([
-            this.listAgentPayloads(),
-            this.workspaceRegistry.list(),
-            this.projectRegistry.list(),
-        ]);
-        const activeProjects = new Map(persistedProjects
-            .filter((project) => !project.archivedAt)
-            .map((project) => [project.projectId, project]));
-        const archivedProjectIds = new Set(persistedProjects.filter((project) => project.archivedAt).map((project) => project.projectId));
-        const activeRecords = persistedWorkspaces.filter((workspace) => !workspace.archivedAt && !archivedProjectIds.has(workspace.projectId));
-        const descriptorsByWorkspaceId = new Map();
-        const workspaceIds = options.workspaceIds ? new Set(options.workspaceIds) : null;
-        const workspaceIdsByDirectory = new Map(activeRecords.map((workspace) => [normalizePersistedWorkspaceId(workspace.cwd), workspace.workspaceId]));
-        const includedWorkspaces = activeRecords.filter((workspace) => !workspaceIds || workspaceIds.has(workspace.workspaceId));
-        const workspaceDescriptors = await Promise.all(includedWorkspaces.map((workspace) => this.buildWorkspaceDescriptor({
-            workspace,
-            projectRecord: activeProjects.get(workspace.projectId) ?? null,
-            includeGitData: options.includeGitData,
-        })));
-        for (let i = 0; i < includedWorkspaces.length; i += 1) {
-            descriptorsByWorkspaceId.set(includedWorkspaces[i].workspaceId, workspaceDescriptors[i]);
-        }
-        for (const agent of agents) {
-            if (agent.archivedAt) {
-                continue;
-            }
-            if (!this.isProviderVisibleToClient(agent.provider)) {
-                continue;
-            }
-            const workspaceId = workspaceIdsByDirectory.get(normalizePersistedWorkspaceId(agent.cwd));
-            if (workspaceId === undefined) {
-                continue;
-            }
-            const existing = descriptorsByWorkspaceId.get(workspaceId);
-            if (!existing) {
-                continue;
-            }
-            const bucket = this.deriveWorkspaceStateBucket(agent);
-            if (this.workspaceStatePriority[bucket] < this.workspaceStatePriority[existing.status]) {
-                existing.status = bucket;
-            }
-        }
-        return descriptorsByWorkspaceId;
+        return this.workspaceDirectory.buildDescriptorMap(options);
     }
     resolveRegisteredWorkspaceIdForCwd(cwd, workspaces) {
-        const normalizedCwd = normalizePersistedWorkspaceId(cwd);
-        const exact = workspaces.find((workspace) => workspace.cwd === normalizedCwd);
-        if (exact) {
-            return exact.workspaceId;
-        }
-        const userHome = homedir();
-        let bestMatch = null;
-        for (const workspace of workspaces) {
-            if (workspace.cwd === userHome)
-                continue;
-            if (workspace.archivedAt)
-                continue;
-            const prefix = workspace.cwd.endsWith(sep) ? workspace.cwd : `${workspace.cwd}${sep}`;
-            if (!normalizedCwd.startsWith(prefix)) {
-                continue;
-            }
-            if (!bestMatch || workspace.cwd.length > bestMatch.cwd.length) {
-                bestMatch = workspace;
-            }
-        }
-        return bestMatch?.workspaceId ?? normalizedCwd;
+        return this.workspaceDirectory.resolveRegisteredWorkspaceIdForCwd(cwd, workspaces);
     }
-    async listWorkspaceDescriptors() {
-        return Array.from((await this.buildWorkspaceDescriptorMap({
-            includeGitData: true,
-        })).values());
+    matchesWorkspaceFilter(input) {
+        return this.workspaceDirectory.matchesFilter(input);
     }
-    normalizeFetchWorkspacesSort(sort) {
-        const fallback = [{ key: "activity_at", direction: "desc" }];
-        if (!sort || sort.length === 0) {
-            return fallback;
+    async listFetchWorkspacesEntries(request) {
+        try {
+            return await this.workspaceDirectory.listFetchEntries(request);
         }
-        const deduped = [];
-        const seen = new Set();
-        for (const entry of sort) {
-            if (seen.has(entry.key)) {
-                continue;
-            }
-            seen.add(entry.key);
-            deduped.push(entry);
-        }
-        return deduped.length > 0 ? deduped : fallback;
-    }
-    getFetchWorkspacesSortValue(workspace, key) {
-        switch (key) {
-            case "status_priority":
-                return this.workspaceStatePriority[workspace.status];
-            case "activity_at":
-                return workspace.activityAt ? Date.parse(workspace.activityAt) : null;
-            case "name":
-                return workspace.name.toLocaleLowerCase();
-            case "project_id":
-                return workspace.projectId.toLocaleLowerCase();
-        }
-    }
-    compareFetchWorkspacesEntries(left, right, sort) {
-        for (const spec of sort) {
-            const leftValue = this.getFetchWorkspacesSortValue(left, spec.key);
-            const rightValue = this.getFetchWorkspacesSortValue(right, spec.key);
-            const base = this.compareSortValues(leftValue, rightValue);
-            if (base === 0) {
-                continue;
+        catch (error) {
+            if (error instanceof CursorError) {
+                throw new SessionRequestError("invalid_cursor", error.message);
             }
-            return spec.direction === "asc" ? base : -base;
+            throw error;
         }
-        return left.id.localeCompare(right.id);
     }
-    encodeFetchWorkspacesCursor(entry, sort) {
-        const values = {};
-        for (const spec of sort) {
-            values[spec.key] = this.getFetchWorkspacesSortValue(entry, spec.key);
-        }
-        return Buffer.from(JSON.stringify({
-            sort,
-            values,
-            id: entry.id,
-        }), "utf8").toString("base64url");
-    }
-    decodeFetchWorkspacesCursor(cursor, sort) {
-        let parsed;
-        try {
-            parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-        }
-        catch {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_workspaces cursor");
-        }
-        if (!parsed || typeof parsed !== "object") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_workspaces cursor");
-        }
-        const payload = parsed;
-        if (!Array.isArray(payload.sort) || typeof payload.id !== "string") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_workspaces cursor");
-        }
-        if (!payload.values || typeof payload.values !== "object") {
-            throw new SessionRequestError("invalid_cursor", "Invalid fetch_workspaces cursor");
-        }
-        const cursorSort = parseFetchWorkspacesCursorSort(payload.sort);
-        if (cursorSort.length !== sort.length ||
-            cursorSort.some((entry, index) => entry.key !== sort[index]?.key || entry.direction !== sort[index]?.direction)) {
-            throw new SessionRequestError("invalid_cursor", "fetch_workspaces cursor does not match current sort");
-        }
-        return {
-            sort: cursorSort,
-            values: payload.values,
-            id: String(payload.id),
-        };
-    }
-    compareWorkspaceWithCursor(workspace, cursor, sort) {
-        for (const spec of sort) {
-            const leftValue = this.getFetchWorkspacesSortValue(workspace, spec.key);
-            const rightValue = cursor.values[spec.key] !== undefined ? (cursor.values[spec.key] ?? null) : null;
-            const base = this.compareSortValues(leftValue, rightValue);
-            if (base === 0) {
-                continue;
-            }
-            return spec.direction === "asc" ? base : -base;
-        }
-        return workspace.id.localeCompare(cursor.id);
-    }
-    matchesWorkspaceFilter(input) {
-        const { workspace, filter } = input;
-        if (!filter) {
-            return true;
-        }
-        if (filter.projectId && filter.projectId.trim().length > 0) {
-            if (workspace.projectId !== filter.projectId.trim()) {
-                return false;
-            }
-        }
-        if (filter.idPrefix && filter.idPrefix.trim().length > 0) {
-            if (!String(workspace.id).startsWith(filter.idPrefix.trim())) {
-                return false;
-            }
-        }
-        if (filter.query && filter.query.trim().length > 0) {
-            const query = filter.query.trim().toLocaleLowerCase();
-            const haystacks = [workspace.name, String(workspace.projectId), String(workspace.id)];
-            if (!haystacks.some((value) => value.toLocaleLowerCase().includes(query))) {
-                return false;
-            }
-        }
-        return true;
-    }
-    async listFetchWorkspacesEntries(request) {
-        const filter = request.filter;
-        const sort = this.normalizeFetchWorkspacesSort(request.sort);
-        let entries = await this.listWorkspaceDescriptors();
-        const listedCount = entries.length;
-        entries = entries.filter((workspace) => this.matchesWorkspaceFilter({ workspace, filter }));
-        const filteredCount = entries.length;
-        entries.sort((left, right) => this.compareFetchWorkspacesEntries(left, right, sort));
-        const cursorToken = request.page?.cursor;
-        if (cursorToken) {
-            const cursor = this.decodeFetchWorkspacesCursor(cursorToken, sort);
-            entries = entries.filter((workspace) => this.compareWorkspaceWithCursor(workspace, cursor, sort) > 0);
-        }
-        const limit = request.page?.limit ?? 200;
-        const pagedEntries = entries.slice(0, limit);
-        const hasMore = entries.length > limit;
-        const nextCursor = hasMore && pagedEntries.length > 0
-            ? this.encodeFetchWorkspacesCursor(pagedEntries[pagedEntries.length - 1], sort)
-            : null;
-        this.sessionLogger.debug({
-            requestId: request.requestId,
-            filter: request.filter ?? null,
-            sort,
-            page: request.page ?? null,
-            listedCount,
-            filteredCount,
-            returnedCount: pagedEntries.length,
-            hasMore,
-            nextCursor,
-        }, "fetch_workspaces_entries_listed");
-        return {
-            entries: pagedEntries,
-            pageInfo: {
-                nextCursor,
-                prevCursor: request.page?.cursor ?? null,
-                hasMore,
-            },
-        };
-    }
-    bufferOrEmitWorkspaceUpdate(subscription, payload) {
-        if (subscription.isBootstrapping) {
-            const workspaceId = payload.kind === "upsert" ? payload.workspace.id : payload.id;
-            subscription.pendingUpdatesByWorkspaceId.set(workspaceId, payload);
-            return;
+    bufferOrEmitWorkspaceUpdate(subscription, payload) {
+        if (subscription.isBootstrapping) {
+            const workspaceId = payload.kind === "upsert" ? payload.workspace.id : payload.id;
+            subscription.pendingUpdatesByWorkspaceId.set(workspaceId, payload);
+            return;
         }
         const workspaceId = payload.kind === "upsert" ? payload.workspace.id : payload.id;
         subscription.lastEmittedByWorkspaceId.set(workspaceId, payload);
@@ -5154,14 +4921,6 @@ export class Session {
         const workspaceId = this.resolveRegisteredWorkspaceIdForCwd(cwd, workspaces);
         await this.emitWorkspaceUpdatesForWorkspaceIds([workspaceId], options);
     }
-    async emitWorkspaceUpdatesForCwds(cwds) {
-        const workspaces = await this.workspaceRegistry.list();
-        const uniqueWorkspaceIds = new Set();
-        for (const cwd of cwds) {
-            uniqueWorkspaceIds.add(this.resolveRegisteredWorkspaceIdForCwd(cwd, workspaces));
-        }
-        await this.emitWorkspaceUpdatesForWorkspaceIds(uniqueWorkspaceIds);
-    }
     async handleFetchAgents(request) {
         const requestedSubscriptionId = request.subscribe?.subscriptionId?.trim();
         const subscriptionId = resolveSubscriptionId(request.subscribe, requestedSubscriptionId);
@@ -5350,6 +5109,7 @@ export class Session {
         return buildWorkspaceScriptPayloads({
             workspaceId,
             workspaceDirectory,
+            paseoConfig: readPaseoConfigForProjection(workspaceDirectory, this.sessionLogger),
             routeStore: this.scriptRouteStore,
             runtimeStore: this.scriptRuntimeStore,
             daemonPort: this.getDaemonTcpPort?.() ?? null,
@@ -5500,15 +5260,15 @@ export class Session {
             paseoHome: this.paseoHome,
             describeWorkspaceRecord: (result) => this.describeCreatedWorktreeWorkspace(result),
             emit: (message) => this.emit(message),
-            createPaseoWorktree: (input) => this.createPaseoWorktree(input),
-            warmWorkspaceGitData: (workspace) => this.warmWorkspaceGitDataForWorkspace(workspace),
             sessionLogger: this.sessionLogger,
-            runWorktreeSetupInBackground: (options) => this.runWorktreeSetupInBackground(options),
+            createPaseoWorktreeWorkflow: (input) => this.createPaseoWorktreeWorkflow(input),
         }, request);
     }
-    async runWorktreeSetupInBackground(options) {
-        return runWorktreeSetupInBackgroundSession({
+    async createPaseoWorktreeWorkflow(input, options) {
+        return createWorktreeWorkflow({
             paseoHome: this.paseoHome,
+            createPaseoWorktree: (workflowInput, serviceOptions) => this.createPaseoWorktree(workflowInput, serviceOptions),
+            warmWorkspaceGitData: (workspace) => this.warmWorkspaceGitDataForWorkspace(workspace),
             emitWorkspaceUpdateForCwd: (cwd, emitOptions) => this.emitWorkspaceUpdateForCwd(cwd, emitOptions),
             cacheWorkspaceSetupSnapshot: (workspaceId, snapshot) => {
                 this.workspaceSetupSnapshots.set(workspaceId, snapshot);
@@ -5524,7 +5284,7 @@ export class Session {
             onScriptsChanged: (workspaceId, workspaceDirectory) => {
                 this.emitWorkspaceScriptStatusUpdate(workspaceId, workspaceDirectory);
             },
-        }, options);
+        }, input, options);
     }
     async handleWorkspaceSetupStatusRequest(request) {
         return handleWorkspaceSetupStatusRequestMessage({
@@ -5597,13 +5357,12 @@ export class Session {
         });
     }
     loadProjectedTimelineWindow(params) {
-        const { agentId, direction, cursor, requestedLimit, provider } = params;
+        const { agentId, direction, cursor, requestedLimit } = params;
         let timeline = params.timeline;
         const projectedLimit = Math.max(1, Math.floor(requestedLimit));
         let fetchLimit = projectedLimit;
         let projectedWindow = selectTimelineWindowByProjectedLimit({
             rows: timeline.rows,
-            provider,
             direction,
             limit: projectedLimit,
             collapseToolLifecycle: false,
@@ -5632,7 +5391,6 @@ export class Session {
             });
             projectedWindow = selectTimelineWindowByProjectedLimit({
                 rows: timeline.rows,
-                provider,
                 direction,
                 limit: projectedLimit,
                 collapseToolLifecycle: false,
@@ -5685,11 +5443,10 @@ export class Session {
                     direction,
                     cursor,
                     requestedLimit,
-                    provider: snapshot.provider,
                     timeline,
                 });
                 timeline = projectedResult.timeline;
-                entries = projectTimelineRows(projectedResult.selectedRows, snapshot.provider, projection);
+                entries = projectTimelineRows({ rows: projectedResult.selectedRows, mode: projection });
                 if (projectedResult.minSeq !== null && projectedResult.maxSeq !== null) {
                     startCursor = { epoch: timeline.epoch, seq: projectedResult.minSeq };
                     endCursor = { epoch: timeline.epoch, seq: projectedResult.maxSeq };
@@ -5702,7 +5459,7 @@ export class Session {
                 const lastRow = timeline.rows[timeline.rows.length - 1];
                 startCursor = firstRow ? { epoch: timeline.epoch, seq: firstRow.seq } : null;
                 endCursor = lastRow ? { epoch: timeline.epoch, seq: lastRow.seq } : null;
-                entries = projectTimelineRows(timeline.rows, snapshot.provider, projection);
+                entries = projectTimelineRows({ rows: timeline.rows, mode: projection });
             }
             this.emit({
                 type: "fetch_agent_timeline_response",
@@ -5721,7 +5478,17 @@ export class Session {
                     endCursor,
                     hasOlder,
                     hasNewer,
-                    entries,
+                    entries: entries.map((entry) => ({
+                        provider: snapshot.provider,
+                        item: entry.item,
+                        timestamp: entry.timestamp,
+                        seqStart: entry.seqStart,
+                        seqEnd: entry.seqEnd,
+                        sourceSeqRanges: entry.sourceSeqRanges,
+                        collapsed: this.supports(CLIENT_CAPS.reasoningMergeEnum)
+                            ? entry.collapsed
+                            : entry.collapsed.filter((value) => value !== "reasoning_merge"),
+                    })),
                     error: null,
                 },
             });
@@ -6474,17 +6241,7 @@ export class Session {
         }
         await this.disableVoiceModeForActiveAgent(true);
         this.isVoiceMode = false;
-        // Unsubscribe from all terminals
-        if (this.unsubscribeTerminalsChanged) {
-            this.unsubscribeTerminalsChanged();
-            this.unsubscribeTerminalsChanged = null;
-        }
-        this.subscribedTerminalDirectories.clear();
-        for (const unsubscribeExit of this.terminalExitSubscriptions.values()) {
-            unsubscribeExit();
-        }
-        this.terminalExitSubscriptions.clear();
-        this.disposeTerminalSubscriptions();
+        this.terminalController.dispose();
         for (const unsubscribe of this.checkoutDiffSubscriptions.values()) {
             unsubscribe();
         }
@@ -6494,26 +6251,6 @@ export class Session {
         }
         this.workspaceGitSubscriptions.clear();
     }
-    // ----------------------------------------------------------------------------
-    // Terminal Handlers
-    // ----------------------------------------------------------------------------
-    ensureTerminalExitSubscription(terminal) {
-        if (this.terminalExitSubscriptions.has(terminal.id)) {
-            return;
-        }
-        const unsubscribeExit = terminal.onExit(() => {
-            this.handleTerminalExited(terminal.id);
-        });
-        this.terminalExitSubscriptions.set(terminal.id, unsubscribeExit);
-    }
-    handleTerminalExited(terminalId) {
-        const unsubscribeExit = this.terminalExitSubscriptions.get(terminalId);
-        if (unsubscribeExit) {
-            unsubscribeExit();
-            this.terminalExitSubscriptions.delete(terminalId);
-        }
-        this.detachTerminalStream(terminalId, { emitExit: true });
-    }
     emitChatRpcError(request, error) {
         const message = error instanceof Error ? error.message : "Chat request failed";
         const code = error instanceof ChatServiceError ? error.code : "chat_request_failed";
@@ -6926,458 +6663,6 @@ export class Session {
             this.emitLoopRpcError(request, error);
         }
     }
-    emitTerminalsChangedSnapshot(input) {
-        this.emit({
-            type: "terminals_changed",
-            payload: {
-                cwd: input.cwd,
-                terminals: input.terminals,
-            },
-        });
-    }
-    filterStandaloneTerminals(terminals) {
-        return terminals;
-    }
-    toTerminalInfo(terminal) {
-        const title = terminal.getTitle();
-        return {
-            id: terminal.id,
-            name: terminal.name,
-            ...(title ? { title } : {}),
-        };
-    }
-    handleTerminalsChanged(event) {
-        if (!this.subscribedTerminalDirectories.has(event.cwd)) {
-            return;
-        }
-        this.emitTerminalsChangedSnapshot({
-            cwd: event.cwd,
-            terminals: this.filterStandaloneTerminals(event.terminals).map((terminal) => Object.assign({ id: terminal.id, name: terminal.name }, terminal.title ? { title: terminal.title } : {})),
-        });
-    }
-    handleSubscribeTerminalsRequest(msg) {
-        this.subscribedTerminalDirectories.add(msg.cwd);
-        void this.emitInitialTerminalsChangedSnapshot(msg.cwd);
-    }
-    handleUnsubscribeTerminalsRequest(msg) {
-        this.subscribedTerminalDirectories.delete(msg.cwd);
-    }
-    async emitInitialTerminalsChangedSnapshot(cwd) {
-        if (!this.terminalManager || !this.subscribedTerminalDirectories.has(cwd)) {
-            return;
-        }
-        try {
-            const terminals = this.filterStandaloneTerminals(await this.terminalManager.getTerminals(cwd));
-            for (const terminal of terminals) {
-                this.ensureTerminalExitSubscription(terminal);
-            }
-            if (!this.subscribedTerminalDirectories.has(cwd)) {
-                return;
-            }
-            this.emitTerminalsChangedSnapshot({
-                cwd,
-                terminals: terminals.map((terminal) => this.toTerminalInfo(terminal)),
-            });
-        }
-        catch (error) {
-            this.sessionLogger.warn({ err: error, cwd }, "Failed to emit initial terminal snapshot");
-        }
-    }
-    async handleListTerminalsRequest(msg) {
-        if (!this.terminalManager) {
-            this.emit({
-                type: "list_terminals_response",
-                payload: {
-                    ...(msg.cwd ? { cwd: msg.cwd } : {}),
-                    terminals: [],
-                    requestId: msg.requestId,
-                },
-            });
-            return;
-        }
-        try {
-            const terminals = this.filterStandaloneTerminals(typeof msg.cwd === "string"
-                ? await this.terminalManager.getTerminals(msg.cwd)
-                : await this.getAllTerminalSessions());
-            for (const terminal of terminals) {
-                this.ensureTerminalExitSubscription(terminal);
-            }
-            this.emit({
-                type: "list_terminals_response",
-                payload: {
-                    ...(msg.cwd ? { cwd: msg.cwd } : {}),
-                    terminals: terminals.map((terminal) => this.toTerminalInfo(terminal)),
-                    requestId: msg.requestId,
-                },
-            });
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, cwd: msg.cwd }, "Failed to list terminals");
-            this.emit({
-                type: "list_terminals_response",
-                payload: {
-                    ...(msg.cwd ? { cwd: msg.cwd } : {}),
-                    terminals: [],
-                    requestId: msg.requestId,
-                },
-            });
-        }
-    }
-    async getAllTerminalSessions() {
-        if (!this.terminalManager) {
-            return [];
-        }
-        const directories = this.terminalManager.listDirectories();
-        const terminalsByDirectory = await Promise.all(directories.map((cwd) => this.terminalManager.getTerminals(cwd)));
-        return terminalsByDirectory.flat();
-    }
-    async handleCreateTerminalRequest(msg) {
-        if (!this.terminalManager) {
-            this.emit({
-                type: "create_terminal_response",
-                payload: {
-                    terminal: null,
-                    error: "Terminal manager not available",
-                    requestId: msg.requestId,
-                },
-            });
-            return;
-        }
-        try {
-            if (msg.agentId) {
-                this.emit({
-                    type: "create_terminal_response",
-                    payload: {
-                        terminal: null,
-                        error: `Agent-backed terminals are no longer supported for agent ${msg.agentId}`,
-                        requestId: msg.requestId,
-                    },
-                });
-                return;
-            }
-            const session = await this.terminalManager.createTerminal({
-                cwd: msg.cwd,
-                name: msg.name,
-                command: msg.command,
-                args: msg.args,
-            });
-            this.ensureTerminalExitSubscription(session);
-            this.emit({
-                type: "create_terminal_response",
-                payload: {
-                    terminal: {
-                        id: session.id,
-                        name: session.name,
-                        cwd: session.cwd,
-                        ...(session.getTitle() ? { title: session.getTitle() } : {}),
-                    },
-                    error: null,
-                    requestId: msg.requestId,
-                },
-            });
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, cwd: msg.cwd }, "Failed to create terminal");
-            this.emit({
-                type: "create_terminal_response",
-                payload: {
-                    terminal: null,
-                    error: error.message,
-                    requestId: msg.requestId,
-                },
-            });
-        }
-    }
-    async handleSubscribeTerminalRequest(msg) {
-        if (!this.terminalManager) {
-            this.emit({
-                type: "subscribe_terminal_response",
-                payload: {
-                    terminalId: msg.terminalId,
-                    error: "Terminal manager not available",
-                    requestId: msg.requestId,
-                },
-            });
-            return;
-        }
-        const session = this.terminalManager.getTerminal(msg.terminalId);
-        if (!session) {
-            this.emit({
-                type: "subscribe_terminal_response",
-                payload: {
-                    terminalId: msg.terminalId,
-                    error: "Terminal not found",
-                    requestId: msg.requestId,
-                },
-            });
-            return;
-        }
-        this.ensureTerminalExitSubscription(session);
-        const slot = this.bindActiveTerminalStream(session);
-        if (slot === null) {
-            this.sessionLogger.warn({
-                terminalId: msg.terminalId,
-                activeTerminalStreamCount: this.activeTerminalStreams.size,
-            }, "Terminal stream slot exhaustion");
-            this.emit({
-                type: "subscribe_terminal_response",
-                payload: {
-                    terminalId: msg.terminalId,
-                    error: "No terminal stream slots available",
-                    requestId: msg.requestId,
-                },
-            });
-            return;
-        }
-        this.emit({
-            type: "subscribe_terminal_response",
-            payload: {
-                terminalId: msg.terminalId,
-                slot,
-                error: null,
-                requestId: msg.requestId,
-            },
-        });
-        const activeStream = this.activeTerminalStreams.get(slot);
-        if (activeStream) {
-            this.trySendTerminalSnapshot(activeStream);
-        }
-    }
-    handleUnsubscribeTerminalRequest(msg) {
-        this.detachTerminalStream(msg.terminalId, { emitExit: false });
-    }
-    handleTerminalInput(msg) {
-        if (!this.terminalManager) {
-            return;
-        }
-        const session = this.terminalManager.getTerminal(msg.terminalId);
-        if (!session) {
-            this.sessionLogger.warn({ terminalId: msg.terminalId }, "Terminal not found for input");
-            return;
-        }
-        this.ensureTerminalExitSubscription(session);
-        if (msg.message.type === "resize") {
-            const currentSize = session.getSize();
-            if (currentSize.rows === msg.message.rows && currentSize.cols === msg.message.cols) {
-                return;
-            }
-        }
-        session.send(msg.message);
-    }
-    killTrackedTerminal(terminalId, options) {
-        this.detachTerminalStream(terminalId, { emitExit: options?.emitExit ?? true });
-        this.terminalManager?.killTerminal(terminalId);
-    }
-    async killTerminalsUnderPath(rootPath) {
-        return killWorktreeTerminalsUnderPath({
-            isPathWithinRoot: (pathRoot, candidatePath) => this.isPathWithinRoot(pathRoot, candidatePath),
-            killTrackedTerminal: (terminalId, options) => this.killTrackedTerminal(terminalId, options),
-            detachTerminalStream: (terminalId, options) => void this.detachTerminalStream(terminalId, options),
-            sessionLogger: this.sessionLogger,
-            terminalManager: this.terminalManager,
-        }, rootPath);
-    }
-    async handleKillTerminalRequest(msg) {
-        const result = this.killTerminalForClose(msg.terminalId);
-        this.emit({
-            type: "kill_terminal_response",
-            payload: {
-                terminalId: result.terminalId,
-                success: result.success,
-                requestId: msg.requestId,
-            },
-        });
-    }
-    killTerminalForClose(terminalId) {
-        if (!this.terminalManager) {
-            return {
-                terminalId,
-                success: false,
-            };
-        }
-        this.killTrackedTerminal(terminalId, { emitExit: true });
-        return {
-            terminalId,
-            success: true,
-        };
-    }
-    async handleCaptureTerminalRequest(msg) {
-        if (!this.terminalManager) {
-            this.emit({
-                type: "capture_terminal_response",
-                payload: {
-                    terminalId: msg.terminalId,
-                    lines: [],
-                    totalLines: 0,
-                    requestId: msg.requestId,
-                },
-            });
-            return;
-        }
-        const session = this.terminalManager.getTerminal(msg.terminalId);
-        if (!session) {
-            this.emit({
-                type: "capture_terminal_response",
-                payload: {
-                    terminalId: msg.terminalId,
-                    lines: [],
-                    totalLines: 0,
-                    requestId: msg.requestId,
-                },
-            });
-            return;
-        }
-        this.ensureTerminalExitSubscription(session);
-        try {
-            const capture = captureTerminalLines(session, {
-                start: msg.start,
-                end: msg.end,
-                stripAnsi: msg.stripAnsi,
-            });
-            this.emit({
-                type: "capture_terminal_response",
-                payload: {
-                    terminalId: msg.terminalId,
-                    lines: capture.lines,
-                    totalLines: capture.totalLines,
-                    requestId: msg.requestId,
-                },
-            });
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, terminalId: msg.terminalId }, "Failed to capture terminal");
-            this.emit({
-                type: "capture_terminal_response",
-                payload: {
-                    terminalId: msg.terminalId,
-                    lines: [],
-                    totalLines: 0,
-                    requestId: msg.requestId,
-                },
-            });
-        }
-    }
-    bindActiveTerminalStream(terminal) {
-        if (!this.onBinaryMessage) {
-            return null;
-        }
-        const existingSlot = this.terminalIdToSlot.get(terminal.id);
-        if (typeof existingSlot === "number") {
-            const existingStream = this.activeTerminalStreams.get(existingSlot);
-            if (existingStream) {
-                existingStream.needsSnapshot = true;
-                return existingSlot;
-            }
-            this.terminalIdToSlot.delete(terminal.id);
-        }
-        const slot = this.allocateTerminalSlot();
-        if (slot === null) {
-            return null;
-        }
-        const activeStream = {
-            terminalId: terminal.id,
-            slot,
-            unsubscribe: () => { },
-            needsSnapshot: true,
-            outputCoalescer: new TerminalOutputCoalescer({
-                timers: { setTimeout, clearTimeout },
-                onFlush: ({ payload }) => {
-                    if (this.activeTerminalStreams.get(slot) !== activeStream) {
-                        return;
-                    }
-                    this.emitBinary(encodeTerminalStreamFrame({
-                        opcode: TerminalStreamOpcode.Output,
-                        slot,
-                        payload,
-                    }));
-                },
-            }),
-        };
-        this.activeTerminalStreams.set(slot, activeStream);
-        this.terminalIdToSlot.set(terminal.id, slot);
-        activeStream.unsubscribe = terminal.subscribe((message) => {
-            if (this.activeTerminalStreams.get(slot) !== activeStream) {
-                return;
-            }
-            if (message.type === "snapshot") {
-                activeStream.outputCoalescer.flush();
-                activeStream.needsSnapshot = true;
-                this.trySendTerminalSnapshot(activeStream);
-                return;
-            }
-            if (message.type === "titleChange") {
-                return;
-            }
-            if (activeStream.needsSnapshot || message.data.length === 0) {
-                return;
-            }
-            activeStream.outputCoalescer.handle(message.data);
-        });
-        return slot;
-    }
-    trySendTerminalSnapshot(activeStream) {
-        if (this.activeTerminalStreams.get(activeStream.slot) !== activeStream ||
-            !activeStream.needsSnapshot) {
-            return;
-        }
-        const terminal = this.terminalManager?.getTerminal(activeStream.terminalId);
-        if (!terminal) {
-            this.detachTerminalStream(activeStream.terminalId, { emitExit: true });
-            return;
-        }
-        activeStream.outputCoalescer.flush();
-        activeStream.needsSnapshot = false;
-        this.emitBinary(encodeTerminalStreamFrame({
-            opcode: TerminalStreamOpcode.Snapshot,
-            slot: activeStream.slot,
-            payload: encodeTerminalSnapshotPayload(terminal.getState()),
-        }));
-    }
-    allocateTerminalSlot() {
-        for (let attempt = 0; attempt < MAX_TERMINAL_STREAM_SLOTS; attempt += 1) {
-            const slot = (this.nextTerminalSlot + attempt) % MAX_TERMINAL_STREAM_SLOTS;
-            if (this.activeTerminalStreams.has(slot)) {
-                continue;
-            }
-            this.nextTerminalSlot = (slot + 1) % MAX_TERMINAL_STREAM_SLOTS;
-            return slot;
-        }
-        return null;
-    }
-    detachTerminalStream(terminalId, options) {
-        const slot = this.terminalIdToSlot.get(terminalId);
-        if (typeof slot !== "number") {
-            return false;
-        }
-        const activeStream = this.activeTerminalStreams.get(slot);
-        if (!activeStream) {
-            this.terminalIdToSlot.delete(terminalId);
-            return false;
-        }
-        activeStream.outputCoalescer.flush();
-        this.activeTerminalStreams.delete(slot);
-        this.terminalIdToSlot.delete(terminalId);
-        try {
-            activeStream.unsubscribe();
-        }
-        catch (error) {
-            this.sessionLogger.warn({ err: error }, "Failed to unsubscribe terminal stream");
-        }
-        if (options?.emitExit) {
-            this.emit({
-                type: "terminal_stream_exit",
-                payload: {
-                    terminalId: activeStream.terminalId,
-                },
-            });
-        }
-        return true;
-    }
-    disposeTerminalSubscriptions() {
-        for (const terminalId of Array.from(this.terminalIdToSlot.keys())) {
-            this.detachTerminalStream(terminalId, { emitExit: false });
-        }
-    }
 }
 // ---------------------------------------------------------------------------
 // Stash handlers