@getpaseo/server 0.1.70 → 0.1.72

package/dist/server/server/session.js

@@ -21,7 +21,7 @@ import { DictationStreamManager, } from "./dictation/dictation-stream-manager.js
 import { createVoiceTurnController, } from "./voice/voice-turn-controller.js";
 import { buildConfigOverrides, extractTimestamps, isStoredAgentProviderAvailable, toAgentPersistenceHandle, } from "./persistence-hooks.js";
 import { ensureAgentLoaded } from "./agent/agent-loading.js";
-import { sendPromptToAgent, unarchiveAgentState } from "./agent/mcp-shared.js";
+import { formatSystemNotificationPrompt, sendPromptToAgent, unarchiveAgentState, } from "./agent/agent-prompt.js";
 import { experimental_createMCPClient } from "ai";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { buildWorkspaceScriptPayloads, readPaseoConfigForProjection, } from "./script-status-projection.js";
@@ -29,20 +29,23 @@ import { deriveProjectSlug } from "./workspace-git-metadata.js";
 import { spawnWorkspaceScript } from "./worktree-bootstrap.js";
 import { applyMutableProviderConfigToOverrides } from "./daemon-config-store.js";
 import { getErrorMessage, getErrorMessageOr } from "../shared/error-utils.js";
+import { getAgentStatusPriority } from "../shared/agent-state-bucket.js";
 import { buildProviderRegistry } from "./agent/provider-registry.js";
 import { resolveSnapshotCwd } from "./agent/provider-snapshot-manager.js";
 import { scheduleAgentMetadataGeneration } from "./agent/agent-metadata-generator.js";
+import { resolveCreateAgentTitles } from "./agent/create-agent-title.js";
 import { buildStoredAgentPayload, resolveEffectiveThinkingOptionId, resolveStoredAgentPayloadUpdatedAt, toAgentPayload, } from "./agent/agent-projections.js";
-import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "./agent/agent-title-limits.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
 import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from "./agent/timeline-projection.js";
 import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent/agent-response-loop.js";
+import { ImportSessionsRequestError, importProviderSession, listImportableProviderSessions, normalizeImportAgentRequest, } from "./agent/import-sessions.js";
 import { checkoutLiteFromGitSnapshot, normalizeWorkspaceId as normalizePersistedWorkspaceId, deriveProjectGroupingName, classifyDirectoryForProjectMembership, deriveWorkspaceDisplayName, } from "./workspace-registry-model.js";
 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, readExplorerFileBytes, getDownloadableFileInfo, } from "./file-explorer/service.js";
 import { readPaseoConfigForEdit, writePaseoConfigForEdit, } from "../utils/paseo-config-file.js";
+import { buildMetadataPrompt } from "../utils/build-metadata-prompt.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";
@@ -50,10 +53,11 @@ import { getProjectIcon } from "../utils/project-icon.js";
 import { expandTilde } from "../utils/path.js";
 import { searchHomeDirectories, searchWorkspaceEntries } from "../utils/directory-suggestions.js";
 import { toCheckoutError } from "./checkout-git-utils.js";
+import { buildCheckoutPrStatusPayloadFromSnapshot, buildCheckoutStatusPayloadFromSnapshot, } from "./checkout/status-projection.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";
+import { ChatServiceError, parseMentionAgentIds, } from "./chat/chat-service.js";
+import { notifyChatMentions, prepareChatMentionFanout } from "./chat/chat-mentions.js";
 import { execCommand } from "../utils/spawn.js";
 import { createGitHubService, } from "../services/github-service.js";
 import { summarizeFetchWorkspacesEntries, WorkspaceDirectory, } from "./workspace-directory.js";
@@ -61,7 +65,6 @@ import { attemptFirstAgentBranchAutoName, createPaseoWorktree, } from "./paseo-w
 import { generateBranchNameFromFirstAgentContext } from "./worktree-branch-name-generator.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__";
 async function resolveKnownProjectRootForConfig(input) {
     const requestedRoot = canonicalizeConfigRoot(input.repoRoot);
@@ -182,44 +185,6 @@ function beginAgentDeleteIfSupported(agentStorage, agentId) {
         agentStorage.beginDelete(agentId);
     }
 }
-function deriveInitialAgentTitle(prompt) {
-    const firstContentLine = prompt
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .find((line) => line.length > 0);
-    if (!firstContentLine) {
-        return null;
-    }
-    const normalized = firstContentLine.replace(/\s+/g, " ").trim();
-    if (!normalized) {
-        return null;
-    }
-    const clamped = normalized.slice(0, MAX_INITIAL_AGENT_TITLE_CHARS).trim();
-    return clamped.length > 0 ? clamped : null;
-}
-export function resolveCreateAgentTitles(options) {
-    const explicitTitle = typeof options.configTitle === "string" && options.configTitle.trim().length > 0
-        ? options.configTitle.trim()
-        : null;
-    const trimmedPrompt = options.initialPrompt?.trim();
-    const provisionalTitle = explicitTitle ?? (trimmedPrompt ? deriveInitialAgentTitle(trimmedPrompt) : null);
-    return {
-        explicitTitle,
-        provisionalTitle,
-    };
-}
-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") {
@@ -253,31 +218,6 @@ 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);
@@ -367,7 +307,12 @@ export class Session {
             getSortValue: (agent, key) => {
                 switch (key) {
                     case "status_priority":
-                        return this.getStatusPriority(agent);
+                        return getAgentStatusPriority({
+                            status: agent.status,
+                            pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
+                            requiresAttention: agent.requiresAttention,
+                            attentionReason: agent.attentionReason ?? null,
+                        });
                     case "created_at":
                         return Date.parse(agent.createdAt);
                     case "updated_at":
@@ -1112,6 +1057,8 @@ export class Session {
                 return this.handleFetchAgents(msg);
             case "fetch_agent_history_request":
                 return this.handleFetchAgentHistory(msg);
+            case "fetch_recent_provider_sessions_request":
+                return this.handleFetchRecentProviderSessions(msg);
             case "fetch_agent_request":
                 return this.handleFetchAgent(msg.agentId, msg.requestId);
             case "delete_agent_request":
@@ -1262,6 +1209,7 @@ export class Session {
             },
         });
     }
+    // eslint-disable-next-line complexity
     dispatchCheckoutMessage(msg) {
         switch (msg.type) {
             case "checkout_status_request":
@@ -1297,6 +1245,8 @@ export class Session {
                 return this.handleCheckoutPushRequest(msg);
             case "checkout_pr_create_request":
                 return this.handleCheckoutPrCreateRequest(msg);
+            case "checkout_pr_merge_request":
+                return this.handleCheckoutPrMergeRequest(msg);
             case "checkout_pr_status_request":
                 return this.handleCheckoutPrStatusRequest(msg);
             case "pull_request_timeline_request":
@@ -2114,6 +2064,7 @@ export class Session {
             agentManager: this.agentManager,
             agentId: snapshot.id,
             cwd: snapshot.cwd,
+            workspaceGitService: this.workspaceGitService,
             initialPrompt: trimmedPrompt,
             explicitTitle: params.explicitTitle,
             paseoHome: this.paseoHome,
@@ -2175,26 +2126,30 @@ export class Session {
         }
     }
     async handleImportAgentRequest(msg) {
-        const { provider, sessionId, cwd, labels, requestId } = msg;
-        this.sessionLogger.info({ sessionId, provider }, `Importing agent ${sessionId} (${provider})`);
+        const normalized = normalizeImportAgentRequest(msg);
+        if ("error" in normalized) {
+            this.emit({
+                type: "status",
+                payload: {
+                    status: "agent_create_failed",
+                    requestId: msg.requestId,
+                    error: normalized.error,
+                },
+            });
+            return;
+        }
+        const { provider, providerHandleId, requestId } = normalized;
+        this.sessionLogger.info({ providerHandleId, provider }, `Importing agent ${providerHandleId} (${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,
+            const { snapshot, timelineSize } = await importProviderSession({
+                request: normalized,
+                agentManager: this.agentManager,
+                agentStorage: this.agentStorage,
+                workspaceGitService: this.workspaceGitService,
+                paseoHome: this.paseoHome,
+                logger: this.sessionLogger,
             });
-            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",
@@ -2229,28 +2184,6 @@ export class Session {
             });
         }
     }
-    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`);
@@ -2260,7 +2193,9 @@ export class Session {
             const existing = this.agentManager.getAgent(agentId);
             if (existing) {
                 await this.interruptAgentIfRunning(agentId);
-                snapshot = await this.agentManager.reloadAgentSession(agentId);
+                snapshot = await this.agentManager.reloadAgentSession(agentId, undefined, {
+                    rehydrateFromDisk: true,
+                });
             }
             else {
                 const record = await this.agentStorage.get(agentId);
@@ -2369,6 +2304,7 @@ export class Session {
                 return generateBranchNameFromFirstAgentContext({
                     agentManager: this.agentManager,
                     cwd,
+                    workspaceGitService: this.workspaceGitService,
                     firstAgentContext,
                     logger: this.sessionLogger,
                 });
@@ -2756,14 +2692,19 @@ export class Session {
         const patch = diff.diff.length > maxPatchChars
             ? `${diff.diff.slice(0, maxPatchChars)}\n\n... (diff truncated to ${maxPatchChars} chars)\n`
             : diff.diff;
-        const prompt = [
-            "Write a concise git commit message for the changes below.",
-            "Return JSON only with a single field 'message'.",
-            "",
-            fileList,
-            "",
-            patch.length > 0 ? patch : "(No diff available)",
-        ].join("\n");
+        const prompt = await buildMetadataPrompt({
+            cwd,
+            workspaceGitService: this.workspaceGitService,
+            configKey: "commitMessage",
+            before: "Write a concise git commit message for the changes below.",
+            after: [
+                "Return JSON only with a single field 'message'.",
+                "",
+                fileList,
+                "",
+                patch.length > 0 ? patch : "(No diff available)",
+            ].join("\n"),
+        });
         try {
             const result = await generateStructuredAgentResponseWithFallback({
                 manager: this.agentManager,
@@ -2813,14 +2754,19 @@ export class Session {
         const patch = diff.diff.length > maxPatchChars
             ? `${diff.diff.slice(0, maxPatchChars)}\n\n... (diff truncated to ${maxPatchChars} chars)\n`
             : diff.diff;
-        const prompt = [
-            "Write a pull request title and body for the changes below.",
-            "Return JSON only with fields 'title' and 'body'.",
-            "",
-            fileList,
-            "",
-            patch.length > 0 ? patch : "(No diff available)",
-        ].join("\n");
+        const prompt = await buildMetadataPrompt({
+            cwd,
+            workspaceGitService: this.workspaceGitService,
+            configKey: "pullRequest",
+            before: "Write a pull request title and body for the changes below.",
+            after: [
+                "Return JSON only with fields 'title' and 'body'.",
+                "",
+                fileList,
+                "",
+                patch.length > 0 ? patch : "(No diff available)",
+            ].join("\n"),
+        });
         try {
             return await generateStructuredAgentResponseWithFallback({
                 manager: this.agentManager,
@@ -3193,7 +3139,7 @@ export class Session {
             const snapshot = await this.workspaceGitService.getSnapshot(resolvedCwd);
             this.emit({
                 type: "checkout_status_response",
-                payload: this.buildCheckoutStatusPayloadFromSnapshot({
+                payload: buildCheckoutStatusPayloadFromSnapshot({
                     cwd,
                     requestId,
                     snapshot,
@@ -3503,94 +3449,18 @@ export class Session {
         this.checkoutDiffSubscriptions.get(msg.subscriptionId)?.();
         this.checkoutDiffSubscriptions.delete(msg.subscriptionId);
     }
-    buildCheckoutStatusPayloadFromSnapshot({ cwd, requestId, snapshot, }) {
-        if (!snapshot.git.isGit) {
-            return {
-                cwd,
-                isGit: false,
-                repoRoot: null,
-                currentBranch: null,
-                isDirty: null,
-                baseRef: null,
-                aheadBehind: null,
-                aheadOfOrigin: null,
-                behindOfOrigin: null,
-                hasRemote: false,
-                remoteUrl: null,
-                isPaseoOwnedWorktree: false,
-                error: null,
-                requestId,
-            };
-        }
-        if (snapshot.git.repoRoot === null || snapshot.git.isDirty === null) {
-            throw new Error("Workspace git snapshot is missing required checkout status fields");
-        }
-        if (snapshot.git.isPaseoOwnedWorktree) {
-            if (snapshot.git.mainRepoRoot === null || snapshot.git.baseRef === null) {
-                throw new Error("Workspace git snapshot is missing required worktree status fields");
-            }
-            return {
-                cwd,
-                isGit: true,
-                repoRoot: snapshot.git.repoRoot,
-                mainRepoRoot: snapshot.git.mainRepoRoot,
-                currentBranch: snapshot.git.currentBranch ?? null,
-                isDirty: snapshot.git.isDirty,
-                baseRef: snapshot.git.baseRef,
-                aheadBehind: snapshot.git.aheadBehind ?? null,
-                aheadOfOrigin: snapshot.git.aheadOfOrigin ?? null,
-                behindOfOrigin: snapshot.git.behindOfOrigin ?? null,
-                hasRemote: snapshot.git.hasRemote,
-                remoteUrl: snapshot.git.remoteUrl,
-                isPaseoOwnedWorktree: true,
-                error: null,
-                requestId,
-            };
-        }
-        return {
-            cwd,
-            isGit: true,
-            repoRoot: snapshot.git.repoRoot,
-            mainRepoRoot: snapshot.git.mainRepoRoot,
-            currentBranch: snapshot.git.currentBranch ?? null,
-            isDirty: snapshot.git.isDirty,
-            baseRef: snapshot.git.baseRef ?? null,
-            aheadBehind: snapshot.git.aheadBehind ?? null,
-            aheadOfOrigin: snapshot.git.aheadOfOrigin ?? null,
-            behindOfOrigin: snapshot.git.behindOfOrigin ?? null,
-            hasRemote: snapshot.git.hasRemote,
-            remoteUrl: snapshot.git.remoteUrl,
-            isPaseoOwnedWorktree: false,
-            error: null,
-            requestId,
-        };
-    }
-    buildCheckoutPrStatusPayloadFromSnapshot({ cwd, requestId, snapshot, }) {
-        return {
-            cwd,
-            status: normalizeCheckoutPrStatusPayload(snapshot.github.pullRequest),
-            githubFeaturesEnabled: snapshot.github.featuresEnabled,
-            error: snapshot.github.error
-                ? {
-                    code: "UNKNOWN",
-                    message: snapshot.github.error.message,
-                }
-                : null,
-            requestId,
-        };
-    }
     emitCheckoutStatusUpdate(cwd, snapshot) {
         try {
             const requestId = `subscription:${cwd}`;
             this.emit({
                 type: "checkout_status_update",
                 payload: {
-                    ...this.buildCheckoutStatusPayloadFromSnapshot({
+                    ...buildCheckoutStatusPayloadFromSnapshot({
                         cwd,
                         requestId,
                         snapshot,
                     }),
-                    prStatus: this.buildCheckoutPrStatusPayloadFromSnapshot({
+                    prStatus: buildCheckoutPrStatusPayloadFromSnapshot({
                         cwd,
                         requestId,
                         snapshot,
@@ -3918,26 +3788,55 @@ export class Session {
             });
         }
     }
-    async handleCheckoutPrStatusRequest(msg) {
+    async handleCheckoutPrMergeRequest(msg) {
         const { cwd, requestId } = msg;
         try {
             const snapshot = await this.workspaceGitService.getSnapshot(cwd);
+            const prNumber = snapshot.github.pullRequest?.number;
+            if (typeof prNumber !== "number") {
+                throw new Error("Unable to determine GitHub pull request number for merge");
+            }
+            await this.github.mergePullRequest({
+                cwd,
+                prNumber,
+                mergeMethod: msg.mergeMethod,
+            });
+            await this.notifyGitMutation(cwd, "merge-pr", { invalidateGithub: true });
             this.emit({
-                type: "checkout_pr_status_response",
+                type: "checkout_pr_merge_response",
                 payload: {
                     cwd,
-                    status: normalizeCheckoutPrStatusPayload(snapshot.github.pullRequest),
-                    githubFeaturesEnabled: snapshot.github.featuresEnabled,
-                    error: snapshot.github.error
-                        ? {
-                            code: "UNKNOWN",
-                            message: snapshot.github.error.message,
-                        }
-                        : null,
+                    success: true,
+                    error: null,
                     requestId,
                 },
             });
         }
+        catch (error) {
+            this.emit({
+                type: "checkout_pr_merge_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutPrStatusRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const snapshot = await this.workspaceGitService.getSnapshot(cwd);
+            this.emit({
+                type: "checkout_pr_status_response",
+                payload: buildCheckoutPrStatusPayloadFromSnapshot({
+                    cwd,
+                    requestId,
+                    snapshot,
+                }),
+            });
+        }
         catch (error) {
             this.emit({
                 type: "checkout_pr_status_response",
@@ -4333,23 +4232,6 @@ export class Session {
         const payload = this.buildStoredAgentPayload(record);
         return this.isProviderVisibleToClient(payload.provider) ? payload : null;
     }
-    getStatusPriority(agent) {
-        const attentionReason = agent.attentionReason ?? null;
-        const hasPendingPermission = (agent.pendingPermissions?.length ?? 0) > 0;
-        if (hasPendingPermission || attentionReason === "permission") {
-            return 0;
-        }
-        if (agent.status === "error" || attentionReason === "error") {
-            return 1;
-        }
-        if (agent.status === "running") {
-            return 2;
-        }
-        if (agent.status === "initializing") {
-            return 3;
-        }
-        return 4;
-    }
     async buildActiveProjectPlacementsByWorkspaceCwd() {
         const [persistedWorkspaces, persistedProjects] = await Promise.all([
             this.workspaceRegistry.list(),
@@ -5002,6 +4884,42 @@ export class Session {
             });
         }
     }
+    async handleFetchRecentProviderSessions(request) {
+        try {
+            const result = await listImportableProviderSessions({
+                request,
+                agentManager: this.agentManager,
+                agentStorage: this.agentStorage,
+                providerRegistry: this.getProviderRegistry(),
+            });
+            this.emit({
+                type: "fetch_recent_provider_sessions_response",
+                payload: {
+                    requestId: request.requestId,
+                    entries: result.entries,
+                    ...(result.filteredAlreadyImportedCount > 0
+                        ? { filteredAlreadyImportedCount: result.filteredAlreadyImportedCount }
+                        : {}),
+                },
+            });
+        }
+        catch (error) {
+            const code = error instanceof ImportSessionsRequestError
+                ? error.code
+                : "fetch_recent_provider_sessions_failed";
+            const message = error instanceof Error ? error.message : "Failed to fetch recent provider sessions";
+            this.sessionLogger.error({ err: error }, "Failed to handle fetch_recent_provider_sessions_request");
+            this.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: request.requestId,
+                    requestType: request.type,
+                    error: message,
+                    code,
+                },
+            });
+        }
+    }
     async handleFetchWorkspacesRequest(request) {
         const requestedSubscriptionId = request.subscribe?.subscriptionId?.trim();
         const subscriptionId = resolveSubscriptionId(request.subscribe, requestedSubscriptionId);
@@ -6351,6 +6269,19 @@ export class Session {
     async handleChatPostRequest(request) {
         try {
             const authorAgentId = request.authorAgentId?.trim() || this.clientId;
+            const mentionAgentIds = parseMentionAgentIds(request.body);
+            const storedAgents = await this.agentStorage.list();
+            const liveAgents = this.agentManager.listAgents();
+            const fanout = await prepareChatMentionFanout({
+                authorAgentId,
+                mentionAgentIds,
+                storedAgents,
+                liveAgents,
+                listRoomPosterAgentIds: () => this.chatService.listRoomPosterAgentIds({ room: request.room }),
+            });
+            if (!fanout.ok) {
+                throw new ChatServiceError("chat_mention_fanout_limit_exceeded", fanout.error);
+            }
             const message = await this.chatService.dispatchMessage({
                 room: request.room,
                 authorAgentId,
@@ -6371,11 +6302,20 @@ export class Session {
                 body: request.body,
                 mentionAgentIds: message.mentionAgentIds,
                 logger: this.sessionLogger,
-                listStoredAgents: () => this.agentStorage.list(),
-                listLiveAgents: () => this.agentManager.listAgents(),
+                storedAgents,
+                liveAgents,
+                prepared: fanout.prepared,
                 resolveAgentIdentifier: (identifier) => this.resolveAgentIdentifier(identifier),
                 sendAgentMessage: async (agentId, text) => {
-                    await this.handleSendAgentMessage(agentId, text);
+                    await sendPromptToAgent({
+                        agentManager: this.agentManager,
+                        agentStorage: this.agentStorage,
+                        agentId,
+                        prompt: formatSystemNotificationPrompt(text),
+                        unarchive: false,
+                        recordUserMessage: false,
+                        logger: this.sessionLogger,
+                    });
                 },
             });
         }
@@ -6723,26 +6663,6 @@ export class Session {
 // Stash handlers
 // ---------------------------------------------------------------------------
 Session.PASEO_STASH_PREFIX = "paseo-auto-stash:";
-export function normalizeCheckoutPrStatusPayload(status) {
-    if (!status) {
-        return null;
-    }
-    return {
-        number: status.number,
-        url: status.url,
-        title: status.title,
-        state: status.state,
-        repoOwner: status.repoOwner,
-        repoName: status.repoName,
-        baseRefName: status.baseRefName,
-        headRefName: status.headRefName,
-        isMerged: status.isMerged,
-        isDraft: status.isDraft ?? false,
-        checks: status.checks ?? [],
-        checksStatus: status.checksStatus,
-        reviewDecision: status.reviewDecision,
-    };
-}
 function isValidPullRequestTimelineIdentity(options) {
     if (!Number.isInteger(options.prNumber) || options.prNumber <= 0) {
         return false;