@getpaseo/server 0.1.35 → 0.1.37

package/dist/src/server/session.js

@@ -31,23 +31,20 @@ import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
 import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from "./file-explorer/service.js";
 import { computeWorktreePath, getWorktreeSetupCommands, resolveWorktreeRuntimeEnv, slugify, validateBranchSlug, listPaseoWorktrees, deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, } from "../utils/worktree.js";
 import { createAgentWorktree, runAsyncWorktreeBootstrap } from "./worktree-bootstrap.js";
-import { getCheckoutDiff, getCheckoutShortstat, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, resolveRepositoryDefaultBranch, } from "../utils/checkout-git.js";
+import { getCheckoutDiff, getCheckoutShortstat, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, resolveRepositoryDefaultBranch, } from "../utils/checkout-git.js";
 import { getProjectIcon } from "../utils/project-icon.js";
 import { expandTilde } from "../utils/path.js";
 import { searchHomeDirectories, searchWorkspaceEntries } from "../utils/directory-suggestions.js";
+import { READ_ONLY_GIT_ENV, resolveCheckoutGitDir, toCheckoutError, } from "./checkout-git-utils.js";
 import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from "./speech/providers/local/models.js";
 import { toResolver } from "./speech/provider-resolver.js";
 import { resolveClientMessageId } from "./client-message-id.js";
+import { ChatServiceError, } from "./chat/chat-service.js";
+import { notifyChatMentions } from "./chat/chat-mentions.js";
 const execAsync = promisify(exec);
 const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
-const READ_ONLY_GIT_ENV = {
-    ...process.env,
-    GIT_OPTIONAL_LOCKS: "0",
-};
 const pendingAgentInitializations = new Map();
 const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_IDS[0];
-const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
-const CHECKOUT_DIFF_FALLBACK_REFRESH_MS = 5000;
 const WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 500;
 const WORKSPACE_GIT_WATCH_REMOVED_FINGERPRINT = "__removed__";
 const TERMINAL_STREAM_HIGH_WATER_BYTES = 256 * 1024;
@@ -190,8 +187,9 @@ export class Session {
         this.activeTerminalStreams = new Map();
         this.terminalIdToSlot = new Map();
         this.nextTerminalSlot = 0;
+        this.inflightRequests = 0;
+        this.peakInflightRequests = 0;
         this.checkoutDiffSubscriptions = new Map();
-        this.checkoutDiffTargets = new Map();
         this.workspaceGitWatchTargets = new Map();
         this.voiceModeAgentId = null;
         this.voiceModeBaseConfig = null;
@@ -202,7 +200,7 @@ export class Session {
             attention: 3,
             done: 4,
         };
-        const { clientId, onMessage, onBinaryMessage, getBinaryBufferedAmount, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
+        const { clientId, onMessage, onBinaryMessage, getBinaryBufferedAmount, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
         this.clientId = clientId;
         this.sessionId = uuidv4();
         this.onMessage = onMessage;
@@ -216,6 +214,10 @@ export class Session {
         this.agentStorage = agentStorage;
         this.projectRegistry = projectRegistry;
         this.workspaceRegistry = workspaceRegistry;
+        this.chatService = chatService;
+        this.scheduleService = scheduleService;
+        this.loopService = loopService;
+        this.checkoutDiffManager = checkoutDiffManager;
         this.createAgentMcpTransport = createAgentMcpTransport;
         this.terminalManager = terminalManager;
         if (this.terminalManager) {
@@ -271,21 +273,11 @@ export class Session {
         return this.clientActivity;
     }
     getRuntimeMetrics() {
-        let checkoutDiffWatcherCount = 0;
-        let checkoutDiffFallbackRefreshTargetCount = 0;
-        for (const target of this.checkoutDiffTargets.values()) {
-            checkoutDiffWatcherCount += target.watchers.length;
-            if (target.fallbackRefreshInterval) {
-                checkoutDiffFallbackRefreshTargetCount += 1;
-            }
-        }
         return {
-            checkoutDiffTargetCount: this.checkoutDiffTargets.size,
-            checkoutDiffSubscriptionCount: this.checkoutDiffSubscriptions.size,
-            checkoutDiffWatcherCount,
-            checkoutDiffFallbackRefreshTargetCount,
             terminalDirectorySubscriptionCount: this.subscribedTerminalDirectories.size,
             terminalSubscriptionCount: this.activeTerminalStreams.size,
+            inflightRequests: this.inflightRequests,
+            peakInflightRequests: this.peakInflightRequests,
         };
     }
     /**
@@ -847,264 +839,333 @@ export class Session {
      * Main entry point for processing session messages
      */
     async handleMessage(msg) {
-        this.sessionLogger.trace({ inbound: msg }, "inbound message");
+        this.inflightRequests++;
+        if (this.inflightRequests > this.peakInflightRequests) {
+            this.peakInflightRequests = this.inflightRequests;
+        }
         try {
-            switch (msg.type) {
-                case "voice_audio_chunk":
-                    await this.handleAudioChunk(msg);
-                    break;
-                case "abort_request":
-                    await this.handleAbort();
-                    break;
-                case "audio_played":
-                    this.handleAudioPlayed(msg.id);
-                    break;
-                case "fetch_agents_request":
-                    await this.handleFetchAgents(msg);
-                    break;
-                case "fetch_workspaces_request":
-                    await this.handleFetchWorkspacesRequest(msg);
-                    break;
-                case "fetch_agent_request":
-                    await this.handleFetchAgent(msg.agentId, msg.requestId);
-                    break;
-                case "delete_agent_request":
-                    await this.handleDeleteAgentRequest(msg.agentId, msg.requestId);
-                    break;
-                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;
-                case "send_agent_message_request":
-                    await this.handleSendAgentMessageRequest(msg);
-                    break;
-                case "wait_for_finish_request":
-                    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;
+            this.sessionLogger.trace({ inbound: msg }, "inbound message");
+            try {
+                switch (msg.type) {
+                    case "voice_audio_chunk":
+                        await this.handleAudioChunk(msg);
+                        break;
+                    case "abort_request":
+                        await this.handleAbort();
+                        break;
+                    case "audio_played":
+                        this.handleAudioPlayed(msg.id);
+                        break;
+                    case "fetch_agents_request":
+                        await this.handleFetchAgents(msg);
+                        break;
+                    case "fetch_workspaces_request":
+                        await this.handleFetchWorkspacesRequest(msg);
+                        break;
+                    case "fetch_agent_request":
+                        await this.handleFetchAgent(msg.agentId, msg.requestId);
+                        break;
+                    case "delete_agent_request":
+                        await this.handleDeleteAgentRequest(msg.agentId, msg.requestId);
+                        break;
+                    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;
+                    case "send_agent_message_request":
+                        await this.handleSendAgentMessageRequest(msg);
+                        break;
+                    case "wait_for_finish_request":
+                        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":
+                        await this.dictationStreamManager.handleChunk({
+                            dictationId: msg.dictationId,
+                            seq: msg.seq,
+                            audioBase64: msg.audio,
+                            format: msg.format,
+                        });
+                        break;
+                    case "dictation_stream_finish":
+                        await this.dictationStreamManager.handleFinish(msg.dictationId, msg.finalSeq);
+                        break;
+                    case "dictation_stream_cancel":
+                        this.dictationStreamManager.handleCancel(msg.dictationId);
+                        break;
+                    case "create_agent_request":
+                        await this.handleCreateAgentRequest(msg);
+                        break;
+                    case "resume_agent_request":
+                        await this.handleResumeAgentRequest(msg);
+                        break;
+                    case "refresh_agent_request":
+                        await this.handleRefreshAgentRequest(msg);
+                        break;
+                    case "cancel_agent_request":
+                        await this.handleCancelAgentRequest(msg.agentId);
+                        break;
+                    case "restart_server_request":
+                        await this.handleRestartServerRequest(msg.requestId, msg.reason);
+                        break;
+                    case "shutdown_server_request":
+                        await this.handleShutdownServerRequest(msg.requestId);
+                        break;
+                    case "fetch_agent_timeline_request":
+                        await this.handleFetchAgentTimelineRequest(msg);
+                        break;
+                    case "set_agent_mode_request":
+                        await this.handleSetAgentModeRequest(msg.agentId, msg.modeId, msg.requestId);
+                        break;
+                    case "set_agent_model_request":
+                        await this.handleSetAgentModelRequest(msg.agentId, msg.modelId, msg.requestId);
+                        break;
+                    case "set_agent_thinking_request":
+                        await this.handleSetAgentThinkingRequest(msg.agentId, msg.thinkingOptionId, msg.requestId);
+                        break;
+                    case "agent_permission_response":
+                        await this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
+                        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 "directory_suggestions_request":
+                        await this.handleDirectorySuggestionsRequest(msg);
+                        break;
+                    case "subscribe_checkout_diff_request":
+                        await this.handleSubscribeCheckoutDiffRequest(msg);
+                        break;
+                    case "unsubscribe_checkout_diff_request":
+                        this.handleUnsubscribeCheckoutDiffRequest(msg);
+                        break;
+                    case "checkout_commit_request":
+                        await this.handleCheckoutCommitRequest(msg);
+                        break;
+                    case "checkout_merge_request":
+                        await this.handleCheckoutMergeRequest(msg);
+                        break;
+                    case "checkout_merge_from_base_request":
+                        await this.handleCheckoutMergeFromBaseRequest(msg);
+                        break;
+                    case "checkout_push_request":
+                        await this.handleCheckoutPushRequest(msg);
+                        break;
+                    case "checkout_pr_create_request":
+                        await this.handleCheckoutPrCreateRequest(msg);
+                        break;
+                    case "checkout_pr_status_request":
+                        await this.handleCheckoutPrStatusRequest(msg);
+                        break;
+                    case "paseo_worktree_list_request":
+                        await this.handlePaseoWorktreeListRequest(msg);
+                        break;
+                    case "paseo_worktree_archive_request":
+                        await this.handlePaseoWorktreeArchiveRequest(msg);
+                        break;
+                    case "create_paseo_worktree_request":
+                        await this.handleCreatePaseoWorktreeRequest(msg);
+                        break;
+                    case "open_project_request":
+                        await this.handleOpenProjectRequest(msg);
+                        break;
+                    case "archive_workspace_request":
+                        await this.handleArchiveWorkspaceRequest(msg);
+                        break;
+                    case "file_explorer_request":
+                        await this.handleFileExplorerRequest(msg);
+                        break;
+                    case "project_icon_request":
+                        await this.handleProjectIconRequest(msg);
+                        break;
+                    case "file_download_token_request":
+                        await this.handleFileDownloadTokenRequest(msg);
+                        break;
+                    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;
+                    case "speech_models_download_request":
+                        await this.handleSpeechModelsDownloadRequest(msg);
+                        break;
+                    case "clear_agent_attention":
+                        await this.handleClearAgentAttention(msg.agentId);
+                        break;
+                    case "client_heartbeat":
+                        this.handleClientHeartbeat(msg);
+                        break;
+                    case "ping": {
+                        const now = Date.now();
+                        this.emit({
+                            type: "pong",
+                            payload: {
+                                requestId: msg.requestId,
+                                clientSentAt: msg.clientSentAt,
+                                serverReceivedAt: now,
+                                serverSentAt: now,
+                            },
+                        });
+                        break;
                     }
-                    await this.dictationStreamManager.handleStart(msg.dictationId, msg.format);
-                    break;
-                case "dictation_stream_chunk":
-                    await this.dictationStreamManager.handleChunk({
-                        dictationId: msg.dictationId,
-                        seq: msg.seq,
-                        audioBase64: msg.audio,
-                        format: msg.format,
-                    });
-                    break;
-                case "dictation_stream_finish":
-                    await this.dictationStreamManager.handleFinish(msg.dictationId, msg.finalSeq);
-                    break;
-                case "dictation_stream_cancel":
-                    this.dictationStreamManager.handleCancel(msg.dictationId);
-                    break;
-                case "create_agent_request":
-                    await this.handleCreateAgentRequest(msg);
-                    break;
-                case "resume_agent_request":
-                    await this.handleResumeAgentRequest(msg);
-                    break;
-                case "refresh_agent_request":
-                    await this.handleRefreshAgentRequest(msg);
-                    break;
-                case "cancel_agent_request":
-                    await this.handleCancelAgentRequest(msg.agentId);
-                    break;
-                case "restart_server_request":
-                    await this.handleRestartServerRequest(msg.requestId, msg.reason);
-                    break;
-                case "shutdown_server_request":
-                    await this.handleShutdownServerRequest(msg.requestId);
-                    break;
-                case "fetch_agent_timeline_request":
-                    await this.handleFetchAgentTimelineRequest(msg);
-                    break;
-                case "set_agent_mode_request":
-                    await this.handleSetAgentModeRequest(msg.agentId, msg.modeId, msg.requestId);
-                    break;
-                case "set_agent_model_request":
-                    await this.handleSetAgentModelRequest(msg.agentId, msg.modelId, msg.requestId);
-                    break;
-                case "set_agent_thinking_request":
-                    await this.handleSetAgentThinkingRequest(msg.agentId, msg.thinkingOptionId, msg.requestId);
-                    break;
-                case "agent_permission_response":
-                    await this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
-                    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 "directory_suggestions_request":
-                    await this.handleDirectorySuggestionsRequest(msg);
-                    break;
-                case "subscribe_checkout_diff_request":
-                    await this.handleSubscribeCheckoutDiffRequest(msg);
-                    break;
-                case "unsubscribe_checkout_diff_request":
-                    this.handleUnsubscribeCheckoutDiffRequest(msg);
-                    break;
-                case "checkout_commit_request":
-                    await this.handleCheckoutCommitRequest(msg);
-                    break;
-                case "checkout_merge_request":
-                    await this.handleCheckoutMergeRequest(msg);
-                    break;
-                case "checkout_merge_from_base_request":
-                    await this.handleCheckoutMergeFromBaseRequest(msg);
-                    break;
-                case "checkout_push_request":
-                    await this.handleCheckoutPushRequest(msg);
-                    break;
-                case "checkout_pr_create_request":
-                    await this.handleCheckoutPrCreateRequest(msg);
-                    break;
-                case "checkout_pr_status_request":
-                    await this.handleCheckoutPrStatusRequest(msg);
-                    break;
-                case "paseo_worktree_list_request":
-                    await this.handlePaseoWorktreeListRequest(msg);
-                    break;
-                case "paseo_worktree_archive_request":
-                    await this.handlePaseoWorktreeArchiveRequest(msg);
-                    break;
-                case "create_paseo_worktree_request":
-                    await this.handleCreatePaseoWorktreeRequest(msg);
-                    break;
-                case "open_project_request":
-                    await this.handleOpenProjectRequest(msg);
-                    break;
-                case "archive_workspace_request":
-                    await this.handleArchiveWorkspaceRequest(msg);
-                    break;
-                case "file_explorer_request":
-                    await this.handleFileExplorerRequest(msg);
-                    break;
-                case "project_icon_request":
-                    await this.handleProjectIconRequest(msg);
-                    break;
-                case "file_download_token_request":
-                    await this.handleFileDownloadTokenRequest(msg);
-                    break;
-                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;
-                case "speech_models_download_request":
-                    await this.handleSpeechModelsDownloadRequest(msg);
-                    break;
-                case "clear_agent_attention":
-                    await this.handleClearAgentAttention(msg.agentId);
-                    break;
-                case "client_heartbeat":
-                    this.handleClientHeartbeat(msg);
-                    break;
-                case "ping": {
-                    const now = Date.now();
-                    this.emit({
-                        type: "pong",
-                        payload: {
-                            requestId: msg.requestId,
-                            clientSentAt: msg.clientSentAt,
-                            serverReceivedAt: now,
-                            serverSentAt: now,
-                        },
-                    });
-                    break;
+                    case "list_commands_request":
+                        await this.handleListCommandsRequest(msg);
+                        break;
+                    case "register_push_token":
+                        this.handleRegisterPushToken(msg.token);
+                        break;
+                    case "subscribe_terminals_request":
+                        this.handleSubscribeTerminalsRequest(msg);
+                        break;
+                    case "unsubscribe_terminals_request":
+                        this.handleUnsubscribeTerminalsRequest(msg);
+                        break;
+                    case "list_terminals_request":
+                        await this.handleListTerminalsRequest(msg);
+                        break;
+                    case "create_terminal_request":
+                        await this.handleCreateTerminalRequest(msg);
+                        break;
+                    case "subscribe_terminal_request":
+                        await this.handleSubscribeTerminalRequest(msg);
+                        break;
+                    case "unsubscribe_terminal_request":
+                        this.handleUnsubscribeTerminalRequest(msg);
+                        break;
+                    case "terminal_input":
+                        this.handleTerminalInput(msg);
+                        break;
+                    case "kill_terminal_request":
+                        await this.handleKillTerminalRequest(msg);
+                        break;
+                    case "chat/create":
+                        await this.handleChatCreateRequest(msg);
+                        break;
+                    case "chat/list":
+                        await this.handleChatListRequest(msg);
+                        break;
+                    case "chat/inspect":
+                        await this.handleChatInspectRequest(msg);
+                        break;
+                    case "chat/delete":
+                        await this.handleChatDeleteRequest(msg);
+                        break;
+                    case "chat/post":
+                        await this.handleChatPostRequest(msg);
+                        break;
+                    case "chat/read":
+                        await this.handleChatReadRequest(msg);
+                        break;
+                    case "chat/wait":
+                        await this.handleChatWaitRequest(msg);
+                        break;
+                    case "schedule/create":
+                        await this.handleScheduleCreateRequest(msg);
+                        break;
+                    case "schedule/list":
+                        await this.handleScheduleListRequest(msg);
+                        break;
+                    case "schedule/inspect":
+                        await this.handleScheduleInspectRequest(msg);
+                        break;
+                    case "schedule/logs":
+                        await this.handleScheduleLogsRequest(msg);
+                        break;
+                    case "schedule/pause":
+                        await this.handleSchedulePauseRequest(msg);
+                        break;
+                    case "schedule/resume":
+                        await this.handleScheduleResumeRequest(msg);
+                        break;
+                    case "schedule/delete":
+                        await this.handleScheduleDeleteRequest(msg);
+                        break;
+                    case "loop/run":
+                        await this.handleLoopRunRequest(msg);
+                        break;
+                    case "loop/list":
+                        await this.handleLoopListRequest(msg);
+                        break;
+                    case "loop/inspect":
+                        await this.handleLoopInspectRequest(msg);
+                        break;
+                    case "loop/logs":
+                        await this.handleLoopLogsRequest(msg);
+                        break;
+                    case "loop/stop":
+                        await this.handleLoopStopRequest(msg);
+                        break;
                 }
-                case "list_commands_request":
-                    await this.handleListCommandsRequest(msg);
-                    break;
-                case "register_push_token":
-                    this.handleRegisterPushToken(msg.token);
-                    break;
-                case "subscribe_terminals_request":
-                    this.handleSubscribeTerminalsRequest(msg);
-                    break;
-                case "unsubscribe_terminals_request":
-                    this.handleUnsubscribeTerminalsRequest(msg);
-                    break;
-                case "list_terminals_request":
-                    await this.handleListTerminalsRequest(msg);
-                    break;
-                case "create_terminal_request":
-                    await this.handleCreateTerminalRequest(msg);
-                    break;
-                case "subscribe_terminal_request":
-                    await this.handleSubscribeTerminalRequest(msg);
-                    break;
-                case "unsubscribe_terminal_request":
-                    this.handleUnsubscribeTerminalRequest(msg);
-                    break;
-                case "terminal_input":
-                    this.handleTerminalInput(msg);
-                    break;
-                case "kill_terminal_request":
-                    await this.handleKillTerminalRequest(msg);
-                    break;
             }
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.sessionLogger.error({ err }, "Error handling message");
-            const requestId = msg.requestId;
-            if (typeof requestId === "string") {
-                try {
-                    this.emit({
-                        type: "rpc_error",
-                        payload: {
-                            requestId,
-                            requestType: msg.type,
-                            error: `Request failed: ${err.message}`,
-                            code: "handler_error",
-                        },
-                    });
-                }
-                catch (emitError) {
-                    this.sessionLogger.error({ err: emitError }, "Failed to emit rpc_error");
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.sessionLogger.error({ err }, "Error handling message");
+                const requestId = msg.requestId;
+                if (typeof requestId === "string") {
+                    try {
+                        this.emit({
+                            type: "rpc_error",
+                            payload: {
+                                requestId,
+                                requestType: msg.type,
+                                error: `Request failed: ${err.message}`,
+                                code: "handler_error",
+                            },
+                        });
+                    }
+                    catch (emitError) {
+                        this.sessionLogger.error({ err: emitError }, "Failed to emit rpc_error");
+                    }
                 }
+                this.emit({
+                    type: "activity_log",
+                    payload: {
+                        id: uuidv4(),
+                        timestamp: new Date(),
+                        type: "error",
+                        content: `Error: ${err.message}`,
+                    },
+                });
             }
-            this.emit({
-                type: "activity_log",
-                payload: {
-                    id: uuidv4(),
-                    timestamp: new Date(),
-                    type: "error",
-                    content: `Error: ${err.message}`,
-                },
-            });
         }
+        finally {
+            this.inflightRequests--;
+        }
+    }
+    resetPeakInflight() {
+        this.peakInflightRequests = this.inflightRequests;
     }
     handleBinaryFrame(frame) {
         const activeStream = this.activeTerminalStreams.get(frame.slot);
@@ -2210,21 +2271,6 @@ export class Session {
         }
         return baseBranch;
     }
-    toCheckoutError(error) {
-        if (error instanceof NotGitRepoError) {
-            return { code: "NOT_GIT_REPO", message: error.message };
-        }
-        if (error instanceof MergeConflictError) {
-            return { code: "MERGE_CONFLICT", message: error.message };
-        }
-        if (error instanceof MergeFromBaseConflictError) {
-            return { code: "MERGE_CONFLICT", message: error.message };
-        }
-        if (error instanceof Error) {
-            return { code: "UNKNOWN", message: error.message };
-        }
-        return { code: "UNKNOWN", message: String(error) };
-    }
     isPathWithinRoot(rootPath, candidatePath) {
         const resolvedRoot = resolve(rootPath);
         const resolvedCandidate = resolve(candidatePath);
@@ -2721,7 +2767,7 @@ export class Session {
                     hasRemote: false,
                     remoteUrl: null,
                     isPaseoOwnedWorktree: false,
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -2865,63 +2911,6 @@ export class Session {
             });
         }
     }
-    normalizeCheckoutDiffCompare(compare) {
-        if (compare.mode === "uncommitted") {
-            return { mode: "uncommitted" };
-        }
-        const trimmedBaseRef = compare.baseRef?.trim();
-        return trimmedBaseRef ? { mode: "base", baseRef: trimmedBaseRef } : { mode: "base" };
-    }
-    buildCheckoutDiffTargetKey(cwd, compare) {
-        return JSON.stringify([
-            cwd,
-            compare.mode,
-            compare.mode === "base" ? (compare.baseRef ?? "") : "",
-        ]);
-    }
-    closeCheckoutDiffWatchTarget(target) {
-        if (target.debounceTimer) {
-            clearTimeout(target.debounceTimer);
-            target.debounceTimer = null;
-        }
-        if (target.fallbackRefreshInterval) {
-            clearInterval(target.fallbackRefreshInterval);
-            target.fallbackRefreshInterval = null;
-        }
-        for (const watcher of target.watchers) {
-            watcher.close();
-        }
-        target.watchers = [];
-    }
-    removeCheckoutDiffSubscription(subscriptionId) {
-        const subscription = this.checkoutDiffSubscriptions.get(subscriptionId);
-        if (!subscription) {
-            return;
-        }
-        this.checkoutDiffSubscriptions.delete(subscriptionId);
-        const target = this.checkoutDiffTargets.get(subscription.targetKey);
-        if (!target) {
-            return;
-        }
-        target.subscriptions.delete(subscriptionId);
-        if (target.subscriptions.size === 0) {
-            this.closeCheckoutDiffWatchTarget(target);
-            this.checkoutDiffTargets.delete(subscription.targetKey);
-        }
-    }
-    async resolveCheckoutGitDir(cwd) {
-        try {
-            const { stdout } = await execAsync("git rev-parse --absolute-git-dir", {
-                cwd,
-                env: READ_ONLY_GIT_ENV,
-            });
-            const gitDir = stdout.trim();
-            return gitDir.length > 0 ? gitDir : null;
-        }
-        catch {
-            return null;
-        }
-    }
     async resolveWorkspaceGitRefsRoot(gitDir) {
         try {
             const commonDir = (await readFile(join(gitDir, "commondir"), "utf8")).trim();
@@ -3020,7 +3009,7 @@ export class Session {
         if (this.workspaceGitWatchTargets.has(workspaceId)) {
             return;
         }
-        const gitDir = await this.resolveCheckoutGitDir(cwd);
+        const gitDir = await resolveCheckoutGitDir(cwd);
         if (!gitDir) {
             return;
         }
@@ -3054,228 +3043,41 @@ export class Session {
         if (target.watchers.length === 0) {
             return;
         }
-        this.workspaceGitWatchTargets.set(workspaceId, target);
-    }
-    async syncWorkspaceGitWatchTarget(cwd, options) {
-        if (!options.isGit) {
-            this.removeWorkspaceGitWatchTarget(cwd);
-            return;
-        }
-        await this.ensureWorkspaceGitWatchTarget(cwd);
-    }
-    async resolveCheckoutWatchRoot(cwd) {
-        try {
-            const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", {
-                cwd,
-                env: READ_ONLY_GIT_ENV,
-            });
-            const root = stdout.trim();
-            return root.length > 0 ? root : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    scheduleCheckoutDiffTargetRefresh(target) {
-        if (target.debounceTimer) {
-            clearTimeout(target.debounceTimer);
-        }
-        target.debounceTimer = setTimeout(() => {
-            target.debounceTimer = null;
-            void this.refreshCheckoutDiffTarget(target);
-        }, CHECKOUT_DIFF_WATCH_DEBOUNCE_MS);
-    }
-    emitCheckoutDiffUpdate(target, snapshot) {
-        if (target.subscriptions.size === 0) {
-            return;
-        }
-        for (const subscriptionId of target.subscriptions) {
-            this.emit({
-                type: "checkout_diff_update",
-                payload: {
-                    subscriptionId,
-                    ...snapshot,
-                },
-            });
-        }
-    }
-    checkoutDiffSnapshotFingerprint(snapshot) {
-        return JSON.stringify(snapshot);
-    }
-    async computeCheckoutDiffSnapshot(cwd, compare, options) {
-        const diffCwd = options?.diffCwd ?? cwd;
-        try {
-            const diffResult = await getCheckoutDiff(diffCwd, {
-                mode: compare.mode,
-                baseRef: compare.baseRef,
-                includeStructured: true,
-            }, { paseoHome: this.paseoHome });
-            const files = [...(diffResult.structured ?? [])];
-            files.sort((a, b) => {
-                if (a.path === b.path)
-                    return 0;
-                return a.path < b.path ? -1 : 1;
-            });
-            return {
-                cwd,
-                files,
-                error: null,
-            };
-        }
-        catch (error) {
-            return {
-                cwd,
-                files: [],
-                error: this.toCheckoutError(error),
-            };
-        }
-    }
-    async refreshCheckoutDiffTarget(target) {
-        if (target.refreshPromise) {
-            target.refreshQueued = true;
-            return;
-        }
-        target.refreshPromise = (async () => {
-            do {
-                target.refreshQueued = false;
-                const snapshot = await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
-                    diffCwd: target.diffCwd,
-                });
-                target.latestPayload = snapshot;
-                const fingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
-                if (fingerprint !== target.latestFingerprint) {
-                    target.latestFingerprint = fingerprint;
-                    this.emitCheckoutDiffUpdate(target, snapshot);
-                }
-            } while (target.refreshQueued);
-        })();
-        try {
-            await target.refreshPromise;
-        }
-        finally {
-            target.refreshPromise = null;
-        }
-    }
-    async ensureCheckoutDiffWatchTarget(cwd, compare) {
-        const targetKey = this.buildCheckoutDiffTargetKey(cwd, compare);
-        const existing = this.checkoutDiffTargets.get(targetKey);
-        if (existing) {
-            return existing;
-        }
-        const watchRoot = await this.resolveCheckoutWatchRoot(cwd);
-        const target = {
-            key: targetKey,
-            cwd,
-            diffCwd: watchRoot ?? cwd,
-            compare,
-            subscriptions: new Set(),
-            watchers: [],
-            fallbackRefreshInterval: null,
-            debounceTimer: null,
-            refreshPromise: null,
-            refreshQueued: false,
-            latestPayload: null,
-            latestFingerprint: null,
-        };
-        const repoWatchPath = watchRoot ?? cwd;
-        const watchPaths = new Set([repoWatchPath]);
-        const gitDir = await this.resolveCheckoutGitDir(cwd);
-        if (gitDir) {
-            watchPaths.add(gitDir);
-        }
-        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 {
-                if (shouldTryRecursive) {
-                    watcher = createWatcher(true);
-                    watcherIsRecursive = true;
-                }
-                else {
-                    watcher = createWatcher(false);
-                }
-            }
-            catch (error) {
-                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");
-                    }
-                }
-                else {
-                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Failed to start checkout diff watcher");
-                }
-            }
-            if (!watcher) {
-                continue;
-            }
-            watcher.on("error", (error) => {
-                this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff watcher error");
-            });
-            target.watchers.push(watcher);
-            if (watchPath === repoWatchPath && watcherIsRecursive) {
-                hasRecursiveRepoCoverage = true;
-            }
-        }
-        const missingRepoCoverage = !hasRecursiveRepoCoverage;
-        if (target.watchers.length === 0 || missingRepoCoverage) {
-            target.fallbackRefreshInterval = setInterval(() => {
-                this.scheduleCheckoutDiffTargetRefresh(target);
-            }, CHECKOUT_DIFF_FALLBACK_REFRESH_MS);
-            this.sessionLogger.warn({
-                cwd,
-                compare,
-                intervalMs: CHECKOUT_DIFF_FALLBACK_REFRESH_MS,
-                reason: target.watchers.length === 0 ? "no_watchers" : "missing_recursive_repo_root_coverage",
-            }, "Checkout diff watchers unavailable; using timed refresh fallback");
+        this.workspaceGitWatchTargets.set(workspaceId, target);
+    }
+    async syncWorkspaceGitWatchTarget(cwd, options) {
+        if (!options.isGit) {
+            this.removeWorkspaceGitWatchTarget(cwd);
+            return;
         }
-        this.checkoutDiffTargets.set(targetKey, target);
-        return target;
+        await this.ensureWorkspaceGitWatchTarget(cwd);
     }
     async handleSubscribeCheckoutDiffRequest(msg) {
         const cwd = expandTilde(msg.cwd);
-        const compare = this.normalizeCheckoutDiffCompare(msg.compare);
-        this.removeCheckoutDiffSubscription(msg.subscriptionId);
-        const target = await this.ensureCheckoutDiffWatchTarget(cwd, compare);
-        target.subscriptions.add(msg.subscriptionId);
-        this.checkoutDiffSubscriptions.set(msg.subscriptionId, {
-            targetKey: target.key,
+        this.checkoutDiffSubscriptions.get(msg.subscriptionId)?.();
+        this.checkoutDiffSubscriptions.delete(msg.subscriptionId);
+        const subscription = await this.checkoutDiffManager.subscribe({ cwd, compare: msg.compare }, (snapshot) => {
+            this.emit({
+                type: "checkout_diff_update",
+                payload: {
+                    subscriptionId: msg.subscriptionId,
+                    ...snapshot,
+                },
+            });
         });
-        const snapshot = target.latestPayload ??
-            (await this.computeCheckoutDiffSnapshot(cwd, compare, {
-                diffCwd: target.diffCwd,
-            }));
-        target.latestPayload = snapshot;
-        target.latestFingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
+        this.checkoutDiffSubscriptions.set(msg.subscriptionId, subscription.unsubscribe);
         this.emit({
             type: "subscribe_checkout_diff_response",
             payload: {
                 subscriptionId: msg.subscriptionId,
-                ...snapshot,
+                ...subscription.initial,
                 requestId: msg.requestId,
             },
         });
     }
     handleUnsubscribeCheckoutDiffRequest(msg) {
-        this.removeCheckoutDiffSubscription(msg.subscriptionId);
-    }
-    scheduleCheckoutDiffRefreshForCwd(cwd) {
-        const resolvedCwd = expandTilde(cwd);
-        for (const target of this.checkoutDiffTargets.values()) {
-            if (target.cwd !== resolvedCwd && target.diffCwd !== resolvedCwd) {
-                continue;
-            }
-            this.scheduleCheckoutDiffTargetRefresh(target);
-        }
+        this.checkoutDiffSubscriptions.get(msg.subscriptionId)?.();
+        this.checkoutDiffSubscriptions.delete(msg.subscriptionId);
     }
     async handleCheckoutCommitRequest(msg) {
         const { cwd, requestId } = msg;
@@ -3291,7 +3093,7 @@ export class Session {
                 message,
                 addAll: msg.addAll ?? true,
             });
-            this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
             this.emit({
                 type: "checkout_commit_response",
                 payload: {
@@ -3308,7 +3110,7 @@ export class Session {
                 payload: {
                     cwd,
                     success: false,
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -3354,7 +3156,7 @@ export class Session {
                 baseRef,
                 mode: msg.strategy === "squash" ? "squash" : "merge",
             }, { paseoHome: this.paseoHome });
-            this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
             this.emit({
                 type: "checkout_merge_response",
                 payload: {
@@ -3371,7 +3173,7 @@ export class Session {
                 payload: {
                     cwd,
                     success: false,
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -3393,7 +3195,7 @@ export class Session {
                 baseRef: msg.baseRef,
                 requireCleanTarget: msg.requireCleanTarget ?? true,
             });
-            this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
             this.emit({
                 type: "checkout_merge_from_base_response",
                 payload: {
@@ -3410,7 +3212,7 @@ export class Session {
                 payload: {
                     cwd,
                     success: false,
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -3436,7 +3238,7 @@ export class Session {
                 payload: {
                     cwd,
                     success: false,
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -3477,7 +3279,7 @@ export class Session {
                     cwd,
                     url: null,
                     number: null,
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -3505,7 +3307,7 @@ export class Session {
                     cwd,
                     status: null,
                     githubFeaturesEnabled: true,
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -3546,7 +3348,7 @@ export class Session {
                 type: "paseo_worktree_list_response",
                 payload: {
                     worktrees: [],
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -3677,7 +3479,7 @@ export class Session {
                 payload: {
                     success: false,
                     removedAgents: [],
-                    error: this.toCheckoutError(error),
+                    error: toCheckoutError(error),
                     requestId,
                 },
             });
@@ -5735,10 +5537,9 @@ export class Session {
         }
         this.terminalExitSubscriptions.clear();
         this.disposeTerminalSubscriptions();
-        for (const target of this.checkoutDiffTargets.values()) {
-            this.closeCheckoutDiffWatchTarget(target);
+        for (const unsubscribe of this.checkoutDiffSubscriptions.values()) {
+            unsubscribe();
         }
-        this.checkoutDiffTargets.clear();
         this.checkoutDiffSubscriptions.clear();
         for (const target of this.workspaceGitWatchTargets.values()) {
             this.closeWorkspaceGitWatchTarget(target);
@@ -5765,6 +5566,416 @@ export class Session {
         }
         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";
+        this.sessionLogger.error({ err: error, requestType: request.type }, "Chat request failed");
+        this.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code,
+            },
+        });
+    }
+    async handleChatCreateRequest(request) {
+        try {
+            const room = await this.chatService.createRoom({
+                name: request.name,
+                purpose: request.purpose,
+            });
+            this.emit({
+                type: "chat/create/response",
+                payload: {
+                    requestId: request.requestId,
+                    room,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatListRequest(request) {
+        try {
+            const rooms = await this.chatService.listRooms();
+            this.emit({
+                type: "chat/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    rooms,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatInspectRequest(request) {
+        try {
+            const result = await this.chatService.inspectRoom({
+                room: request.room,
+            });
+            this.emit({
+                type: "chat/inspect/response",
+                payload: {
+                    requestId: request.requestId,
+                    room: result.room,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatDeleteRequest(request) {
+        try {
+            const result = await this.chatService.deleteRoom({
+                room: request.room,
+            });
+            this.emit({
+                type: "chat/delete/response",
+                payload: {
+                    requestId: request.requestId,
+                    room: result.room,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatPostRequest(request) {
+        try {
+            const authorAgentId = request.authorAgentId?.trim() || this.clientId;
+            const message = await this.chatService.postMessage({
+                room: request.room,
+                authorAgentId,
+                body: request.body,
+                replyToMessageId: request.replyToMessageId,
+            });
+            this.emit({
+                type: "chat/post/response",
+                payload: {
+                    requestId: request.requestId,
+                    message,
+                    error: null,
+                },
+            });
+            void notifyChatMentions({
+                room: request.room,
+                authorAgentId,
+                body: request.body,
+                mentionAgentIds: message.mentionAgentIds,
+                logger: this.sessionLogger,
+                listStoredAgents: () => this.agentStorage.list(),
+                listLiveAgents: () => this.agentManager.listAgents(),
+                resolveAgentIdentifier: (identifier) => this.resolveAgentIdentifier(identifier),
+                sendAgentMessage: (agentId, text) => this.handleSendAgentMessage(agentId, text),
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatReadRequest(request) {
+        try {
+            const messages = await this.chatService.readMessages({
+                room: request.room,
+                limit: request.limit,
+                since: request.since,
+                authorAgentId: request.authorAgentId,
+            });
+            this.emit({
+                type: "chat/read/response",
+                payload: {
+                    requestId: request.requestId,
+                    messages,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatWaitRequest(request) {
+        try {
+            const messages = await this.chatService.waitForMessages({
+                room: request.room,
+                afterMessageId: request.afterMessageId,
+                timeoutMs: request.timeoutMs,
+            });
+            this.emit({
+                type: "chat/wait/response",
+                payload: {
+                    requestId: request.requestId,
+                    messages,
+                    timedOut: messages.length === 0,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    toScheduleSummary(schedule) {
+        const { runs: _runs, ...summary } = schedule;
+        return summary;
+    }
+    emitScheduleRpcError(request, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.sessionLogger.error({ err: error, requestType: request.type }, "Schedule request failed");
+        this.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code: "schedule_request_failed",
+            },
+        });
+    }
+    async handleScheduleCreateRequest(request) {
+        try {
+            const target = request.target.type === "self"
+                ? { type: "agent", agentId: request.target.agentId }
+                : request.target;
+            const schedule = await this.scheduleService.create({
+                prompt: request.prompt,
+                name: request.name,
+                cadence: request.cadence,
+                target,
+                maxRuns: request.maxRuns,
+                expiresAt: request.expiresAt,
+            });
+            this.emit({
+                type: "schedule/create/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule: this.toScheduleSummary(schedule),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleListRequest(request) {
+        try {
+            const schedules = await this.scheduleService.list();
+            this.emit({
+                type: "schedule/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedules: schedules.map((schedule) => this.toScheduleSummary(schedule)),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleInspectRequest(request) {
+        try {
+            const schedule = await this.scheduleService.inspect(request.scheduleId);
+            this.emit({
+                type: "schedule/inspect/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleLogsRequest(request) {
+        try {
+            const runs = await this.scheduleService.logs(request.scheduleId);
+            this.emit({
+                type: "schedule/logs/response",
+                payload: {
+                    requestId: request.requestId,
+                    runs,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleSchedulePauseRequest(request) {
+        try {
+            const schedule = await this.scheduleService.pause(request.scheduleId);
+            this.emit({
+                type: "schedule/pause/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule: this.toScheduleSummary(schedule),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleResumeRequest(request) {
+        try {
+            const schedule = await this.scheduleService.resume(request.scheduleId);
+            this.emit({
+                type: "schedule/resume/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule: this.toScheduleSummary(schedule),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleDeleteRequest(request) {
+        try {
+            await this.scheduleService.delete(request.scheduleId);
+            this.emit({
+                type: "schedule/delete/response",
+                payload: {
+                    requestId: request.requestId,
+                    scheduleId: request.scheduleId,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    emitLoopRpcError(request, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.sessionLogger.error({ err: error, requestType: request.type }, "Loop request failed");
+        this.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code: "loop_request_failed",
+            },
+        });
+    }
+    async handleLoopRunRequest(request) {
+        try {
+            const loop = await this.loopService.runLoop({
+                prompt: request.prompt,
+                cwd: request.cwd,
+                provider: request.provider,
+                model: request.model,
+                workerProvider: request.workerProvider,
+                workerModel: request.workerModel,
+                verifierProvider: request.verifierProvider,
+                verifierModel: request.verifierModel,
+                verifyPrompt: request.verifyPrompt,
+                verifyChecks: request.verifyChecks,
+                archive: request.archive,
+                name: request.name,
+                sleepMs: request.sleepMs,
+                maxIterations: request.maxIterations,
+                maxTimeMs: request.maxTimeMs,
+            });
+            this.emit({
+                type: "loop/run/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopListRequest(request) {
+        try {
+            const loops = await this.loopService.listLoops();
+            this.emit({
+                type: "loop/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    loops,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopInspectRequest(request) {
+        try {
+            const loop = await this.loopService.inspectLoop(request.id);
+            this.emit({
+                type: "loop/inspect/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopLogsRequest(request) {
+        try {
+            const result = await this.loopService.getLoopLogs(request.id, request.afterSeq ?? 0);
+            this.emit({
+                type: "loop/logs/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop: result.loop,
+                    entries: result.entries,
+                    nextCursor: result.nextCursor,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopStopRequest(request) {
+        try {
+            const loop = await this.loopService.stopLoop(request.id);
+            this.emit({
+                type: "loop/stop/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
     emitTerminalsChangedSnapshot(input) {
         this.emit({
             type: "terminals_changed",