@getpaseo/server 0.1.74 → 0.1.76

package/dist/server/server/session.js

@@ -38,9 +38,10 @@ import { buildStoredAgentPayload, resolveEffectiveThinkingOptionId, resolveStore
 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 { getAgentStreamEventTurnId, } from "./agent/agent-sdk-types.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 { createPersistedProjectRecord, createPersistedWorkspaceRecord, resolveProjectDisplayName, } 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";
@@ -59,7 +60,7 @@ import { resolveClientMessageId } from "./client-message-id.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 { assertPullRequestAutoMergeDisableReady, assertPullRequestAutoMergeEnableReady, createGitHubService, } from "../services/github-service.js";
 import { summarizeFetchWorkspacesEntries, WorkspaceDirectory, } from "./workspace-directory.js";
 import { attemptFirstAgentBranchAutoName, createPaseoWorktree, } from "./paseo-worktree-service.js";
 import { generateBranchNameFromFirstAgentContext } from "./worktree-branch-name-generator.js";
@@ -322,7 +323,7 @@ export class Session {
                 }
             },
         });
-        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, tts, terminalManager, providerSnapshotManager, scriptRouteStore, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, voice, voiceBridge, dictation, agentProviderRuntimeSettings, providerOverrides, isDev, } = options;
+        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, scriptRouteStore, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, voice, voiceBridge, dictation, agentProviderRuntimeSettings, providerOverrides, isDev, } = options;
         this.clientId = clientId;
         this.appVersion = appVersion ?? null;
         this.clientCapabilities = parseClientCapabilities(clientCapabilities);
@@ -367,6 +368,7 @@ export class Session {
         this.getDaemonTcpPort = getDaemonTcpPort ?? null;
         this.getDaemonTcpHost = getDaemonTcpHost ?? null;
         this.resolveScriptHealth = resolveScriptHealth ?? null;
+        this.sttLanguage = sttLanguage ?? "en";
         this.subscribeToOptionalManagers();
         this.bindVoiceBridges({ voice, voiceBridge, dictation });
         this.agentProviderRuntimeSettings = agentProviderRuntimeSettings;
@@ -381,11 +383,11 @@ export class Session {
             isProviderVisibleToClient: (provider) => this.isProviderVisibleToClient(provider),
             buildWorkspaceDescriptor: (input) => this.buildWorkspaceDescriptor(input),
         });
-        this.initializePerSessionManagers({ tts, stt, dictation });
+        this.initializePerSessionManagers({ tts, stt, sttLanguage, dictation });
         // Initialize agent MCP client asynchronously
         void this.initializeAgentMcp();
         this.subscribeToAgentEvents();
-        this.sessionLogger.trace("Session created");
+        this.sessionLogger.trace({}, "agent.session.lifecycle.created");
     }
     updateAppVersion(appVersion) {
         if (appVersion && appVersion !== this.appVersion) {
@@ -477,12 +479,17 @@ export class Session {
     async interruptAgentIfRunning(agentId) {
         const snapshot = this.agentManager.getAgent(agentId);
         if (!snapshot) {
-            this.sessionLogger.trace({ agentId }, "interruptAgentIfRunning: agent not found");
+            this.sessionLogger.trace({ agentId }, "agent.session.interrupt.not_found");
             throw new Error(`Agent ${agentId} not found`);
         }
         const hasInFlightRun = this.agentManager.hasInFlightRun(agentId);
         if (!hasInFlightRun) {
-            this.sessionLogger.trace({ agentId, lifecycle: snapshot.lifecycle, hasInFlightRun }, "interruptAgentIfRunning: skipping because agent is not running");
+            this.sessionLogger.trace({
+                agentId,
+                provider: snapshot.provider,
+                lifecycle: snapshot.lifecycle,
+                hasInFlightRun,
+            }, "agent.session.interrupt.skip_not_running");
             return;
         }
         this.sessionLogger.debug({ agentId, lifecycle: snapshot.lifecycle, hasInFlightRun }, "interruptAgentIfRunning: interrupting");
@@ -507,14 +514,14 @@ export class Session {
             agentId,
             promptType: typeof prompt === "string" ? "string" : "structured",
             hasRunOptions: Boolean(runOptions),
-        }, "startAgentStream: requested");
+        }, "agent.session.start_stream.request");
         let iterator;
         try {
             const shouldReplace = this.agentManager.hasInFlightRun(agentId);
             iterator = shouldReplace
                 ? this.agentManager.replaceAgentRun(agentId, prompt, runOptions)
                 : this.agentManager.streamAgent(agentId, prompt, runOptions);
-            this.sessionLogger.trace({ agentId, shouldReplace }, "startAgentStream: agent iterator returned");
+            this.sessionLogger.trace({ agentId, shouldReplace }, "agent.session.start_stream.iterator_returned");
         }
         catch (error) {
             this.handleAgentRunError(agentId, error, "Failed to start agent run");
@@ -525,10 +532,10 @@ export class Session {
                 for await (const _ of iterator) {
                     // Events are forwarded via the session's AgentManager subscription.
                 }
-                this.sessionLogger.trace({ agentId }, "startAgentStream: iterator drained");
+                this.sessionLogger.trace({ agentId }, "agent.session.iterator.drained");
             }
             catch (error) {
-                this.sessionLogger.trace({ agentId, err: error }, "startAgentStream: iterator threw");
+                this.sessionLogger.trace({ agentId, err: error }, "agent.session.iterator.error");
                 this.handleAgentRunError(agentId, error, "Agent stream failed");
             }
         })();
@@ -562,7 +569,7 @@ export class Session {
             });
             this.agentTools = (await this.agentMcpClient.tools());
             const agentToolCount = Object.keys(this.agentTools ?? {}).length;
-            this.sessionLogger.trace({ agentToolCount }, `Agent MCP initialized with ${agentToolCount} tools`);
+            this.sessionLogger.trace({ agentToolCount }, "agent.session.mcp_init");
         }
         catch (error) {
             this.sessionLogger.error({ err: error }, "Failed to initialize Agent MCP");
@@ -602,14 +609,17 @@ export class Session {
         this.getSpeechReadiness = dictation?.getSpeechReadiness;
     }
     initializePerSessionManagers(params) {
-        const { tts, stt, dictation } = params;
+        const { tts, stt, sttLanguage, dictation } = params;
         this.ttsManager = new TTSManager(this.sessionId, this.sessionLogger, tts);
-        this.sttManager = new STTManager(this.sessionId, this.sessionLogger, stt);
+        this.sttManager = new STTManager(this.sessionId, this.sessionLogger, stt, {
+            language: sttLanguage,
+        });
         this.dictationStreamManager = new DictationStreamManager({
             logger: this.sessionLogger,
             sessionId: this.sessionId,
             emit: (msg) => this.handleDictationManagerMessage(msg),
             stt: dictation?.stt ?? null,
+            language: dictation?.sttLanguage,
             finalTimeoutMs: dictation?.finalTimeoutMs,
         });
     }
@@ -619,6 +629,13 @@ export class Session {
         }
         this.unsubscribeAgentEvents = this.agentManager.subscribe((event) => {
             if (event.type === "agent_state") {
+                this.sessionLogger.trace({
+                    agentId: event.agent.id,
+                    provider: event.agent.provider,
+                    providerSessionId: event.agent.persistence?.sessionId ?? undefined,
+                    turnId: event.agent.activeForegroundTurnId ?? undefined,
+                    lifecycle: event.agent.lifecycle,
+                }, "agent.session.forward_update");
                 void this.forwardAgentUpdate(event.agent);
                 return;
             }
@@ -642,35 +659,24 @@ export class Session {
             // Reduce bandwidth/CPU on mobile: only forward high-frequency agent stream events
             // for the focused agent, with a short grace window while backgrounded.
             // History catch-up is handled via pull-based `fetch_agent_timeline_request`.
-            const activity = this.clientActivity;
-            if (activity?.deviceType === "mobile") {
-                if (!activity.focusedAgentId) {
-                    return;
-                }
-                if (activity.focusedAgentId !== event.agentId) {
-                    return;
-                }
-                if (!activity.appVisible) {
-                    const hiddenForMs = Date.now() - activity.appVisibilityChangedAt.getTime();
-                    if (hiddenForMs >= this.MOBILE_BACKGROUND_STREAM_GRACE_MS) {
-                        return;
-                    }
-                }
+            if (this.shouldSkipAgentStreamForward(event.agentId)) {
+                return;
             }
             const serializedEvent = serializeAgentStreamEvent(event.event);
             if (!serializedEvent) {
                 return;
             }
-            const payload = {
+            this.sessionLogger.trace({
                 agentId: event.agentId,
-                event: serializedEvent,
-                timestamp: new Date().toISOString(),
-                ...(typeof event.seq === "number" ? { seq: event.seq } : {}),
-                ...(typeof event.epoch === "string" ? { epoch: event.epoch } : {}),
-            };
+                provider: event.event.provider,
+                turnId: getAgentStreamEventTurnId(event.event),
+                seq: event.seq,
+                epoch: event.epoch,
+                event: event.event,
+            }, "agent.session.forward_stream");
             this.emit({
                 type: "agent_stream",
-                payload,
+                payload: this.buildAgentStreamPayload(event, serializedEvent),
             });
             if (event.event.type === "permission_requested") {
                 this.emit({
@@ -694,6 +700,29 @@ export class Session {
             // Title updates may be applied asynchronously after agent creation.
         }, { replayState: false });
     }
+    shouldSkipAgentStreamForward(agentId) {
+        const activity = this.clientActivity;
+        if (activity?.deviceType !== "mobile") {
+            return false;
+        }
+        if (!activity.focusedAgentId || activity.focusedAgentId !== agentId) {
+            return true;
+        }
+        if (activity.appVisible) {
+            return false;
+        }
+        const hiddenForMs = Date.now() - activity.appVisibilityChangedAt.getTime();
+        return hiddenForMs >= this.MOBILE_BACKGROUND_STREAM_GRACE_MS;
+    }
+    buildAgentStreamPayload(event, serializedEvent) {
+        return {
+            agentId: event.agentId,
+            event: serializedEvent,
+            timestamp: event.timestamp ?? new Date().toISOString(),
+            ...(typeof event.seq === "number" ? { seq: event.seq } : {}),
+            ...(typeof event.epoch === "string" ? { epoch: event.epoch } : {}),
+        };
+    }
     async buildAgentPayload(agent) {
         const storedRecord = await this.agentStorage.get(agent.id);
         const title = storedRecord?.title ?? storedRecord?.config?.title ?? null;
@@ -858,7 +887,7 @@ export class Session {
         const checkout = buildWorkspaceCheckout(workspace, project);
         return {
             projectKey: project.projectId,
-            projectName: project.displayName,
+            projectName: resolveProjectDisplayName(project),
             checkout,
         };
     }
@@ -933,7 +962,10 @@ export class Session {
             this.peakInflightRequests = this.inflightRequests;
         }
         try {
-            this.sessionLogger.trace({ messageType: msg.type, payloadBytes: JSON.stringify(msg).length }, "inbound message");
+            this.sessionLogger.trace({
+                messageType: msg.type,
+                payloadBytes: JSON.stringify(msg).length,
+            }, "agent.session.inbound");
             try {
                 await this.dispatchInboundMessage(msg);
             }
@@ -1069,6 +1101,8 @@ export class Session {
                 return this.handleCloseItemsRequest(msg);
             case "update_agent_request":
                 return this.handleUpdateAgentRequest(msg.agentId, msg.name, msg.labels, msg.requestId);
+            case "project.rename.request":
+                return this.handleProjectRenameRequest(msg.projectId, msg.customName, msg.requestId);
             case "send_agent_message_request":
                 return this.handleSendAgentMessageRequest(msg);
             case "wait_for_finish_request":
@@ -1247,6 +1281,8 @@ export class Session {
                 return this.handleCheckoutPrCreateRequest(msg);
             case "checkout_pr_merge_request":
                 return this.handleCheckoutPrMergeRequest(msg);
+            case "checkout.github.set_auto_merge.request":
+                return this.handleCheckoutGithubSetAutoMergeRequest(msg);
             case "checkout_pr_status_request":
                 return this.handleCheckoutPrStatusRequest(msg);
             case "pull_request_timeline_request":
@@ -1641,6 +1677,75 @@ export class Session {
             });
         }
     }
+    async handleProjectRenameRequest(projectId, customName, requestId) {
+        this.sessionLogger.info({ projectId, requestId, hasCustomName: typeof customName === "string" }, "session: project.rename.request");
+        try {
+            const existing = await this.projectRegistry.get(projectId);
+            if (!existing) {
+                this.emit({
+                    type: "project.rename.response",
+                    payload: {
+                        requestId,
+                        projectId,
+                        accepted: false,
+                        customName: null,
+                        error: "Project not found",
+                    },
+                });
+                return;
+            }
+            const trimmed = customName?.trim() ?? "";
+            const nextCustomName = trimmed.length === 0 ? null : trimmed;
+            await this.projectRegistry.upsert({
+                ...existing,
+                customName: nextCustomName,
+                updatedAt: new Date().toISOString(),
+            });
+            this.emit({
+                type: "project.rename.response",
+                payload: {
+                    requestId,
+                    projectId,
+                    accepted: true,
+                    customName: nextCustomName,
+                    error: null,
+                },
+            });
+            // Re-emit descriptors for every workspace under this project so the new
+            // resolved name lands in the UI immediately.
+            const workspaces = await this.workspaceRegistry.list();
+            const affectedWorkspaceIds = workspaces
+                .filter((workspace) => workspace.projectId === projectId)
+                .map((workspace) => workspace.workspaceId);
+            if (affectedWorkspaceIds.length > 0) {
+                await this.emitWorkspaceUpdatesForWorkspaceIds(affectedWorkspaceIds, {
+                    skipReconcile: true,
+                });
+            }
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, projectId, requestId }, "session: project.rename.request error");
+            this.emit({
+                type: "activity_log",
+                payload: {
+                    id: uuidv4(),
+                    timestamp: new Date(),
+                    type: "error",
+                    content: `Failed to rename project: ${getErrorMessage(error)}`,
+                },
+            });
+            this.emit({
+                type: "project.rename.response",
+                payload: {
+                    requestId,
+                    projectId,
+                    accepted: false,
+                    customName: null,
+                    error: getErrorMessageOr(error, "Failed to rename project"),
+                },
+            });
+        }
+    }
     toVoiceFeatureUnavailableContext(state) {
         return {
             reasonCode: state.reasonCode,
@@ -1857,6 +1962,7 @@ export class Session {
             logger: this.sessionLogger.child({ component: "voice-turn-controller" }),
             turnDetection,
             stt,
+            sttLanguage: this.sttLanguage,
             callbacks: {
                 onSpeechStarted: async () => {
                     this.sessionLogger.debug("Voice VAD speech_started");
@@ -2079,6 +2185,17 @@ export class Session {
         const { handle, overrides, requestId } = msg;
         if (!handle) {
             this.sessionLogger.warn("Resume request missing persistence handle");
+            if (requestId) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId,
+                        requestType: msg.type,
+                        error: "Unable to resume agent: missing persistence handle",
+                        code: "agent_resume_failed",
+                    },
+                });
+            }
             this.emit({
                 type: "activity_log",
                 payload: {
@@ -2113,14 +2230,26 @@ export class Session {
             }
         }
         catch (error) {
+            const message = getErrorMessage(error);
             this.sessionLogger.error({ err: error }, "Failed to resume agent");
+            if (requestId) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId,
+                        requestType: msg.type,
+                        error: message,
+                        code: "agent_resume_failed",
+                    },
+                });
+            }
             this.emit({
                 type: "activity_log",
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
                     type: "error",
-                    content: `Failed to resume agent: ${getErrorMessage(error)}`,
+                    content: `Failed to resume agent: ${message}`,
                 },
             });
         }
@@ -2228,14 +2357,26 @@ export class Session {
             }
         }
         catch (error) {
+            const message = getErrorMessage(error);
             this.sessionLogger.error({ err: error, agentId }, `Failed to refresh agent ${agentId}`);
+            if (requestId) {
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId,
+                        requestType: msg.type,
+                        error: message,
+                        code: "agent_refresh_failed",
+                    },
+                });
+            }
             this.emit({
                 type: "activity_log",
                 payload: {
                     id: uuidv4(),
                     timestamp: new Date(),
                     type: "error",
-                    content: `Failed to refresh agent: ${getErrorMessage(error)}`,
+                    content: `Failed to refresh agent: ${message}`,
                 },
             });
         }
@@ -3791,15 +3932,17 @@ export class Session {
     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");
-            }
+            const pullRequest = await this.resolveCurrentPullRequest(cwd, "merge", {
+                force: true,
+                includeGitHub: true,
+                reason: "merge-pr-validation",
+            });
+            this.assertCurrentPullRequestHasGithubMergeFacts(pullRequest);
             await this.github.mergePullRequest({
                 cwd,
-                prNumber,
+                prNumber: pullRequest.number,
                 mergeMethod: msg.mergeMethod,
+                status: pullRequest,
             });
             await this.notifyGitMutation(cwd, "merge-pr", { invalidateGithub: true });
             this.emit({
@@ -3824,6 +3967,81 @@ export class Session {
             });
         }
     }
+    assertCurrentPullRequestHasGithubMergeFacts(pullRequest) {
+        if (!pullRequest.github) {
+            throw new Error("GitHub merge facts are unavailable for this pull request");
+        }
+    }
+    async handleCheckoutGithubSetAutoMergeRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const pullRequest = await this.resolveCurrentPullRequest(cwd, "auto-merge", {
+                force: true,
+                includeGitHub: true,
+                reason: "auto-merge-validation",
+            });
+            if (msg.enabled) {
+                const mergeMethod = msg.mergeMethod;
+                if (!mergeMethod) {
+                    throw new Error("mergeMethod is required when enabling auto-merge");
+                }
+                assertPullRequestAutoMergeEnableReady({
+                    mergeMethod,
+                    status: pullRequest,
+                });
+                await this.github.enablePullRequestAutoMerge({
+                    cwd,
+                    prNumber: pullRequest.number,
+                    mergeMethod,
+                    status: pullRequest,
+                });
+            }
+            else {
+                if (msg.mergeMethod) {
+                    throw new Error("mergeMethod is not allowed when disabling auto-merge");
+                }
+                assertPullRequestAutoMergeDisableReady({ status: pullRequest });
+                await this.github.disablePullRequestAutoMerge({
+                    cwd,
+                    prNumber: pullRequest.number,
+                    status: pullRequest,
+                });
+            }
+            await this.notifyGitMutation(cwd, msg.enabled ? "enable-pr-auto-merge" : "disable-pr-auto-merge", {
+                invalidateGithub: true,
+            });
+            this.emit({
+                type: "checkout.github.set_auto_merge.response",
+                payload: {
+                    cwd,
+                    enabled: msg.enabled,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: "checkout.github.set_auto_merge.response",
+                payload: {
+                    cwd,
+                    enabled: msg.enabled,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async resolveCurrentPullRequest(cwd, operation, options) {
+        const snapshot = await this.workspaceGitService.getSnapshot(cwd, options);
+        const pullRequest = snapshot.github.pullRequest;
+        if (!pullRequest || typeof pullRequest.number !== "number") {
+            throw new Error(`Unable to determine GitHub pull request number for ${operation}`);
+        }
+        return { ...pullRequest, number: pullRequest.number };
+    }
     async handleCheckoutPrStatusRequest(msg) {
         const { cwd, requestId } = msg;
         try {
@@ -4361,7 +4579,10 @@ export class Session {
         return {
             id: workspace.workspaceId,
             projectId: workspace.projectId,
-            projectDisplayName: resolvedProjectRecord?.displayName ?? workspace.projectId,
+            projectDisplayName: resolvedProjectRecord
+                ? resolveProjectDisplayName(resolvedProjectRecord)
+                : workspace.projectId,
+            projectCustomName: resolvedProjectRecord?.customName ?? null,
             projectRootPath: resolvedProjectRecord?.rootPath ?? workspace.cwd,
             workspaceDirectory: workspace.cwd,
             projectKind: (resolvedProjectRecord?.kind ?? "directory") === "git" ? "git" : "non_git",
@@ -4432,7 +4653,10 @@ export class Session {
         return {
             id: result.workspace.workspaceId,
             projectId: result.workspace.projectId,
-            projectDisplayName: projectRecord?.displayName ?? result.workspace.projectId,
+            projectDisplayName: projectRecord
+                ? resolveProjectDisplayName(projectRecord)
+                : result.workspace.projectId,
+            projectCustomName: projectRecord?.customName ?? null,
             projectRootPath: projectRecord?.rootPath ?? result.repoRoot,
             workspaceDirectory: result.workspace.cwd,
             projectKind: "git",
@@ -5459,7 +5683,11 @@ export class Session {
         try {
             const agentId = resolved.agentId;
             const prompt = this.buildAgentPrompt(msg.text, msg.images, msg.attachments);
-            this.sessionLogger.trace({ agentId, messageId: msg.messageId, textPrefix: msg.text.slice(0, 80) }, "send_agent_message_request: dispatching shared sendPromptToAgent");
+            this.sessionLogger.trace({
+                agentId,
+                messageId: msg.messageId,
+                textPrefix: msg.text.slice(0, 80),
+            }, "agent.session.send_agent_message");
             let dispatchResult;
             try {
                 dispatchResult = await sendPromptToAgent({
@@ -6082,7 +6310,10 @@ export class Session {
      * Emit a message to the client
      */
     emit(msg) {
-        this.sessionLogger.trace({ messageType: msg.type, payloadBytes: JSON.stringify(msg).length }, "outbound message");
+        this.sessionLogger.trace({
+            messageType: msg.type,
+            payloadBytes: JSON.stringify(msg).length,
+        }, "agent.session.outbound");
         if (msg.type === "audio_output" &&
             (process.env.TTS_DEBUG_AUDIO_DIR || isPaseoDictationDebugEnabled()) &&
             msg.payload.groupId &&
@@ -6137,7 +6368,7 @@ export class Session {
      * Clean up session resources
      */
     async cleanup() {
-        this.sessionLogger.trace("Cleaning up");
+        this.sessionLogger.trace({}, "agent.session.lifecycle.cleanup");
         if (this.unsubscribeAgentEvents) {
             this.unsubscribeAgentEvents();
             this.unsubscribeAgentEvents = null;