@rudderhq/server 0.4.6-canary.9 → 0.5.0

package/dist/routes/chats.js

@@ -1,4 +1,4 @@
-import { addChatMessageSchema, cancelChatQueuedMessageSchema, chatAutomationCreateFromStructuredPayload, createChatConversationSchema, createChatQueuedMessageSchema, forkChatConversationSchema, steerChatQueuedMessageSchema, updateChatConversationSchema, updateChatQueuedMessageSchema } from "@rudderhq/shared";
+import { addChatMessageSchema, cancelChatQueuedMessageSchema, chatAutomationCreateFromStructuredPayload, createChatConversationSchema, createChatQueuedMessageSchema, createSideChatSchema, forkChatConversationSchema, parseCodexInlineVisualDirectives, steerChatQueuedMessageSchema, updateChatConversationSchema, updateChatQueuedMessageSchema, } from "@rudderhq/shared";
 import { Router } from "express";
 import multer from "multer";
 import { randomUUID } from "node:crypto";
@@ -9,16 +9,23 @@ import { validate } from "../middleware/validate.js";
 import { assertTimeZone } from "../services/automations.scheduler.js";
 import { chatAgentRunService } from "../services/chat-agent-runs.js";
 import { CHAT_ASSISTANT_USER_ERROR_MESSAGE, chatAssistantService, ChatAssistantStreamError, userVisiblePartialBodyFromError, } from "../services/chat-assistant.js";
-import { cancelAndReleaseActiveChatGeneration, claimChatGeneration, getActiveChatGeneration, hasActiveChatGeneration } from "../services/chat-generation-locks.js";
+import { cancelAndReleaseActiveChatGeneration, claimChatGeneration, createChatRuntimeControlCoordinator, getActiveChatGeneration, hasActiveChatGeneration, interruptActiveChatGeneration, steerActiveChatGeneration } from "../services/chat-generation-locks.js";
+import { hashChatGenerationBody } from "../services/chat-generation-protocol.js";
 import { buildChatTitlePromptFromMessages, chatTitleGenerationService, } from "../services/chat-title-generation.js";
 import { chatWorkManifestService } from "../services/chat-work-manifest.js";
 import { validateCron } from "../services/cron.js";
-import { accessService, agentService, automationService, chatService, goalService, heartbeatService, issueService, logActivity, operatorProfileService, organizationService, productIntelligenceService, projectService, } from "../services/index.js";
+import { accessService, agentService, automationService, chatService, goalService, heartbeatService, issueService, logActivity, operatorProfileService, organizationService, productIntelligenceService, projectService, sideChatService, } from "../services/index.js";
 import { runtimeResultText, sanitizeGeneratedTitle, } from "../services/title-generation.js";
 import { assertBoard, assertCompanyAccess, getActorInfo } from "./authz.js";
+import { createChatBackgroundRuntime, } from "./chat-background-runtime.js";
 import { wakeIssueAssigneeAfterChatConversion } from "./chat-issue-assignment-wakeup.js";
 import { registerChatStreamRoutes } from "./chats.stream-routes.js";
-export function chatRoutes(db, storage) {
+function chatVisibleOutputAdmissionClosed(error) {
+    return error instanceof HttpError
+        && error.status === 409
+        && error.message === "Chat-visible output admission is closed for this generation";
+}
+export function chatRoutes(db, storage, backgroundRuntime = createChatBackgroundRuntime()) {
     const router = Router();
     const svc = chatService(db);
     const organizationsSvc = organizationService(db);
@@ -35,6 +42,7 @@ export function chatRoutes(db, storage) {
     const heartbeat = heartbeatService(db);
     const productIntelligence = productIntelligenceService(db);
     const chatTitles = chatTitleGenerationService({ chats: svc, productIntelligence });
+    const sideChats = sideChatService(db);
     const CHAT_ASSISTANT_RECOVERABLE_FAILURE_FALLBACK_MESSAGE = "The assistant reply could not be completed. Rudder saved this attempt for diagnostics; retry when ready.";
     const upload = multer({
         storage: multer.memoryStorage(),
@@ -91,6 +99,7 @@ export function chatRoutes(db, storage) {
         if (!conversation)
             return null;
         assertCompanyAccess(req, conversation.orgId);
+        await sideChats.assertAccessible(conversation, req.actor.type === "board" ? (req.actor.userId ?? "local-board") : null);
         return conversation;
     }
     function boardUserId(req) {
@@ -112,6 +121,12 @@ export function chatRoutes(db, storage) {
             throw conflict("Fork this Feishu chat to continue in Rudder");
         }
     }
+    async function assertSideChatMutationAllowed(req, conversation) {
+        await sideChats.assertMutable(conversation, req.actor.type === "board" ? boardUserId(req) : null);
+    }
+    async function touchSideChat(req, conversation) {
+        await sideChats.touch(conversation, req.actor.type === "board" ? boardUserId(req) : null);
+    }
     function isTitleOnlyChatUpdate(body) {
         const keys = Object.keys(body);
         return keys.length === 1 && keys[0] === "title";
@@ -219,6 +234,71 @@ export function chatRoutes(db, storage) {
             }
         }
     }
+    function queueRequestActor(req) {
+        if (req.actor.type === "agent") {
+            return {
+                type: "agent",
+                source: req.actor.source === "agent_jwt" ? "agent_jwt" : "agent_key",
+                orgId: req.actor.orgId,
+                agentId: req.actor.agentId,
+                runId: req.actor.runId,
+                adapterType: req.actor.adapterType,
+            };
+        }
+        if (req.actor.type !== "board")
+            throw unauthorized();
+        return {
+            type: "board",
+            source: req.actor.source === "local_implicit"
+                ? "local_implicit"
+                : req.actor.source === "board_key"
+                    ? "board_key"
+                    : "session",
+            userId: req.actor.userId,
+            orgIds: req.actor.orgIds,
+            isInstanceAdmin: req.actor.isInstanceAdmin,
+            runId: req.actor.runId,
+        };
+    }
+    function requestForQueuedActor(requestActor, orgId) {
+        if (!requestActor) {
+            throw new Error("Queued chat continuation is missing its authenticated request actor");
+        }
+        if (requestActor.type === "agent") {
+            if (!requestActor.agentId || requestActor.orgId !== orgId) {
+                throw new Error("Queued chat continuation has an invalid agent actor scope");
+            }
+            return {
+                actor: {
+                    type: "agent",
+                    source: requestActor.source === "agent_jwt" ? "agent_jwt" : "agent_key",
+                    orgId,
+                    agentId: requestActor.agentId,
+                    runId: requestActor.runId,
+                    adapterType: requestActor.adapterType,
+                },
+            };
+        }
+        const source = requestActor.source === "local_implicit"
+            ? "local_implicit"
+            : requestActor.source === "board_key"
+                ? "board_key"
+                : "session";
+        const orgIds = requestActor.orgIds ?? [];
+        if (source !== "local_implicit" && !requestActor.isInstanceAdmin && !orgIds.includes(orgId)) {
+            throw new Error("Queued chat continuation has an invalid board actor scope");
+        }
+        return {
+            actor: {
+                type: "board",
+                source,
+                userId: requestActor.userId,
+                orgIds,
+                isInstanceAdmin: requestActor.isInstanceAdmin,
+                runId: requestActor.runId,
+            },
+        };
+    }
     function turnContextFromUserMessage(userMessage) {
         if (!userMessage.chatTurnId) {
             throw new Error("User message missing chat turn id");
@@ -398,12 +478,19 @@ export function chatRoutes(db, storage) {
         const createdMessages = [];
         const { chatTurnId, turnVariant } = turnContext;
         const attachGeneratedFiles = async (message, generatedAttachments) => {
-            if (!generatedAttachments || generatedAttachments.length === 0)
+            const finalDirectives = parseCodexInlineVisualDirectives(assistantReply.body).directives;
+            const inlineVisuals = (assistantReply.inlineVisuals ?? []).filter((visual) => finalDirectives.some((directive) => directive.index === visual.directiveIndex && directive.file === visual.file));
+            const generatedFiles = (generatedAttachments ?? []).filter((generated) => generated.source !== "codex_inline_visual"
+                || inlineVisuals.some((visual) => visual.status === "captured"
+                    && visual.directiveIndex === generated.directiveIndex
+                    && visual.file === generated.directiveFile));
+            if (generatedFiles.length === 0 && inlineVisuals.length === 0)
                 return message;
             const attachments = [];
-            for (const generated of generatedAttachments) {
+            const attachmentByVisualIndex = new Map();
+            for (const generated of generatedFiles) {
                 if (generated.body.length > MAX_ATTACHMENT_BYTES) {
-                    throw new ChatAssistantStreamError(`Generated attachment exceeds ${MAX_ATTACHMENT_BYTES} bytes`, assistantReply.body, generatedAttachments, { partialBodyUserVisible: true });
+                    throw new ChatAssistantStreamError(`Generated attachment exceeds ${MAX_ATTACHMENT_BYTES} bytes`, assistantReply.body, generatedFiles, { partialBodyUserVisible: true });
                 }
                 const stored = await storage.putFile({
                     orgId: conversation.orgId,
@@ -425,10 +512,45 @@ export function chatRoutes(db, storage) {
                     createdByAgentId: replyingAgentId,
                     createdByUserId: null,
                 });
-                attachments.push(attachment);
+                const typedAttachment = attachment;
+                const publicAttachment = generated.source === "codex_inline_visual"
+                    ? (({ provider: _provider, objectKey: _objectKey, ...safe }) => safe)(typedAttachment)
+                    : typedAttachment;
+                attachments.push(publicAttachment);
+                if (generated.source === "codex_inline_visual") {
+                    attachmentByVisualIndex.set(generated.directiveIndex, publicAttachment);
+                }
+            }
+            let structuredPayload = message.structuredPayload ?? null;
+            if (inlineVisuals.length > 0) {
+                const persistedMappings = inlineVisuals.map((visual) => {
+                    if (visual.status === "captured") {
+                        const attachment = attachmentByVisualIndex.get(visual.directiveIndex);
+                        if (attachment) {
+                            return {
+                                directiveIndex: visual.directiveIndex,
+                                file: visual.file,
+                                status: "ready",
+                                attachmentId: attachment.id,
+                            };
+                        }
+                    }
+                    return {
+                        directiveIndex: visual.directiveIndex,
+                        file: visual.file,
+                        status: "unavailable",
+                        reason: visual.status === "unavailable" ? visual.reason : "capture_failed",
+                    };
+                });
+                structuredPayload = {
+                    ...(structuredPayload ?? {}),
+                    inlineVisuals: persistedMappings,
+                };
+                await svc.updateMessage(conversation.id, message.id, { structuredPayload });
             }
             return {
                 ...message,
+                structuredPayload,
                 attachments: [...(message.attachments ?? []), ...attachments],
             };
         };
@@ -825,6 +947,425 @@ export function chatRoutes(db, storage) {
             await chatRunsSvc.linkAssistantMessage(runId, conversation.id, message.id);
         }
     }
+    const queueWorkerId = `chat-queue:${process.pid}:${randomUUID()}`;
+    const queueLeaseMs = 30_000;
+    const queueWorkerConcurrency = 4;
+    const queueWorkerEnabled = process.env.NODE_ENV !== "test"
+        || process.env.RUDDER_CHAT_QUEUE_WORKER_TEST === "true";
+    const runningServerQueueTasks = new Set();
+    const terminalProjectorId = `chat-terminal:${process.pid}:${randomUUID()}`;
+    let terminalProjectionRetryTimer = null;
+    let terminalProjectionRetryAt = Number.POSITIVE_INFINITY;
+    function scheduleTerminalProjectorAt(wakeAt) {
+        if (!queueWorkerEnabled || !backgroundRuntime.acceptingWork)
+            return;
+        const wakeAtMs = Math.max(Date.now(), wakeAt.getTime());
+        if (terminalProjectionRetryTimer && terminalProjectionRetryAt <= wakeAtMs)
+            return;
+        if (terminalProjectionRetryTimer)
+            backgroundRuntime.clearTimer(terminalProjectionRetryTimer);
+        terminalProjectionRetryAt = wakeAtMs;
+        terminalProjectionRetryTimer = backgroundRuntime.setTimeout(() => {
+            terminalProjectionRetryTimer = null;
+            terminalProjectionRetryAt = Number.POSITIVE_INFINITY;
+            wakeTerminalProjector();
+        }, Math.max(0, wakeAtMs - Date.now()));
+    }
+    async function drainTerminalProjections() {
+        while (backgroundRuntime.acceptingWork) {
+            const claim = await svc.generationProtocol.claimTerminalProjection({
+                workerId: terminalProjectorId,
+                leaseMs: 30_000,
+            });
+            if (!claim) {
+                const nextWakeAt = await svc.generationProtocol.getNextTerminalProjectionWakeAt();
+                if (nextWakeAt)
+                    scheduleTerminalProjectorAt(nextWakeAt);
+                return;
+            }
+            // A claim requested before close may resolve after admission shuts. The
+            // terminal protocol has no release operation, so this tracked drain must
+            // finish that claim while close waits instead of leaking its lease.
+            try {
+                const finalStatus = typeof claim.payload.finalStatus === "string"
+                    ? claim.payload.finalStatus
+                    : null;
+                const controlActionKind = typeof claim.payload.controlActionKind === "string"
+                    ? claim.payload.controlActionKind
+                    : null;
+                const controlDisposition = finalStatus === "stopped"
+                    && controlActionKind !== "steer"
+                    ? "stopped"
+                    : finalStatus === "interrupted_unverified"
+                        && controlActionKind !== "steer"
+                        ? "interrupted_unverified"
+                        : finalStatus === "control_lost"
+                            ? "control_lost"
+                            : undefined;
+                const completed = await svc.generationProtocol.completeTerminalProjection({
+                    outboxId: claim.id,
+                    claimToken: claim.claimToken,
+                    claimEpoch: claim.claimEpoch,
+                    controlDisposition,
+                });
+                if (completed)
+                    wakeServerQueue();
+            }
+            catch (error) {
+                const retryAt = new Date(Date.now() + 1_000);
+                const retry = await svc.generationProtocol.retryTerminalProjection({
+                    outboxId: claim.id,
+                    claimToken: claim.claimToken,
+                    claimEpoch: claim.claimEpoch,
+                    error: error instanceof Error ? error.message : String(error),
+                    retryAt,
+                    maxAttempts: 5,
+                }).catch(() => null);
+                if (retry?.status === "retry_wait") {
+                    scheduleTerminalProjectorAt(retry.availableAt ?? retryAt);
+                }
+            }
+        }
+    }
+    const terminalProjector = backgroundRuntime.createCoalescingTask(drainTerminalProjections, (error) => logger.warn({ err: error }, "chat terminal projection drain failed"));
+    function wakeTerminalProjector() {
+        if (!queueWorkerEnabled || !backgroundRuntime.acceptingWork)
+            return;
+        if (terminalProjectionRetryTimer) {
+            backgroundRuntime.clearTimer(terminalProjectionRetryTimer);
+            terminalProjectionRetryTimer = null;
+            terminalProjectionRetryAt = Number.POSITIVE_INFINITY;
+        }
+        terminalProjector.wake();
+    }
+    async function runServerQueuedMessage(claim) {
+        const conversation = await svc.getById(claim.item.conversationId);
+        if (!conversation) {
+            await svc.releaseServerQueuedMessageClaim({
+                itemId: claim.item.id,
+                generationId: claim.generationId,
+                leaseToken: claim.leaseToken,
+                leaseEpoch: claim.leaseEpoch,
+                reason: "conversation_missing",
+            });
+            return;
+        }
+        let request;
+        try {
+            request = requestForQueuedActor(claim.item.requestActor, conversation.orgId);
+        }
+        catch (error) {
+            await svc.completeServerQueuedMessageDelivery({
+                itemId: claim.item.id,
+                generationId: claim.generationId,
+                leaseToken: claim.leaseToken,
+                leaseEpoch: claim.leaseEpoch,
+                status: "failed",
+                reason: error instanceof Error ? error.message : "queued_request_actor_invalid",
+            });
+            return;
+        }
+        const actor = getActorInfo(request);
+        const managedAbort = backgroundRuntime.manageAbortController();
+        const abortController = managedAbort.controller;
+        const releaseGeneration = claimChatGeneration(conversation.id, abortController, claim.generationId);
+        if (!releaseGeneration) {
+            managedAbort.release();
+            await svc.releaseServerQueuedMessageClaim({
+                itemId: claim.item.id,
+                generationId: claim.generationId,
+                leaseToken: claim.leaseToken,
+                leaseEpoch: claim.leaseEpoch,
+                reason: "local_generation_owner_busy",
+            });
+            return;
+        }
+        let leaseRenewing = false;
+        let leaseLost = false;
+        const renewLease = async () => {
+            if (leaseRenewing || leaseLost)
+                return;
+            leaseRenewing = true;
+            try {
+                const renewed = await svc.renewServerQueuedMessageClaim({
+                    itemId: claim.item.id,
+                    generationId: claim.generationId,
+                    leaseToken: claim.leaseToken,
+                    leaseEpoch: claim.leaseEpoch,
+                    leaseMs: queueLeaseMs,
+                });
+                if (!renewed) {
+                    leaseLost = true;
+                    abortController.abort(new Error("Queued chat continuation lost its delivery lease"));
+                }
+            }
+            finally {
+                leaseRenewing = false;
+            }
+        };
+        const leaseTimer = backgroundRuntime.setInterval(() => {
+            return renewLease().catch((error) => {
+                leaseLost = true;
+                abortController.abort(error);
+            });
+        }, Math.floor(queueLeaseMs / 3));
+        let terminalStatus = "failed";
+        let terminalReason = null;
+        let completionRecorded = false;
+        let assistantConversation = conversation;
+        let activeChatRunId = null;
+        const transcript = [];
+        let partialBody = "";
+        try {
+            const userMessage = await svc.getMessage(conversation.id, claim.userMessageId);
+            if (!userMessage)
+                throw new Error("Queued chat continuation user message is missing");
+            const turnContext = turnContextFromUserMessage(userMessage);
+            const assistantInput = await loadAssistantInput(conversation, actor);
+            assistantConversation = assistantInput.conversation;
+            const streamed = await assistantSvc.streamChatAssistantReply({
+                ...assistantInput,
+                userMessageId: userMessage.id,
+                chatTurnId: turnContext.chatTurnId,
+                turnVariant: turnContext.turnVariant,
+                stream: false,
+                abortSignal: abortController.signal,
+                controlCoordinator: createChatRuntimeControlCoordinator(conversation.id, claim.generationId, {
+                    onAttemptStarted: async ({ generationId, attemptEpoch, ownerToken, attempt }) => {
+                        await svc.beginGenerationControlAttempt({
+                            orgId: conversation.orgId,
+                            conversationId: conversation.id,
+                            generationId,
+                            attemptEpoch,
+                            ownerToken,
+                            runtimeType: attempt.runtimeType,
+                        });
+                    },
+                    onHandleRegistered: async ({ generationId, attemptEpoch, ownerToken, handle }) => {
+                        await svc.markGenerationControlReady({
+                            generationId,
+                            attemptEpoch,
+                            ownerToken,
+                            runtimeType: handle.runtimeType,
+                            providerThreadId: handle.providerThreadId ?? null,
+                            providerTurnId: handle.providerTurnId ?? null,
+                        });
+                    },
+                    onAttemptLeaseRenewed: async ({ generationId, attemptEpoch, ownerToken }) => {
+                        await svc.renewGenerationControlLease({ generationId, attemptEpoch, ownerToken });
+                    },
+                    onAttemptCompleted: async ({ generationId, attemptEpoch, ownerToken }) => {
+                        await svc.markGenerationControlAttemptCompleted({
+                            generationId,
+                            attemptEpoch,
+                            ownerToken,
+                        });
+                    },
+                }),
+                onRunCreated: (runId) => {
+                    activeChatRunId = runId;
+                },
+                onAssistantDelta: async (delta) => {
+                    if (!abortController.signal.aborted)
+                        partialBody = `${partialBody}${delta}`;
+                },
+                onTranscriptEntry: async (entry) => {
+                    if (!abortController.signal.aborted)
+                        transcript.push(entry);
+                },
+            });
+            partialBody = streamed.partialBody || partialBody;
+            if (abortController.signal.aborted || streamed.outcome === "stopped") {
+                terminalStatus = "stopped";
+                terminalReason = "operator_stop";
+                const stoppedMessage = await persistPartialAssistantMessage(assistantConversation, "", "stopped", turnContext, transcript, streamed.replyingAgentId, null, activeChatRunId);
+                const stoppedMessages = stoppedMessage ? [stoppedMessage] : [];
+                await linkChatRunMessages(assistantConversation, activeChatRunId, stoppedMessages);
+                if (stoppedMessages.length > 0) {
+                    await logChatMessagesAdded(assistantConversation, stoppedMessages, {
+                        actorType: "system",
+                        actorId: "chat-assistant",
+                        agentId: streamed.replyingAgentId,
+                    });
+                }
+            }
+            else {
+                let completionMessageId = null;
+                try {
+                    const attemptEpoch = Math.max(1, getActiveChatGeneration(conversation.id)?.attemptEpoch ?? 1);
+                    const completion = await svc.generationProtocol.appendVisibleEventAndProject({
+                        orgId: conversation.orgId,
+                        conversationId: conversation.id,
+                        generationId: claim.generationId,
+                        expectedAttemptEpoch: attemptEpoch,
+                        eventKind: "runtime_output",
+                        payload: {
+                            resultKind: streamed.reply.kind,
+                            body: streamed.reply.body,
+                        },
+                        bodyOffset: 0,
+                        bodyLength: streamed.reply.body.length,
+                        runId: activeChatRunId,
+                        bodyHash: hashChatGenerationBody(streamed.reply.body),
+                        body: streamed.reply.body,
+                        transcript,
+                        replyingAgentId: streamed.replyingAgentId,
+                        chatTurnId: turnContext.chatTurnId,
+                        turnVariant: turnContext.turnVariant,
+                    });
+                    completionMessageId = completion.message.id;
+                }
+                catch (error) {
+                    if (!chatVisibleOutputAdmissionClosed(error))
+                        throw error;
+                    terminalStatus = "stopped";
+                    terminalReason = "operator_stop";
+                    const stoppedMessage = await persistPartialAssistantMessage(assistantConversation, "", "stopped", turnContext, transcript, streamed.replyingAgentId, null, activeChatRunId);
+                    const stoppedMessages = stoppedMessage ? [stoppedMessage] : [];
+                    await linkChatRunMessages(assistantConversation, activeChatRunId, stoppedMessages);
+                    if (stoppedMessages.length > 0) {
+                        await logChatMessagesAdded(assistantConversation, stoppedMessages, {
+                            actorType: "system",
+                            actorId: "chat-assistant",
+                            agentId: streamed.replyingAgentId,
+                        });
+                    }
+                    return;
+                }
+                const createdMessages = await persistAssistantReply(request, assistantConversation, actor, streamed.reply, turnContext, transcript, streamed.replyingAgentId, completionMessageId, activeChatRunId);
+                await linkChatRunMessages(assistantConversation, activeChatRunId, createdMessages);
+                await logChatMessagesAdded(assistantConversation, createdMessages, {
+                    actorType: "system",
+                    actorId: "chat-assistant",
+                    agentId: streamed.replyingAgentId,
+                });
+                terminalStatus = "completed";
+            }
+        }
+        catch (error) {
+            terminalStatus = abortController.signal.aborted ? "aborted" : "failed";
+            terminalReason = leaseLost
+                ? "delivery_lease_lost"
+                : error instanceof Error
+                    ? error.message
+                    : "queued_continuation_failed";
+            logger.warn({ err: error, conversationId: conversation.id, queuedMessageId: claim.item.id }, "server-owned queued chat continuation failed");
+            if (!leaseLost) {
+                const failurePayload = recoverableFailurePayload(error, activeChatRunId);
+                const failureBody = userVisiblePartialBodyFromError(error)
+                    || recoverableFailureBody(failurePayload)
+                    || CHAT_ASSISTANT_USER_ERROR_MESSAGE;
+                const failedMessage = await persistPartialAssistantMessage(assistantConversation, failureBody, "failed", null, transcript, chatReplyingAgentId(assistantConversation), null, activeChatRunId, failurePayload).catch(() => null);
+                const failedMessages = failedMessage ? [failedMessage] : [];
+                await linkChatRunMessages(assistantConversation, activeChatRunId, failedMessages).catch(() => undefined);
+                if (failedMessages.length > 0) {
+                    await logChatMessagesAdded(assistantConversation, failedMessages, {
+                        actorType: "system",
+                        actorId: "chat-assistant",
+                        agentId: chatReplyingAgentId(assistantConversation),
+                    }).catch(() => undefined);
+                }
+            }
+        }
+        finally {
+            backgroundRuntime.clearTimer(leaseTimer);
+            if (!leaseLost) {
+                const latestGeneration = await svc.getLatestGeneration(conversation.id).catch(() => null);
+                const terminalEvidence = latestGeneration?.id === claim.generationId
+                    ? await svc.generationProtocol.recordRuntimeTerminal({
+                        orgId: conversation.orgId,
+                        conversationId: conversation.id,
+                        generationId: claim.generationId,
+                        expectedAttemptEpoch: latestGeneration.attemptEpoch,
+                        expectedOwnerToken: latestGeneration.controlOwnerToken,
+                        finalStatus: terminalStatus,
+                        terminalReason: terminalReason ?? terminalStatus,
+                    }).catch((error) => {
+                        logger.warn({ err: error, generationId: claim.generationId }, "failed to record queued chat terminal evidence");
+                        return null;
+                    })
+                    : null;
+                if (terminalEvidence) {
+                    wakeTerminalProjector();
+                    const completed = await svc.completeServerQueuedMessageDelivery({
+                        itemId: claim.item.id,
+                        generationId: claim.generationId,
+                        leaseToken: claim.leaseToken,
+                        leaseEpoch: claim.leaseEpoch,
+                        status: terminalStatus,
+                        reason: terminalReason,
+                    }).catch((error) => {
+                        logger.warn({ err: error, queuedMessageId: claim.item.id }, "failed to complete queued chat continuation");
+                        return null;
+                    });
+                    completionRecorded = Boolean(completed);
+                }
+            }
+            if (!completionRecorded && !leaseLost) {
+                await svc.releaseServerQueuedMessageClaim({
+                    itemId: claim.item.id,
+                    generationId: claim.generationId,
+                    leaseToken: claim.leaseToken,
+                    leaseEpoch: claim.leaseEpoch,
+                    reason: "queued_continuation_completion_unconfirmed",
+                }).catch(() => null);
+            }
+            releaseGeneration();
+            managedAbort.release();
+        }
+    }
+    async function drainServerQueue() {
+        await svc.recoverExpiredServerQueueClaims();
+        while (backgroundRuntime.acceptingWork
+            && runningServerQueueTasks.size < queueWorkerConcurrency) {
+            const claim = await svc.claimNextServerQueuedMessage({
+                workerId: queueWorkerId,
+                leaseMs: queueLeaseMs,
+            });
+            if (!claim)
+                return;
+            if (!backgroundRuntime.acceptingWork) {
+                await svc.releaseServerQueuedMessageClaim({
+                    itemId: claim.item.id,
+                    generationId: claim.generationId,
+                    leaseToken: claim.leaseToken,
+                    leaseEpoch: claim.leaseEpoch,
+                    reason: "chat_background_runtime_closing",
+                });
+                return;
+            }
+            let task;
+            task = backgroundRuntime.track(runServerQueuedMessage(claim)
+                .catch((error) => {
+                logger.warn({ err: error, queuedMessageId: claim.item.id }, "server-owned chat continuation crashed");
+            })
+                .finally(() => {
+                runningServerQueueTasks.delete(task);
+                wakeServerQueue();
+            }));
+            runningServerQueueTasks.add(task);
+        }
+    }
+    const serverQueueDrain = backgroundRuntime.createCoalescingTask(drainServerQueue, (error) => logger.warn({ err: error }, "server-owned chat queue drain failed"));
+    function wakeServerQueue() {
+        if (!queueWorkerEnabled || !backgroundRuntime.acceptingWork)
+            return;
+        serverQueueDrain.wake();
+    }
+    if (queueWorkerEnabled) {
+        const recoverChatControlOwners = () => {
+            if (!backgroundRuntime.acceptingWork)
+                return;
+            return svc.generationProtocol.recoverStaleControlOwners({})
+                .then(() => {
+                wakeTerminalProjector();
+                wakeServerQueue();
+            })
+                .catch((error) => logger.warn({ err: error }, "chat control recovery failed"));
+        };
+        backgroundRuntime.setTimeout(recoverChatControlOwners, 0);
+        backgroundRuntime.setInterval(recoverChatControlOwners, 10_000);
+    }
     router.get("/orgs/:orgId/chats", async (req, res) => {
         const orgId = req.params.orgId;
         assertCompanyAccess(req, orgId);
@@ -833,12 +1374,21 @@ export function chatRoutes(db, storage) {
             ? statusParam
             : "active";
         const q = typeof req.query.q === "string" ? req.query.q : undefined;
+        const projectId = typeof req.query.projectId === "string"
+            ? req.query.projectId.trim() || undefined
+            : undefined;
         const limit = typeof req.query.limit === "string"
             ? positiveIntegerQuery(req.query.limit, 50, 500)
             : undefined;
         const userId = req.actor.type === "board" ? (req.actor.userId ?? "local-board") : null;
-        const conversations = await svc.list(orgId, { status, q, limit }, userId);
-        res.json(await assistantSvc.enrichConversations(conversations));
+        const conversations = await svc.list(orgId, {
+            status,
+            q,
+            limit,
+            ...(projectId ? { projectId } : {}),
+        }, userId);
+        const visibleConversations = conversations.filter((conversation) => conversation.messengerVisible !== false);
+        res.json(await assistantSvc.enrichConversations(visibleConversations));
     });
     router.post("/orgs/:orgId/chats", validate(createChatConversationSchema), async (req, res) => {
         const orgId = req.params.orgId;
@@ -915,6 +1465,7 @@ export function chatRoutes(db, storage) {
         if (existing.mutability === "external_bound_chat" && !isTitleOnlyChatUpdate(req.body)) {
             assertChatLocalMutationAllowed(existing);
         }
+        await assertSideChatMutationAllowed(req, existing);
         if (req.body.primaryIssueId) {
             const issue = await issuesSvc.getById(req.body.primaryIssueId);
             if (!issue || issue.orgId !== existing.orgId) {
@@ -961,6 +1512,7 @@ export function chatRoutes(db, storage) {
             res.status(404).json({ error: "Chat conversation not found" });
             return;
         }
+        await assertSideChatMutationAllowed(req, existing);
         const messages = await svc.listMessages(existing.id, { includeTranscript: false });
         const prompt = buildChatTitlePromptFromMessages(messages);
         if (!prompt) {
@@ -1026,6 +1578,96 @@ export function chatRoutes(db, storage) {
         });
         res.status(201).json(await assistantSvc.enrichConversation(forked));
     });
+    router.post("/chats/:id/side-chats", validate(createSideChatSchema), async (req, res) => {
+        assertBoard(req);
+        const existing = await assertConversationAccess(req, req.params.id);
+        if (!existing) {
+            res.status(404).json({ error: "Chat conversation not found" });
+            return;
+        }
+        const userId = boardUserId(req);
+        const sideChat = await sideChats.create({
+            sourceConversationId: existing.id,
+            sourceMessageId: req.body.sourceMessageId,
+            clientMutationId: req.body.clientMutationId,
+            orgId: existing.orgId,
+            userId,
+        });
+        const actor = getActorInfo(req);
+        await logActivity(db, {
+            orgId: existing.orgId,
+            actorType: actor.actorType,
+            actorId: actor.actorId,
+            agentId: actor.agentId,
+            runId: actor.runId,
+            action: "chat.side_chat_created",
+            entityType: "chat",
+            entityId: sideChat.id,
+            details: {
+                sourceConversationId: existing.id,
+                sourceMessageId: req.body.sourceMessageId,
+            },
+        });
+        res.status(201).json(await assistantSvc.enrichConversation(sideChat));
+    });
+    router.post("/chats/:id/side-chat/complete", async (req, res) => {
+        assertBoard(req);
+        const existing = await assertConversationAccess(req, req.params.id);
+        if (!existing || existing.conversationKind !== "side_chat") {
+            res.status(404).json({ error: "Side Chat not found" });
+            return;
+        }
+        const userId = boardUserId(req);
+        const sideChat = await sideChats.complete({
+            conversationId: req.params.id,
+            userId,
+        });
+        const actor = getActorInfo(req);
+        await logActivity(db, {
+            orgId: sideChat.orgId,
+            actorType: actor.actorType,
+            actorId: actor.actorId,
+            agentId: actor.agentId,
+            runId: actor.runId,
+            action: "chat.side_chat_completed",
+            entityType: "chat",
+            entityId: sideChat.id,
+            details: {
+                sourceConversationId: sideChat.forkedFromConversationId,
+                sourceMessageId: sideChat.forkedFromMessageId,
+            },
+        });
+        res.json(await assistantSvc.enrichConversation(sideChat));
+    });
+    router.post("/chats/:id/side-chat/keep", async (req, res) => {
+        assertBoard(req);
+        const existing = await assertConversationAccess(req, req.params.id);
+        if (!existing || existing.conversationKind !== "side_chat") {
+            res.status(404).json({ error: "Side Chat not found" });
+            return;
+        }
+        const userId = boardUserId(req);
+        const sideChat = await sideChats.keepInMessenger({
+            conversationId: req.params.id,
+            userId,
+        });
+        const actor = getActorInfo(req);
+        await logActivity(db, {
+            orgId: sideChat.orgId,
+            actorType: actor.actorType,
+            actorId: actor.actorId,
+            agentId: actor.agentId,
+            runId: actor.runId,
+            action: "chat.side_chat_kept",
+            entityType: "chat",
+            entityId: sideChat.id,
+            details: {
+                sourceConversationId: sideChat.forkedFromConversationId,
+                sourceMessageId: sideChat.forkedFromMessageId,
+            },
+        });
+        res.json(await assistantSvc.enrichConversation(sideChat));
+    });
     router.delete("/chats/:id", async (req, res) => {
         assertBoard(req);
         const existing = await assertConversationAccess(req, req.params.id);
@@ -1034,6 +1676,9 @@ export function chatRoutes(db, storage) {
             return;
         }
         assertChatLocalMutationAllowed(existing);
+        if (existing.conversationKind === "side_chat") {
+            throw conflict("Side Chat audit records cannot be deleted");
+        }
         if (hasActiveChatGeneration(existing.id)) {
             if (req.query.cancelActive === "true") {
                 cancelAndReleaseActiveChatGeneration(existing.id);
@@ -1050,7 +1695,9 @@ export function chatRoutes(db, storage) {
         }
         for (const attachment of attachments) {
             try {
-                await storage.deleteObject(attachment.orgId, attachment.objectKey);
+                if (!await svc.assetHasAttachments(attachment.assetId)) {
+                    await storage.deleteObject(attachment.orgId, attachment.objectKey);
+                }
             }
             catch (err) {
                 logger.warn({ err, conversationId: existing.id, attachmentId: attachment.id }, "failed to delete chat attachment object during chat delete");
@@ -1088,12 +1735,15 @@ export function chatRoutes(db, storage) {
             return;
         }
         assertChatLocalMutationAllowed(conversation);
+        await assertSideChatMutationAllowed(req, conversation);
+        const requestActor = queueRequestActor(req);
         const item = await svc.createQueuedMessage({
             orgId: conversation.orgId,
             conversationId: conversation.id,
             clientMutationId: req.body.clientMutationId,
             expectedGenerationId: req.body.expectedGenerationId ?? getActiveChatGeneration(conversation.id)?.generationId ?? null,
             payload: req.body.payload,
+            requestActor,
         });
         const actor = getActorInfo(req);
         await logActivity(db, {
@@ -1110,6 +1760,7 @@ export function chatRoutes(db, storage) {
                 position: item.position,
             },
         });
+        wakeServerQueue();
         res.status(201).json(item);
     });
     router.post("/chats/:id/queue/next/claim", async (req, res) => {
@@ -1119,6 +1770,7 @@ export function chatRoutes(db, storage) {
             return;
         }
         assertChatLocalMutationAllowed(conversation);
+        await assertSideChatMutationAllowed(req, conversation);
         if (hasActiveChatGeneration(conversation.id)) {
             throw conflict("Cannot dequeue the next message while a reply is in progress");
         }
@@ -1153,6 +1805,7 @@ export function chatRoutes(db, storage) {
             return;
         }
         assertChatLocalMutationAllowed(conversation);
+        await assertSideChatMutationAllowed(req, conversation);
         const item = await svc.releaseQueuedMessageClaim({
             conversationId: conversation.id,
             itemId: req.params.itemId,
@@ -1167,6 +1820,7 @@ export function chatRoutes(db, storage) {
             return;
         }
         assertChatLocalMutationAllowed(conversation);
+        await assertSideChatMutationAllowed(req, conversation);
         const item = await svc.updateQueuedMessage({
             conversationId: conversation.id,
             itemId: req.params.itemId,
@@ -1182,6 +1836,7 @@ export function chatRoutes(db, storage) {
             return;
         }
         assertChatLocalMutationAllowed(conversation);
+        await assertSideChatMutationAllowed(req, conversation);
         const parsed = cancelChatQueuedMessageSchema.safeParse(req.body ?? {});
         if (!parsed.success) {
             res.status(400).json({ error: "Invalid queued message cancel request", details: parsed.error.issues });
@@ -1201,27 +1856,283 @@ export function chatRoutes(db, storage) {
             return;
         }
         assertChatLocalMutationAllowed(conversation);
+        await assertSideChatMutationAllowed(req, conversation);
         const active = getActiveChatGeneration(conversation.id);
-        if (!active?.generationId) {
-            throw conflict("Cannot steer queued follow-ups because no reply is in progress");
-        }
-        const expected = req.body.expectedActiveGenerationId ?? null;
-        const result = expected && expected !== active.generationId
-            ? "stale_generation"
-            : "unsupported";
-        const item = await svc.markQueuedMessageSteerFallback({
+        const requestActor = queueRequestActor(req);
+        const controlActionId = req.body.controlActionId ?? randomUUID();
+        const expectedGenerationId = req.body.expectedActiveGenerationId
+            ?? active?.generationId
+            ?? null;
+        if (!expectedGenerationId) {
+            const scheduled = await svc.scheduleSteerContinuation({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                itemId: req.params.itemId,
+                controlActionId,
+                requestActor,
+            });
+            wakeServerQueue();
+            res.json({
+                item: scheduled.item,
+                result: "scheduled_next",
+                disposition: "continuation_pending",
+                controlActionId,
+                activeGenerationId: scheduled.action.expectedGenerationId ?? null,
+                queueVersion: scheduled.item.version,
+                transcriptEventId: null,
+            });
+            return;
+        }
+        const queueSnapshot = await svc.getQueueSnapshot(conversation.id, expectedGenerationId);
+        const expectedAttemptEpoch = req.body.expectedAttemptEpoch
+            ?? queueSnapshot.activeAttemptEpoch
+            ?? active?.attemptEpoch
+            ?? 0;
+        const expectedControlVersion = req.body.expectedControlVersion
+            ?? queueSnapshot.activeControlVersion
+            ?? 0;
+        const started = await svc.beginSteerControlAction({
+            orgId: conversation.orgId,
             conversationId: conversation.id,
             itemId: req.params.itemId,
-            reason: result,
-            activeGenerationId: active?.generationId ?? null,
+            controlActionId,
+            expectedGenerationId,
+            expectedAttemptEpoch,
+            expectedControlVersion,
+            requestActor,
         });
-        res.json({
+        const durableControlActionId = started.action.id;
+        const durableGenerationId = started.action.expectedGenerationId ?? expectedGenerationId;
+        const durableAttemptEpoch = started.action.expectedAttemptEpoch ?? expectedAttemptEpoch;
+        const responseForDurableDisposition = (item, disposition) => ({
             item,
-            result: result === "unsupported" ? "queued_fallback" : result,
-            activeGenerationId: active?.generationId ?? null,
+            result: disposition === "accepted_current"
+                ? "delivered_current"
+                : disposition === "acceptance_unknown"
+                    ? "acceptance_unknown"
+                    : disposition === "continuation_pending"
+                        ? "scheduled_next"
+                        : disposition === "failed_actionable"
+                            ? "failed_actionable"
+                            : "pending",
+            disposition,
+            controlActionId: durableControlActionId,
+            activeGenerationId: durableGenerationId,
             queueVersion: item.version,
             transcriptEventId: null,
         });
+        if (started.idempotent && started.action.localDisposition !== "pending") {
+            if (started.action.localDisposition === "continuation_pending")
+                wakeServerQueue();
+            res.json(responseForDurableDisposition(started.item, started.action.localDisposition));
+            return;
+        }
+        if (started.action.localDisposition === "continuation_pending") {
+            wakeServerQueue();
+            res.json(responseForDurableDisposition(started.item, started.action.localDisposition));
+            return;
+        }
+        const providerSendState = { denied: null };
+        const runtimeResult = await steerActiveChatGeneration({
+            conversationId: conversation.id,
+            expectedGenerationId: durableGenerationId,
+            expectedAttemptEpoch: durableAttemptEpoch,
+            feedback: {
+                text: started.item.payload.body,
+                clientMessageId: started.action.providerClientMessageId ?? durableControlActionId,
+            },
+            claimProviderSend: async () => {
+                const sendClaim = await svc.claimSteerProviderSend({
+                    orgId: conversation.orgId,
+                    controlActionId: durableControlActionId,
+                });
+                if (!sendClaim)
+                    return null;
+                if ("sendDenied" in sendClaim) {
+                    providerSendState.denied = sendClaim;
+                    return {
+                        sendDenied: true,
+                        reason: "generation_fence_changed",
+                    };
+                }
+                try {
+                    await svc.appendGenerationEvent({
+                        orgId: conversation.orgId,
+                        generationId: durableGenerationId,
+                        attemptEpoch: durableAttemptEpoch,
+                        eventKind: "steer_requested",
+                        payload: { controlActionId: durableControlActionId, queueItemId: started.item.id },
+                        controlActionId: durableControlActionId,
+                        queueItemId: started.item.id,
+                    });
+                }
+                catch (error) {
+                    await svc.releaseSteerProviderSendClaim({
+                        orgId: conversation.orgId,
+                        controlActionId: durableControlActionId,
+                        reason: "steer_requested_event_failed",
+                    }).catch(() => null);
+                    throw error;
+                }
+                return {
+                    clientMessageId: sendClaim.providerClientMessageId ?? durableControlActionId,
+                    release: async () => {
+                        const released = await svc.releaseSteerProviderSendClaim({
+                            orgId: conversation.orgId,
+                            controlActionId: durableControlActionId,
+                            reason: "runtime_owner_changed_before_provider_send",
+                        });
+                        if (!released) {
+                            throw new Error("Steer provider send claim could not be safely released before send");
+                        }
+                    },
+                };
+            },
+        });
+        if (runtimeResult.status === "provider_send_in_flight") {
+            res.json(responseForDurableDisposition(started.item, started.action.localDisposition));
+            return;
+        }
+        const deniedProviderSend = providerSendState.denied;
+        if (deniedProviderSend) {
+            if (deniedProviderSend.reason === "stop_cutoff_won_before_provider_send") {
+                await interruptActiveChatGeneration(conversation.id, "steer_fallback");
+            }
+            wakeServerQueue();
+            res.json(responseForDurableDisposition(deniedProviderSend.item, deniedProviderSend.action.localDisposition));
+            return;
+        }
+        let resolution;
+        if (runtimeResult.status === "delivered_current") {
+            resolution = await svc.resolveSteerControlAction({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                itemId: started.item.id,
+                controlActionId: durableControlActionId,
+                status: "accepted_current",
+                disposition: "accepted_current",
+                providerDisposition: "acknowledged",
+                providerThreadId: runtimeResult.providerThreadId,
+                providerTurnId: runtimeResult.providerTurnId,
+                providerEvidence: {
+                    receipt: "same_turn",
+                    attemptEpoch: runtimeResult.attemptEpoch,
+                    ownerChangedAfterSend: runtimeResult.ownerChangedAfterSend === true,
+                },
+            });
+            await svc.appendGenerationEvent({
+                orgId: conversation.orgId,
+                generationId: durableGenerationId,
+                attemptEpoch: runtimeResult.attemptEpoch,
+                eventKind: "steer_acknowledged",
+                payload: {
+                    controlActionId: durableControlActionId,
+                    providerThreadId: runtimeResult.providerThreadId,
+                    providerTurnId: runtimeResult.providerTurnId,
+                },
+                controlActionId: durableControlActionId,
+                queueItemId: started.item.id,
+            });
+        }
+        else if (runtimeResult.status === "acceptance_unknown") {
+            resolution = await svc.resolveSteerControlAction({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                itemId: started.item.id,
+                controlActionId: durableControlActionId,
+                status: "acceptance_unknown",
+                disposition: "acceptance_unknown",
+                providerDisposition: "connection_lost",
+                reason: runtimeResult.reason,
+                providerEvidence: {
+                    attemptEpoch: runtimeResult.attemptEpoch,
+                    ownerChangedAfterSend: runtimeResult.ownerChangedAfterSend === true,
+                },
+            });
+        }
+        else if (runtimeResult.status === "continuation_required") {
+            const cutoff = await svc.generationProtocol.beginSteerFallbackCutoff({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                generationId: durableGenerationId,
+                expectedAttemptEpoch: durableAttemptEpoch,
+                controlActionId: durableControlActionId,
+                queueItemId: started.item.id,
+                requestedRenderSeq: req.body.lastCommittedRenderSeq,
+                requestedBodyHash: req.body.renderedBodyHash,
+            });
+            const completionCommitted = cutoff.outcome === "completion_committed";
+            const interrupt = completionCommitted
+                ? null
+                : interruptActiveChatGeneration(conversation.id, "steer_fallback");
+            const interruptDisposition = interrupt ? await interrupt : "unverified";
+            resolution = await svc.resolveSteerControlAction({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                itemId: started.item.id,
+                controlActionId: durableControlActionId,
+                status: "continuation_pending",
+                disposition: "continuation_pending",
+                providerDisposition: "not_sent",
+                providerEvidence: {
+                    ...(cutoff.action.providerEvidence ?? {}),
+                    ...(completionCommitted
+                        ? { completionDisposition: "committed" }
+                        : {
+                            interruptDisposition,
+                            acceptedThroughSeq: cutoff.action.acceptedThroughSeq,
+                            frozenBodyHash: cutoff.action.frozenBodyHash,
+                        }),
+                },
+                reason: completionCommitted
+                    ? "target_generation_completion_committed"
+                    : interrupt
+                        ? "runtime_requires_continuation"
+                        : "runtime_owner_missing_during_steer_fallback",
+            });
+            if (!completionCommitted && !interrupt) {
+                await svc.generationProtocol.recordRuntimeTerminal({
+                    orgId: conversation.orgId,
+                    conversationId: conversation.id,
+                    generationId: durableGenerationId,
+                    expectedAttemptEpoch: durableAttemptEpoch,
+                    finalStatus: "interrupted_unverified",
+                    terminalReason: "steer_fallback_runtime_owner_missing",
+                    controlActionId: durableControlActionId,
+                    payload: { interruptDisposition },
+                });
+                wakeTerminalProjector();
+            }
+            wakeServerQueue();
+        }
+        else {
+            resolution = await svc.resolveSteerControlAction({
+                orgId: conversation.orgId,
+                conversationId: conversation.id,
+                itemId: started.item.id,
+                controlActionId: durableControlActionId,
+                status: "continuation_pending",
+                disposition: "continuation_pending",
+                providerDisposition: "not_sent",
+                reason: "stale_generation",
+            });
+            await svc.appendGenerationEvent({
+                orgId: conversation.orgId,
+                generationId: durableGenerationId,
+                attemptEpoch: durableAttemptEpoch,
+                eventKind: "continuation_scheduled",
+                payload: { controlActionId: durableControlActionId, reason: "stale_generation" },
+                controlActionId: durableControlActionId,
+                queueItemId: started.item.id,
+            });
+            wakeServerQueue();
+        }
+        res.json({
+            ...responseForDurableDisposition(resolution.item, resolution.action.localDisposition),
+            activeGenerationId: durableGenerationId,
+            queueVersion: resolution.item.version,
+            transcriptEventId: null,
+        });
     });
     router.get("/chats/:id/messages", async (req, res) => {
         const conversation = await assertConversationAccess(req, req.params.id);
@@ -1261,6 +2172,7 @@ export function chatRoutes(db, storage) {
         }
         const actor = getActorInfo(req);
         assertChatLocalMutationAllowed(conversation);
+        await assertSideChatMutationAllowed(req, conversation);
         if (actor.actorType === "agent") {
             if (req.body.editUserMessageId) {
                 res.status(422).json({ error: "Agent-authored chat messages cannot edit operator messages" });
@@ -1282,6 +2194,7 @@ export function chatRoutes(db, storage) {
                 conversationId: conversation.id,
                 clientMutationId: `message:${randomUUID()}`,
                 expectedGenerationId: getActiveChatGeneration(conversation.id)?.generationId ?? null,
+                requestActor: queueRequestActor(req),
                 payload: {
                     body: req.body.body,
                     attachmentIds: [],
@@ -1295,11 +2208,13 @@ export function chatRoutes(db, storage) {
                     },
                 },
             });
+            wakeServerQueue();
             res.status(202).json({ queued: item });
             return;
         }
         try {
             const userMessage = await addUserMessage(conversation, req.body.body, actor, req.body.editUserMessageId ?? null);
+            await touchSideChat(req, conversation);
             if (!req.body.editUserMessageId) {
                 startChatTitleGeneration(conversation, userMessage);
             }
@@ -1388,6 +2303,8 @@ export function chatRoutes(db, storage) {
         heartbeat,
         assertConversationAccess,
         assertChatLocalMutationAllowed,
+        assertSideChatMutationAllowed,
+        touchSideChat,
         boardUserId,
         assertCanAssignTasks,
         runSingleFileUpload,
@@ -1411,6 +2328,9 @@ export function chatRoutes(db, storage) {
         recoverableFailurePayload,
         recoverableFailureBody,
         writeStreamEvent,
+        queueRequestActor,
+        wakeServerQueue,
+        wakeTerminalProjector,
     });
     return router;
 }