@rudderhq/server 0.4.6-canary.8 → 0.5.0

package/dist/services/chats.js

@@ -1,16 +1,65 @@
-import { agentIntegrationChatBindings, agentIntegrations, approvals, assets, chatAttachments, chatContextLinks, chatConversations, chatConversationUserStates, chatGenerations, chatMessages, chatQueuedMessages, messengerCustomGroupEntries, messengerCustomGroups } from "@rudderhq/db";
-import { MESSENGER_FORK_GROUP_DEFAULT_ICON, sanitizeChatStructuredPayload } from "@rudderhq/shared";
+import { agentIntegrationChatBindings, agentIntegrations, approvals, assets, chatAttachments, chatContextLinks, chatControlActions, chatConversations, chatConversationUserStates, chatGenerationEvents, chatGenerations, chatMessages, chatQueuedMessages, messengerCustomGroupEntries, messengerCustomGroups } from "@rudderhq/db";
+import { chatInlineVisualMappingsFromStructuredPayload, MESSENGER_FORK_GROUP_DEFAULT_ICON, sanitizeChatStructuredPayload } from "@rudderhq/shared";
 import { and, asc, desc, eq, gt, gte, inArray, isNull, lt, or, sql } from "drizzle-orm";
 import { randomUUID } from "node:crypto";
 import { conflict, notFound, unprocessable } from "../errors.js";
 import { logActivity } from "./activity-log.js";
 import { agentService } from "./agents.js";
 import { approvalService } from "./approvals.js";
+import { chatGenerationProtocolService } from "./chat-generation-protocol.js";
 import { issueApprovalService } from "./issue-approvals.js";
 import { issueService } from "./issues.js";
 import { normalizeLocalLibraryPathMarkdown } from "./library-path-markdown.js";
 import { organizationService } from "./orgs.js";
 import { isPostgresError } from "./postgres-errors.js";
+const CHAT_TITLE_MAX_LENGTH = 200;
+const FORK_TITLE_SUFFIX_PATTERN = / \(([1-9]\d*)\)$/;
+const ACTIVE_CHAT_GENERATION_STATUSES = [
+    "starting",
+    "active",
+    "running",
+    "tool_busy",
+    "closing",
+    "stop_requested",
+    "stopping",
+];
+const NATIVE_STEER_GENERATION_STATUSES = ["starting", "active", "running", "tool_busy"];
+const SERVER_QUEUE_RUNNING_STATUSES = ["dequeue_claimed", "running_next"];
+const CHAT_GENERATION_CONTROL_LEASE_MS = 30_000;
+function baseForkTitle(title, sourceIsFork, familyTitles) {
+    const trimmed = title.trim() || "Forked conversation";
+    if (!sourceIsFork)
+        return trimmed;
+    const match = trimmed.match(FORK_TITLE_SUFFIX_PATTERN);
+    const index = Number(match?.[1]);
+    if (!match || index < 2)
+        return trimmed;
+    for (const familyTitle of familyTitles) {
+        const candidateBase = familyTitle.trim();
+        if (!candidateBase || candidateBase === trimmed)
+            continue;
+        if (numberedForkTitle(candidateBase, index) !== trimmed)
+            continue;
+        if (index === 2 || familyTitles.has(numberedForkTitle(candidateBase, index - 1))) {
+            return candidateBase;
+        }
+    }
+    return trimmed;
+}
+function numberedForkTitle(baseTitle, index) {
+    const suffix = ` (${index})`;
+    const availableBaseLength = CHAT_TITLE_MAX_LENGTH - suffix.length;
+    const truncatedBase = baseTitle.slice(0, availableBaseLength).trimEnd() || "Forked conversation";
+    return `${truncatedBase}${suffix}`;
+}
+function nextForkTitle(source, familyTitles) {
+    const existingTitles = new Set(familyTitles);
+    const baseTitle = baseForkTitle(source.title, Boolean(source.forkedFromConversationId), existingTitles);
+    let index = 2;
+    while (existingTitles.has(numberedForkTitle(baseTitle, index)))
+        index += 1;
+    return numberedForkTitle(baseTitle, index);
+}
 function conversationMutability(row, sourceMetadata, sourceMetadataByConversationId) {
     if (sourceMetadata)
         return "external_bound_chat";
@@ -22,6 +71,7 @@ function conversationMutability(row, sourceMetadata, sourceMetadataByConversatio
 }
 import { buildSearchSnippet, CHAT_TRANSCRIPT_KEY, chatTranscriptFromPayload, chatTranscriptSummaryFromEntries, contentPath, escapeLikePattern, incomingMessagePreviewSql, issueProposalFromPayload, isVisibleIncomingChatMessage, listContextLinksForConversationIds, listPrimaryIssues, operationProposalDecisionStatusFromPayload, operationProposalFromPayload, resolveContextEntities, safeTrim, stripChatMetadataFromPayload, textContains, truncatePreview, visibleIncomingMessageSql, withOperationProposalDecisionState, withPersistedTranscript, } from "./chats.helpers.js";
 export function chatService(db) {
+    const generationProtocol = chatGenerationProtocolService(db);
     const QUEUED_MESSAGE_CLAIM_LEASE_MS = 2 * 60 * 1000;
     const issuesSvc = issueService(db);
     const approvalsSvc = approvalService(db);
@@ -388,8 +438,11 @@ export function chatService(db) {
             .orderBy(chatAttachments.createdAt);
         const map = new Map();
         for (const row of rows) {
+            const safeRow = row.contentType === "text/html" && row.createdByAgentId
+                ? (({ provider: _provider, objectKey: _objectKey, ...safe }) => safe)(row)
+                : row;
             const attachment = {
-                ...row,
+                ...safeRow,
                 contentPath: contentPath(row.assetId),
             };
             const list = map.get(row.messageId);
@@ -438,12 +491,18 @@ export function chatService(db) {
         };
     }
     async function createGeneration(orgId, conversationId) {
+        const now = new Date();
         const [row] = await db
             .insert(chatGenerations)
             .values({
             orgId,
             conversationId,
             status: "active",
+            controlOwnerToken: randomUUID(),
+            controlLeaseExpiresAt: new Date(now.getTime() + CHAT_GENERATION_CONTROL_LEASE_MS),
+            startedAt: now,
+            createdAt: now,
+            updatedAt: now,
         })
             .returning();
         if (!row)
@@ -454,23 +513,81 @@ export function chatService(db) {
         if (!generationId)
             return null;
         const now = new Date();
-        const [row] = await db
-            .update(chatGenerations)
-            .set({
-            status,
-            terminalReason: status,
-            completedAt: now,
-            updatedAt: now,
-        })
-            .where(and(eq(chatGenerations.id, generationId), inArray(chatGenerations.status, ["active", "tool_busy", "closing"])))
-            .returning();
-        return row ?? null;
+        return db.transaction(async (tx) => {
+            const [row] = await tx
+                .update(chatGenerations)
+                .set({
+                status,
+                terminalReason: status,
+                controlState: "terminal",
+                runtimeTerminalAt: now,
+                completedAt: now,
+                updatedAt: now,
+            })
+                .where(and(eq(chatGenerations.id, generationId), inArray(chatGenerations.status, ACTIVE_CHAT_GENERATION_STATUSES)))
+                .returning();
+            if (!row)
+                return null;
+            const deliveredSteers = await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: "delivered",
+                deliveryDisposition: "delivered",
+                reconciliationReason: null,
+                lastDeliveryReason: null,
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.status, "accepted_current"), or(eq(chatQueuedMessages.expectedGenerationId, generationId), eq(chatQueuedMessages.activeGenerationId, generationId))))
+                .returning({ controlActionId: chatQueuedMessages.controlActionId });
+            const controlActionIds = deliveredSteers
+                .map((item) => item.controlActionId)
+                .filter((id) => Boolean(id));
+            if (controlActionIds.length > 0) {
+                await tx
+                    .update(chatControlActions)
+                    .set({
+                    localDisposition: "delivered",
+                    resolvedAt: now,
+                    updatedAt: now,
+                })
+                    .where(and(inArray(chatControlActions.id, controlActionIds), eq(chatControlActions.localDisposition, "accepted_current")));
+            }
+            const continuedSteers = await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: "continuation_pending",
+                deliveryDisposition: "continuation_pending",
+                reconciliationReason: `target_generation_${status}`,
+                lastDeliveryReason: null,
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.status, "steer_pending"), or(eq(chatQueuedMessages.expectedGenerationId, generationId), eq(chatQueuedMessages.activeGenerationId, generationId))))
+                .returning({ controlActionId: chatQueuedMessages.controlActionId });
+            const continuedControlActionIds = continuedSteers
+                .map((item) => item.controlActionId)
+                .filter((id) => Boolean(id));
+            if (continuedControlActionIds.length > 0) {
+                await tx
+                    .update(chatControlActions)
+                    .set({
+                    localDisposition: "continuation_pending",
+                    providerDisposition: "not_sent",
+                    lastError: `target_generation_${status}`,
+                    resolvedAt: now,
+                    updatedAt: now,
+                })
+                    .where(and(inArray(chatControlActions.id, continuedControlActionIds), eq(chatControlActions.localDisposition, "pending")));
+            }
+            return row;
+        });
     }
     async function getLatestActiveGeneration(conversationId) {
         return db
             .select()
             .from(chatGenerations)
-            .where(and(eq(chatGenerations.conversationId, conversationId), inArray(chatGenerations.status, ["active", "tool_busy", "closing"])))
+            .where(and(eq(chatGenerations.conversationId, conversationId), inArray(chatGenerations.status, ACTIVE_CHAT_GENERATION_STATUSES)))
             .orderBy(desc(chatGenerations.startedAt), desc(chatGenerations.createdAt))
             .limit(1)
             .then((rows) => rows[0] ?? null);
@@ -489,7 +606,16 @@ export function chatService(db) {
         const rows = await db
             .select()
             .from(chatQueuedMessages)
-            .where(and(eq(chatQueuedMessages.conversationId, conversationId), inArray(chatQueuedMessages.status, ["queued", "steer_pending", "dequeue_claimed", "running"])))
+            .where(and(eq(chatQueuedMessages.conversationId, conversationId), inArray(chatQueuedMessages.status, [
+            "queued",
+            "steer_pending",
+            "acceptance_unknown",
+            "continuation_pending",
+            "dequeue_claimed",
+            "running",
+            "running_next",
+            "failed_actionable",
+        ])))
             .orderBy(asc(chatQueuedMessages.position), asc(chatQueuedMessages.createdAt));
         return rows.map(hydrateQueuedMessage);
     }
@@ -497,13 +623,673 @@ export function chatService(db) {
         const activeGeneration = activeGenerationId === undefined
             ? await getLatestActiveGeneration(conversationId)
             : activeGenerationId
-                ? { id: activeGenerationId }
+                ? await db
+                    .select()
+                    .from(chatGenerations)
+                    .where(and(eq(chatGenerations.id, activeGenerationId), eq(chatGenerations.conversationId, conversationId)))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null)
                 : null;
         return {
             activeGenerationId: activeGeneration?.id ?? null,
+            activeAttemptEpoch: activeGeneration?.attemptEpoch ?? null,
+            activeControlVersion: activeGeneration?.controlVersion ?? null,
+            activeGenerationStatus: activeGeneration?.status ?? null,
             items: await listQueuedMessages(conversationId),
         };
     }
+    async function beginGenerationControlAttempt(input) {
+        const now = new Date();
+        const leaseExpiresAt = new Date(now.getTime() + CHAT_GENERATION_CONTROL_LEASE_MS);
+        const [row] = await db
+            .update(chatGenerations)
+            .set({
+            attemptEpoch: input.attemptEpoch,
+            controlState: "unregistered",
+            controlRuntimeType: input.runtimeType,
+            controlOwnerToken: input.ownerToken,
+            controlLeaseExpiresAt: leaseExpiresAt,
+            providerThreadId: null,
+            providerTurnId: null,
+            status: "starting",
+            updatedAt: now,
+        })
+            .where(and(eq(chatGenerations.id, input.generationId), eq(chatGenerations.orgId, input.orgId), eq(chatGenerations.conversationId, input.conversationId), isNull(chatGenerations.runtimeTerminalAt), inArray(chatGenerations.status, ["active", "starting", "running", "tool_busy", "closing"]), sql `${chatGenerations.attemptEpoch} <= ${input.attemptEpoch}`))
+            .returning();
+        if (!row)
+            throw conflict("Chat generation control ownership changed before runtime startup");
+        return row;
+    }
+    async function markGenerationControlReady(input) {
+        const now = new Date();
+        const [row] = await db
+            .update(chatGenerations)
+            .set({
+            controlState: "ready",
+            controlRuntimeType: input.runtimeType,
+            providerThreadId: input.providerThreadId ?? null,
+            providerTurnId: input.providerTurnId ?? null,
+            controlLeaseExpiresAt: new Date(now.getTime() + CHAT_GENERATION_CONTROL_LEASE_MS),
+            status: "running",
+            updatedAt: now,
+        })
+            .where(and(eq(chatGenerations.id, input.generationId), eq(chatGenerations.attemptEpoch, input.attemptEpoch), eq(chatGenerations.controlOwnerToken, input.ownerToken), isNull(chatGenerations.runtimeTerminalAt), inArray(chatGenerations.status, ["active", "starting", "running", "tool_busy"])))
+            .returning();
+        if (!row)
+            throw conflict("Chat runtime control handle lost its generation lease");
+        return row;
+    }
+    async function renewGenerationControlLease(input) {
+        const now = input.now ?? new Date();
+        const [row] = await db
+            .update(chatGenerations)
+            .set({
+            controlLeaseExpiresAt: new Date(now.getTime() + CHAT_GENERATION_CONTROL_LEASE_MS),
+            updatedAt: now,
+        })
+            .where(and(eq(chatGenerations.id, input.generationId), eq(chatGenerations.attemptEpoch, input.attemptEpoch), eq(chatGenerations.controlOwnerToken, input.ownerToken), isNull(chatGenerations.runtimeTerminalAt), inArray(chatGenerations.status, ["active", "starting", "running", "tool_busy", "closing"])))
+            .returning({ id: chatGenerations.id });
+        if (!row)
+            throw conflict("Chat generation control lease is no longer current");
+        return true;
+    }
+    async function markGenerationControlAttemptCompleted(input) {
+        const now = new Date();
+        return db.transaction(async (tx) => {
+            const [row] = await tx
+                .update(chatGenerations)
+                .set({
+                controlState: "unregistered",
+                status: "closing",
+                updatedAt: now,
+            })
+                .where(and(eq(chatGenerations.id, input.generationId), eq(chatGenerations.attemptEpoch, input.attemptEpoch), eq(chatGenerations.controlOwnerToken, input.ownerToken), inArray(chatGenerations.status, ["active", "starting", "running", "tool_busy", "closing"])))
+                .returning();
+            if (!row)
+                return null;
+            const pendingSteers = await tx
+                .select({
+                id: chatQueuedMessages.id,
+                controlActionId: chatQueuedMessages.controlActionId,
+            })
+                .from(chatQueuedMessages)
+                .where(and(eq(chatQueuedMessages.status, "steer_pending"), eq(chatQueuedMessages.activeGenerationId, input.generationId), eq(chatQueuedMessages.attemptEpoch, input.attemptEpoch)));
+            const pendingItemIds = pendingSteers.map((item) => item.id).sort();
+            const controlActionIds = pendingSteers
+                .map((item) => item.controlActionId)
+                .filter((id) => Boolean(id))
+                .sort();
+            if (controlActionIds.length > 0) {
+                await tx
+                    .select({ id: chatControlActions.id })
+                    .from(chatControlActions)
+                    .where(inArray(chatControlActions.id, controlActionIds))
+                    .orderBy(asc(chatControlActions.id))
+                    .for("update");
+            }
+            if (pendingItemIds.length > 0) {
+                await tx
+                    .select({ id: chatQueuedMessages.id })
+                    .from(chatQueuedMessages)
+                    .where(inArray(chatQueuedMessages.id, pendingItemIds))
+                    .orderBy(asc(chatQueuedMessages.id))
+                    .for("update");
+            }
+            const uncertainSteers = pendingItemIds.length === 0
+                ? []
+                : await tx
+                    .update(chatQueuedMessages)
+                    .set({
+                    status: "acceptance_unknown",
+                    deliveryDisposition: "acceptance_unknown",
+                    reconciliationReason: "runtime_attempt_completed_after_steer_send",
+                    lastDeliveryReason: "runtime_attempt_completed_after_steer_send",
+                    version: sql `${chatQueuedMessages.version} + 1`,
+                    updatedAt: now,
+                })
+                    .where(and(inArray(chatQueuedMessages.id, pendingItemIds), eq(chatQueuedMessages.status, "steer_pending"), inArray(chatQueuedMessages.controlActionId, tx
+                    .select({ id: chatControlActions.id })
+                    .from(chatControlActions)
+                    .where(inArray(chatControlActions.providerDisposition, [
+                    "sent",
+                    "timed_out",
+                    "connection_lost",
+                    "waiting_safe_boundary",
+                    "unverified",
+                ])))))
+                    .returning({ controlActionId: chatQueuedMessages.controlActionId });
+            const uncertainControlActionIds = uncertainSteers
+                .map((item) => item.controlActionId)
+                .filter((id) => Boolean(id));
+            if (uncertainControlActionIds.length > 0) {
+                await tx
+                    .update(chatControlActions)
+                    .set({
+                    localDisposition: "acceptance_unknown",
+                    providerDisposition: "unverified",
+                    lastError: "runtime_attempt_completed_after_steer_send",
+                    resolvedAt: now,
+                    updatedAt: now,
+                })
+                    .where(and(inArray(chatControlActions.id, uncertainControlActionIds), eq(chatControlActions.localDisposition, "pending")));
+            }
+            const continuedSteers = pendingItemIds.length === 0
+                ? []
+                : await tx
+                    .update(chatQueuedMessages)
+                    .set({
+                    status: "continuation_pending",
+                    deliveryDisposition: "continuation_pending",
+                    reconciliationReason: "runtime_attempt_completed_without_steer_acceptance",
+                    lastDeliveryReason: null,
+                    version: sql `${chatQueuedMessages.version} + 1`,
+                    updatedAt: now,
+                })
+                    .where(and(inArray(chatQueuedMessages.id, pendingItemIds), eq(chatQueuedMessages.status, "steer_pending"), or(isNull(chatQueuedMessages.controlActionId), inArray(chatQueuedMessages.controlActionId, tx
+                    .select({ id: chatControlActions.id })
+                    .from(chatControlActions)
+                    .where(or(eq(chatControlActions.providerDisposition, "not_sent"), eq(chatControlActions.providerDisposition, "rejected"), isNull(chatControlActions.providerDisposition)))))))
+                    .returning({ controlActionId: chatQueuedMessages.controlActionId });
+            const continuedControlActionIds = continuedSteers
+                .map((item) => item.controlActionId)
+                .filter((id) => Boolean(id));
+            if (continuedControlActionIds.length > 0) {
+                await tx
+                    .update(chatControlActions)
+                    .set({
+                    localDisposition: "continuation_pending",
+                    providerDisposition: "not_sent",
+                    lastError: "runtime_attempt_completed_without_steer_acceptance",
+                    resolvedAt: now,
+                    updatedAt: now,
+                })
+                    .where(and(inArray(chatControlActions.id, continuedControlActionIds), eq(chatControlActions.localDisposition, "pending")));
+            }
+            return row;
+        });
+    }
+    async function appendGenerationEvent(input) {
+        return db.transaction(async (tx) => {
+            await tx.execute(sql `select id from ${chatGenerations} where ${chatGenerations.id} = ${input.generationId} and ${chatGenerations.orgId} = ${input.orgId} for update`);
+            const generation = await tx
+                .select({ id: chatGenerations.id })
+                .from(chatGenerations)
+                .where(and(eq(chatGenerations.id, input.generationId), eq(chatGenerations.orgId, input.orgId)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!generation)
+                throw notFound("Chat generation not found");
+            const nextSeq = await tx
+                .select({ value: sql `coalesce(max(${chatGenerationEvents.generationSeq}), 0) + 1` })
+                .from(chatGenerationEvents)
+                .where(eq(chatGenerationEvents.generationId, input.generationId))
+                .then((rows) => Number(rows[0]?.value ?? 1));
+            const [event] = await tx
+                .insert(chatGenerationEvents)
+                .values({
+                orgId: input.orgId,
+                generationId: input.generationId,
+                generationSeq: nextSeq,
+                attemptEpoch: input.attemptEpoch,
+                eventKind: input.eventKind,
+                payload: input.payload ?? {},
+                controlActionId: input.controlActionId ?? null,
+                queueItemId: input.queueItemId ?? null,
+                emittedAt: input.emittedAt ?? null,
+            })
+                .returning();
+            if (!event)
+                throw new Error("Failed to append chat generation event");
+            return event;
+        });
+    }
+    async function beginSteerControlAction(input) {
+        return db.transaction(async (tx) => {
+            const existingAction = await tx
+                .select()
+                .from(chatControlActions)
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (existingAction) {
+                const existingItem = await tx
+                    .select()
+                    .from(chatQueuedMessages)
+                    .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.conversationId, input.conversationId), eq(chatQueuedMessages.controlActionId, existingAction.id)))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null);
+                const existingGeneration = existingAction.expectedGenerationId
+                    ? await tx
+                        .select()
+                        .from(chatGenerations)
+                        .where(eq(chatGenerations.id, existingAction.expectedGenerationId))
+                        .limit(1)
+                        .then((rows) => rows[0] ?? null)
+                    : null;
+                if (!existingItem || existingAction.actionKind !== "steer") {
+                    throw conflict("Control action id was already used for a different operation");
+                }
+                return {
+                    action: existingAction,
+                    item: hydrateQueuedMessage(existingItem),
+                    generation: existingGeneration,
+                    idempotent: true,
+                };
+            }
+            await tx.execute(sql `select id from ${chatGenerations} where ${chatGenerations.id} = ${input.expectedGenerationId} for update`);
+            await tx.execute(sql `select id from ${chatQueuedMessages} where ${chatQueuedMessages.id} = ${input.itemId} for update`);
+            const generation = await tx
+                .select()
+                .from(chatGenerations)
+                .where(and(eq(chatGenerations.id, input.expectedGenerationId), eq(chatGenerations.orgId, input.orgId), eq(chatGenerations.conversationId, input.conversationId)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            const generationAcceptsNativeSteer = Boolean(generation && NATIVE_STEER_GENERATION_STATUSES.includes(generation.status));
+            const item = await tx
+                .select()
+                .from(chatQueuedMessages)
+                .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.orgId, input.orgId), eq(chatQueuedMessages.conversationId, input.conversationId), inArray(chatQueuedMessages.status, ["queued", "steer_pending"])))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!item)
+                throw conflict("Queued feedback is no longer steerable");
+            if (item.status === "steer_pending") {
+                const boundAction = item.controlActionId
+                    ? await tx
+                        .select()
+                        .from(chatControlActions)
+                        .where(and(eq(chatControlActions.id, item.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer")))
+                        .limit(1)
+                        .then((rows) => rows[0] ?? null)
+                    : null;
+                if (!boundAction) {
+                    throw conflict("Queued feedback has an unresolved Steer action");
+                }
+                const boundGeneration = boundAction.expectedGenerationId
+                    ? await tx
+                        .select()
+                        .from(chatGenerations)
+                        .where(and(eq(chatGenerations.id, boundAction.expectedGenerationId), eq(chatGenerations.orgId, input.orgId), eq(chatGenerations.conversationId, input.conversationId)))
+                        .limit(1)
+                        .then((rows) => rows[0] ?? null)
+                    : null;
+                return {
+                    action: boundAction,
+                    item: hydrateQueuedMessage(item),
+                    generation: boundGeneration,
+                    idempotent: true,
+                };
+            }
+            if (generationAcceptsNativeSteer && generation && (generation.attemptEpoch !== input.expectedAttemptEpoch
+                || generation.controlVersion !== input.expectedControlVersion)) {
+                throw conflict("The targeted chat generation control version changed");
+            }
+            const now = new Date();
+            if (!generationAcceptsNativeSteer) {
+                const [action] = await tx
+                    .insert(chatControlActions)
+                    .values({
+                    id: input.controlActionId,
+                    orgId: input.orgId,
+                    expectedGenerationId: generation?.id ?? null,
+                    expectedAttemptEpoch: generation?.attemptEpoch ?? null,
+                    expectedControlVersion: generation?.controlVersion ?? null,
+                    actionKind: "steer",
+                    localDisposition: "continuation_pending",
+                    providerDisposition: "not_sent",
+                    providerClientMessageId: input.controlActionId,
+                    resolvedAt: now,
+                })
+                    .returning();
+                if (!action)
+                    throw new Error("Failed to persist Steer continuation action");
+                const [updatedItem] = await tx
+                    .update(chatQueuedMessages)
+                    .set({
+                    status: "continuation_pending",
+                    deliveryIntent: "steer",
+                    deliveryDisposition: "continuation_pending",
+                    controlActionId: action.id,
+                    requestActor: item.requestActor ?? input.requestActor ?? null,
+                    activeGenerationId: generation?.id ?? item.activeGenerationId,
+                    attemptEpoch: generation?.attemptEpoch ?? item.attemptEpoch,
+                    providerClientMessageId: action.providerClientMessageId,
+                    reconciliationReason: generation ? "target_generation_terminal" : "target_generation_missing",
+                    lastDeliveryReason: null,
+                    version: sql `${chatQueuedMessages.version} + 1`,
+                    updatedAt: now,
+                })
+                    .where(and(eq(chatQueuedMessages.id, item.id), eq(chatQueuedMessages.version, item.version)))
+                    .returning();
+                if (!updatedItem)
+                    throw conflict("Queued feedback changed while continuation was being scheduled");
+                return {
+                    action,
+                    item: hydrateQueuedMessage(updatedItem),
+                    generation,
+                    idempotent: false,
+                };
+            }
+            if (!generation)
+                throw new Error("Expected a native Steer generation");
+            const appliedControlVersion = generation.controlVersion + 1;
+            const [action] = await tx
+                .insert(chatControlActions)
+                .values({
+                id: input.controlActionId,
+                orgId: input.orgId,
+                expectedGenerationId: generation.id,
+                expectedAttemptEpoch: generation.attemptEpoch,
+                expectedControlVersion: generation.controlVersion,
+                appliedControlVersion,
+                actionKind: "steer",
+                localDisposition: "pending",
+                providerDisposition: "not_sent",
+                controlOwnerToken: generation.controlOwnerToken,
+                providerClientMessageId: input.controlActionId,
+            })
+                .returning();
+            if (!action)
+                throw new Error("Failed to create chat Steer control action");
+            const [updatedGeneration] = await tx
+                .update(chatGenerations)
+                .set({ controlVersion: appliedControlVersion, updatedAt: now })
+                .where(and(eq(chatGenerations.id, generation.id), eq(chatGenerations.controlVersion, generation.controlVersion), eq(chatGenerations.attemptEpoch, generation.attemptEpoch)))
+                .returning();
+            if (!updatedGeneration)
+                throw conflict("The targeted chat generation control version changed");
+            const [updatedItem] = await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: "steer_pending",
+                deliveryIntent: "steer",
+                deliveryDisposition: "pending",
+                controlActionId: action.id,
+                requestActor: item.requestActor ?? input.requestActor ?? null,
+                activeGenerationId: generation.id,
+                attemptEpoch: generation.attemptEpoch,
+                providerClientMessageId: action.providerClientMessageId,
+                deliveryAttempts: sql `${chatQueuedMessages.deliveryAttempts} + 1`,
+                lastAttemptAt: now,
+                lastDeliveryReason: null,
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.id, item.id), eq(chatQueuedMessages.version, item.version)))
+                .returning();
+            if (!updatedItem)
+                throw conflict("Queued feedback changed while Steer was being accepted");
+            return {
+                action,
+                item: hydrateQueuedMessage(updatedItem),
+                generation: updatedGeneration,
+                idempotent: false,
+            };
+        });
+    }
+    async function resolveSteerControlAction(input) {
+        const now = new Date();
+        return db.transaction(async (tx) => {
+            await tx.execute(sql `
+        select ${chatControlActions.id}
+        from ${chatControlActions}
+        where ${chatControlActions.id} = ${input.controlActionId}
+          and ${chatControlActions.orgId} = ${input.orgId}
+        for update
+      `);
+            await tx.execute(sql `
+        select ${chatQueuedMessages.id}
+        from ${chatQueuedMessages}
+        where ${chatQueuedMessages.id} = ${input.itemId}
+          and ${chatQueuedMessages.orgId} = ${input.orgId}
+          and ${chatQueuedMessages.conversationId} = ${input.conversationId}
+        for update
+      `);
+            const existingAction = await tx
+                .select()
+                .from(chatControlActions)
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer")))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            const existingItem = await tx
+                .select()
+                .from(chatQueuedMessages)
+                .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.orgId, input.orgId), eq(chatQueuedMessages.conversationId, input.conversationId), eq(chatQueuedMessages.controlActionId, input.controlActionId)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!existingAction)
+                throw notFound("Chat Steer control action not found");
+            if (!existingItem)
+                throw notFound("Queued Steer feedback not found");
+            const allowedCurrentStatuses = input.status === "accepted_current"
+                ? ["steer_pending", "acceptance_unknown", "accepted_current"]
+                : input.status === "acceptance_unknown"
+                    ? ["steer_pending", "acceptance_unknown"]
+                    : input.status === "continuation_pending"
+                        ? ["steer_pending", "acceptance_unknown", "continuation_pending"]
+                        : input.status === "steer_pending"
+                            ? ["steer_pending"]
+                            : ["steer_pending", "acceptance_unknown", "continuation_pending", "failed_actionable"];
+            const transitionAllowed = allowedCurrentStatuses.includes(existingItem.status);
+            const preserveAcknowledgement = existingAction.providerDisposition === "acknowledged"
+                && input.providerDisposition !== "acknowledged";
+            const providerDisposition = preserveAcknowledgement
+                ? existingAction.providerDisposition
+                : input.providerDisposition;
+            const [action] = await tx
+                .update(chatControlActions)
+                .set({
+                localDisposition: transitionAllowed ? input.disposition : existingAction.localDisposition,
+                providerDisposition,
+                providerThreadId: input.providerThreadId ?? existingAction.providerThreadId,
+                providerTurnId: input.providerTurnId ?? existingAction.providerTurnId,
+                providerEvidence: input.providerEvidence ?? existingAction.providerEvidence,
+                lastError: transitionAllowed ? input.reason ?? null : existingAction.lastError,
+                providerSentAt: providerDisposition === "not_sent"
+                    ? null
+                    : existingAction.providerSentAt ?? now,
+                providerAcknowledgedAt: providerDisposition === "acknowledged"
+                    ? existingAction.providerAcknowledgedAt ?? now
+                    : existingAction.providerAcknowledgedAt,
+                resolvedAt: transitionAllowed
+                    ? input.disposition === "pending" ? null : now
+                    : existingAction.resolvedAt,
+                updatedAt: now,
+            })
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer")))
+                .returning();
+            if (!action)
+                throw notFound("Chat Steer control action not found");
+            if (!transitionAllowed) {
+                return { action, item: hydrateQueuedMessage(existingItem), applied: false };
+            }
+            const [item] = await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: input.status,
+                deliveryDisposition: input.disposition,
+                providerThreadId: input.providerThreadId ?? existingItem.providerThreadId,
+                providerTurnId: input.providerTurnId ?? existingItem.providerTurnId,
+                providerEvidence: input.providerEvidence ?? existingItem.providerEvidence,
+                reconciliationReason: input.reason ?? null,
+                lastDeliveryReason: input.reason ?? null,
+                steeredAt: input.status === "accepted_current" ? now : existingItem.steeredAt,
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.id, existingItem.id), eq(chatQueuedMessages.status, existingItem.status), eq(chatQueuedMessages.version, existingItem.version)))
+                .returning();
+            if (!item)
+                throw conflict("Queued Steer feedback changed while provider evidence was resolving");
+            return { action, item: hydrateQueuedMessage(item), applied: true };
+        });
+    }
+    async function claimSteerProviderSend(input) {
+        return db.transaction(async (tx) => {
+            const existingAction = await tx
+                .select()
+                .from(chatControlActions)
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer")))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!existingAction
+                || existingAction.localDisposition !== "pending"
+                || existingAction.providerDisposition !== "not_sent") {
+                return null;
+            }
+            const generation = existingAction.expectedGenerationId
+                ? await tx
+                    .select()
+                    .from(chatGenerations)
+                    .where(and(eq(chatGenerations.id, existingAction.expectedGenerationId), eq(chatGenerations.orgId, input.orgId)))
+                    .limit(1)
+                    .for("update")
+                    .then((rows) => rows[0] ?? null)
+                : null;
+            const leaseIsCurrent = generation
+                ? await tx
+                    .select({
+                    value: sql `${chatGenerations.controlLeaseExpiresAt} > clock_timestamp()`,
+                })
+                    .from(chatGenerations)
+                    .where(eq(chatGenerations.id, generation.id))
+                    .limit(1)
+                    .then((rows) => rows[0]?.value === true)
+                : false;
+            const now = new Date();
+            const generationFenceMatches = Boolean(generation
+                && NATIVE_STEER_GENERATION_STATUSES.includes(generation.status)
+                && generation.controlState === "ready"
+                && generation.runtimeTerminalAt === null
+                && Boolean(generation.controlOwnerToken)
+                && generation.attemptEpoch === existingAction.expectedAttemptEpoch
+                && generation.controlVersion === existingAction.appliedControlVersion
+                && generation.controlOwnerToken === existingAction.controlOwnerToken
+                && leaseIsCurrent);
+            if (!generationFenceMatches) {
+                await tx.execute(sql `
+          select ${chatControlActions.id}
+          from ${chatControlActions}
+          where ${chatControlActions.id} = ${input.controlActionId}
+            and ${chatControlActions.orgId} = ${input.orgId}
+          for update
+        `);
+                const queueItem = await tx
+                    .select()
+                    .from(chatQueuedMessages)
+                    .where(and(eq(chatQueuedMessages.controlActionId, input.controlActionId), eq(chatQueuedMessages.orgId, input.orgId)))
+                    .limit(1)
+                    .for("update")
+                    .then((rows) => rows[0] ?? null);
+                if (!queueItem)
+                    throw conflict("Queued Steer feedback disappeared before provider send");
+                const reason = generation?.stopRequestedAt
+                    || generation?.status === "stop_requested"
+                    || generation?.status === "stopping"
+                    ? "stop_cutoff_won_before_provider_send"
+                    : "generation_fence_changed_before_provider_send";
+                const [action] = await tx
+                    .update(chatControlActions)
+                    .set({
+                    localDisposition: "continuation_pending",
+                    providerDisposition: "not_sent",
+                    providerSentAt: null,
+                    lastError: reason,
+                    resolvedAt: now,
+                    updatedAt: now,
+                })
+                    .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer"), eq(chatControlActions.localDisposition, "pending"), eq(chatControlActions.providerDisposition, "not_sent")))
+                    .returning();
+                if (!action)
+                    return null;
+                const [item] = await tx
+                    .update(chatQueuedMessages)
+                    .set({
+                    status: "continuation_pending",
+                    deliveryDisposition: "continuation_pending",
+                    reconciliationReason: reason,
+                    lastDeliveryReason: null,
+                    version: sql `${chatQueuedMessages.version} + 1`,
+                    updatedAt: now,
+                })
+                    .where(and(eq(chatQueuedMessages.id, queueItem.id), eq(chatQueuedMessages.status, "steer_pending"), eq(chatQueuedMessages.version, queueItem.version)))
+                    .returning();
+                if (!item)
+                    throw conflict("Queued Steer feedback changed before provider send fallback");
+                return {
+                    sendDenied: true,
+                    reason,
+                    action,
+                    item: hydrateQueuedMessage(item),
+                };
+            }
+            const [action] = await tx
+                .update(chatControlActions)
+                .set({
+                providerDisposition: "sent",
+                providerSentAt: now,
+                updatedAt: now,
+            })
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer"), eq(chatControlActions.localDisposition, "pending"), eq(chatControlActions.providerDisposition, "not_sent"), eq(chatControlActions.expectedGenerationId, generation.id), eq(chatControlActions.expectedAttemptEpoch, generation.attemptEpoch), eq(chatControlActions.appliedControlVersion, generation.controlVersion), eq(chatControlActions.controlOwnerToken, generation.controlOwnerToken)))
+                .returning();
+            return action ?? null;
+        });
+    }
+    async function releaseSteerProviderSendClaim(input) {
+        const now = new Date();
+        return db.transaction(async (tx) => {
+            await tx.execute(sql `
+        select ${chatControlActions.id}
+        from ${chatControlActions}
+        where ${chatControlActions.id} = ${input.controlActionId}
+          and ${chatControlActions.orgId} = ${input.orgId}
+        for update
+      `);
+            const existingAction = await tx
+                .select()
+                .from(chatControlActions)
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer")))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!existingAction
+                || existingAction.providerDisposition !== "sent"
+                || existingAction.providerAcknowledgedAt) {
+                return null;
+            }
+            await tx.execute(sql `
+        select ${chatQueuedMessages.id}
+        from ${chatQueuedMessages}
+        where ${chatQueuedMessages.controlActionId} = ${input.controlActionId}
+        for update
+      `);
+            const [action] = await tx
+                .update(chatControlActions)
+                .set({
+                localDisposition: "pending",
+                providerDisposition: "not_sent",
+                providerSentAt: null,
+                lastError: input.reason,
+                resolvedAt: null,
+                updatedAt: now,
+            })
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId), eq(chatControlActions.actionKind, "steer"), eq(chatControlActions.providerDisposition, "sent"), isNull(chatControlActions.providerAcknowledgedAt)))
+                .returning();
+            if (!action)
+                return null;
+            await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: "steer_pending",
+                deliveryDisposition: "pending",
+                reconciliationReason: input.reason,
+                lastDeliveryReason: input.reason,
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.controlActionId, input.controlActionId), inArray(chatQueuedMessages.status, ["steer_pending", "acceptance_unknown"])));
+            return action;
+        });
+    }
     async function createQueuedMessage(input) {
         const payload = {
             ...input.payload,
@@ -545,6 +1331,7 @@ export function chatService(db) {
                         clientMutationId: input.clientMutationId,
                         position: Number(positionRow?.nextPosition ?? 1),
                         payload,
+                        requestActor: input.requestActor ?? null,
                         expectedGenerationId: input.expectedGenerationId ?? null,
                     })
                         .returning();
@@ -610,6 +1397,99 @@ export function chatService(db) {
             throw conflict("Queued message was changed or is no longer cancellable");
         return hydrateQueuedMessage(row);
     }
+    async function scheduleSteerContinuation(input) {
+        return db.transaction(async (tx) => {
+            const existingAction = await tx
+                .select()
+                .from(chatControlActions)
+                .where(and(eq(chatControlActions.id, input.controlActionId), eq(chatControlActions.orgId, input.orgId)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (existingAction) {
+                const existingItem = await tx
+                    .select()
+                    .from(chatQueuedMessages)
+                    .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.orgId, input.orgId), eq(chatQueuedMessages.conversationId, input.conversationId), eq(chatQueuedMessages.controlActionId, existingAction.id)))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null);
+                if (!existingItem || existingAction.actionKind !== "steer") {
+                    throw conflict("Control action id was already used for a different operation");
+                }
+                return {
+                    action: existingAction,
+                    item: hydrateQueuedMessage(existingItem),
+                    idempotent: true,
+                };
+            }
+            await tx.execute(sql `select id from ${chatQueuedMessages} where ${chatQueuedMessages.id} = ${input.itemId} for update`);
+            const item = await tx
+                .select()
+                .from(chatQueuedMessages)
+                .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.orgId, input.orgId), eq(chatQueuedMessages.conversationId, input.conversationId), inArray(chatQueuedMessages.status, ["queued", "steer_pending", "continuation_pending"])))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!item)
+                throw conflict("Queued feedback is no longer schedulable");
+            const targetGenerationId = item.expectedGenerationId ?? item.activeGenerationId;
+            const targetGeneration = targetGenerationId
+                ? await tx
+                    .select()
+                    .from(chatGenerations)
+                    .where(and(eq(chatGenerations.id, targetGenerationId), eq(chatGenerations.orgId, input.orgId), eq(chatGenerations.conversationId, input.conversationId)))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null)
+                : await tx
+                    .select()
+                    .from(chatGenerations)
+                    .where(and(eq(chatGenerations.orgId, input.orgId), eq(chatGenerations.conversationId, input.conversationId)))
+                    .orderBy(desc(chatGenerations.startedAt), desc(chatGenerations.createdAt))
+                    .limit(1)
+                    .then((rows) => rows[0] ?? null);
+            const now = new Date();
+            const [action] = await tx
+                .insert(chatControlActions)
+                .values({
+                id: input.controlActionId,
+                orgId: input.orgId,
+                expectedGenerationId: targetGeneration?.id ?? null,
+                expectedAttemptEpoch: targetGeneration?.attemptEpoch ?? null,
+                expectedControlVersion: targetGeneration?.controlVersion ?? null,
+                actionKind: "steer",
+                localDisposition: "continuation_pending",
+                providerDisposition: "not_sent",
+                providerClientMessageId: input.controlActionId,
+                resolvedAt: now,
+            })
+                .returning();
+            if (!action)
+                throw new Error("Failed to persist Steer continuation action");
+            const [updatedItem] = await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: "continuation_pending",
+                deliveryIntent: "steer",
+                deliveryDisposition: "continuation_pending",
+                controlActionId: action.id,
+                requestActor: item.requestActor ?? input.requestActor ?? null,
+                activeGenerationId: targetGeneration?.id ?? item.activeGenerationId,
+                attemptEpoch: targetGeneration?.attemptEpoch ?? item.attemptEpoch,
+                providerClientMessageId: action.providerClientMessageId,
+                reconciliationReason: targetGeneration ? "target_generation_terminal" : "no_active_generation",
+                lastDeliveryReason: null,
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.id, item.id), eq(chatQueuedMessages.version, item.version)))
+                .returning();
+            if (!updatedItem)
+                throw conflict("Queued feedback changed while continuation was being scheduled");
+            return {
+                action,
+                item: hydrateQueuedMessage(updatedItem),
+                idempotent: false,
+            };
+        });
+    }
     async function markQueuedMessageSteerFallback(input) {
         const now = new Date();
         const [row] = await db
@@ -629,6 +1509,342 @@ export function chatService(db) {
             throw conflict("Queued message was changed or is no longer steerable");
         return hydrateQueuedMessage(row);
     }
+    async function claimNextServerQueuedMessage(input) {
+        const now = input.now ?? new Date();
+        const leaseExpiresAt = new Date(now.getTime() + input.leaseMs);
+        return db.transaction(async (tx) => {
+            const batchSize = 25;
+            let scanOffset = 0;
+            while (true) {
+                const candidates = await tx
+                    .select()
+                    .from(chatQueuedMessages)
+                    .where(and(inArray(chatQueuedMessages.status, ["continuation_pending", "steer_pending", "queued"]), sql `jsonb_typeof(${chatQueuedMessages.requestActor}) = 'object'`, or(isNull(chatQueuedMessages.deliveryLeaseExpiresAt), lt(chatQueuedMessages.deliveryLeaseExpiresAt, now)), sql `${chatQueuedMessages.status} <> 'steer_pending' or coalesce((
+            select steer_action.provider_disposition
+            from ${chatControlActions} as steer_action
+            where steer_action.id = ${chatQueuedMessages.controlActionId}
+            limit 1
+          ), 'not_sent') in ('not_sent', 'rejected')`))
+                    .orderBy(sql `case
+            when ${chatQueuedMessages.status} = 'continuation_pending' then 0
+            when ${chatQueuedMessages.status} = 'steer_pending' then 1
+            else 2
+          end`, asc(chatQueuedMessages.position), asc(chatQueuedMessages.createdAt))
+                    .limit(batchSize)
+                    .offset(scanOffset)
+                    .for("update", { skipLocked: true });
+                for (const candidate of candidates) {
+                    if (!candidate.requestActor || typeof candidate.requestActor !== "object" || Array.isArray(candidate.requestActor)) {
+                        continue;
+                    }
+                    const latestGeneration = await tx
+                        .select()
+                        .from(chatGenerations)
+                        .where(and(eq(chatGenerations.orgId, candidate.orgId), eq(chatGenerations.conversationId, candidate.conversationId)))
+                        .orderBy(desc(chatGenerations.startedAt), desc(chatGenerations.createdAt))
+                        .limit(1)
+                        .then((rows) => rows[0] ?? null);
+                    const isSteer = candidate.deliveryIntent === "steer"
+                        || candidate.status === "steer_pending"
+                        || candidate.status === "continuation_pending";
+                    if (latestGeneration
+                        && ACTIVE_CHAT_GENERATION_STATUSES.some((status) => status === latestGeneration.status)) {
+                        continue;
+                    }
+                    if (candidate.status === "queued"
+                        && latestGeneration
+                        && latestGeneration.status !== "completed") {
+                        continue;
+                    }
+                    if (isSteer
+                        && latestGeneration
+                        && ["failed", "control_lost", "interrupted_unverified"].includes(latestGeneration.status)) {
+                        await tx
+                            .update(chatQueuedMessages)
+                            .set({
+                            status: "failed_actionable",
+                            deliveryDisposition: "failed_actionable",
+                            reconciliationReason: `prior_generation_${latestGeneration.status}`,
+                            lastDeliveryReason: `prior_generation_${latestGeneration.status}`,
+                            updatedAt: now,
+                            version: sql `${chatQueuedMessages.version} + 1`,
+                        })
+                            .where(eq(chatQueuedMessages.id, candidate.id));
+                        if (candidate.controlActionId) {
+                            await tx
+                                .update(chatControlActions)
+                                .set({
+                                localDisposition: "failed_actionable",
+                                lastError: `prior_generation_${latestGeneration.status}`,
+                                resolvedAt: now,
+                                updatedAt: now,
+                            })
+                                .where(eq(chatControlActions.id, candidate.controlActionId));
+                        }
+                        continue;
+                    }
+                    const generationId = randomUUID();
+                    const leaseToken = randomUUID();
+                    const leaseEpoch = candidate.deliveryLeaseEpoch + 1;
+                    await tx.insert(chatGenerations).values({
+                        id: generationId,
+                        orgId: candidate.orgId,
+                        conversationId: candidate.conversationId,
+                        status: "active",
+                        attemptEpoch: 0,
+                        controlVersion: 0,
+                        controlState: "unregistered",
+                        controlOwnerToken: leaseToken,
+                        controlLeaseExpiresAt: new Date(now.getTime() + CHAT_GENERATION_CONTROL_LEASE_MS),
+                        startedAt: now,
+                        createdAt: now,
+                        updatedAt: now,
+                    });
+                    let userMessageId = candidate.continuationMessageId;
+                    if (userMessageId) {
+                        const existingMessage = await tx
+                            .select({ id: chatMessages.id })
+                            .from(chatMessages)
+                            .where(and(eq(chatMessages.id, userMessageId), eq(chatMessages.orgId, candidate.orgId), eq(chatMessages.conversationId, candidate.conversationId), eq(chatMessages.role, "user")))
+                            .limit(1)
+                            .then((rows) => rows[0] ?? null);
+                        if (!existingMessage)
+                            userMessageId = null;
+                    }
+                    if (!userMessageId) {
+                        userMessageId = randomUUID();
+                        await tx.insert(chatMessages).values({
+                            id: userMessageId,
+                            orgId: candidate.orgId,
+                            conversationId: candidate.conversationId,
+                            role: "user",
+                            kind: "message",
+                            status: "completed",
+                            body: normalizeQueuedPayload(candidate.payload).body,
+                            structuredPayload: null,
+                            chatTurnId: randomUUID(),
+                            turnVariant: 0,
+                            createdAt: now,
+                            updatedAt: now,
+                        });
+                        await tx
+                            .update(chatConversations)
+                            .set({ lastMessageAt: now, updatedAt: now })
+                            .where(and(eq(chatConversations.id, candidate.conversationId), eq(chatConversations.orgId, candidate.orgId)));
+                    }
+                    const [claimed] = await tx
+                        .update(chatQueuedMessages)
+                        .set({
+                        status: isSteer ? "running_next" : "dequeue_claimed",
+                        deliveryDisposition: isSteer ? "running_next" : null,
+                        continuationGenerationId: generationId,
+                        continuationMessageId: userMessageId,
+                        sourceMessageId: userMessageId,
+                        deliveredMessageId: userMessageId,
+                        deliveryLeaseToken: leaseToken,
+                        deliveryLeaseEpoch: leaseEpoch,
+                        deliveryLeaseOwner: input.workerId,
+                        deliveryLeaseExpiresAt: leaseExpiresAt,
+                        dequeuedAt: now,
+                        deliveryAttempts: sql `${chatQueuedMessages.deliveryAttempts} + 1`,
+                        lastAttemptAt: now,
+                        lastDeliveryReason: null,
+                        reconciliationReason: "server_claimed",
+                        version: sql `${chatQueuedMessages.version} + 1`,
+                        updatedAt: now,
+                    })
+                        .where(and(eq(chatQueuedMessages.id, candidate.id), eq(chatQueuedMessages.version, candidate.version)))
+                        .returning();
+                    if (!claimed)
+                        throw conflict("Queued continuation changed while being claimed");
+                    if (candidate.controlActionId) {
+                        await tx
+                            .update(chatControlActions)
+                            .set({
+                            localDisposition: "running_next",
+                            resolvedAt: null,
+                            updatedAt: now,
+                        })
+                            .where(and(eq(chatControlActions.id, candidate.controlActionId), eq(chatControlActions.orgId, candidate.orgId)));
+                    }
+                    return {
+                        item: hydrateQueuedMessage(claimed),
+                        generationId,
+                        userMessageId,
+                        leaseToken,
+                        leaseEpoch,
+                    };
+                }
+                if (candidates.length < batchSize)
+                    return null;
+                scanOffset += candidates.length;
+            }
+        });
+    }
+    async function renewServerQueuedMessageClaim(input) {
+        const now = input.now ?? new Date();
+        const [row] = await db
+            .update(chatQueuedMessages)
+            .set({
+            deliveryLeaseExpiresAt: new Date(now.getTime() + input.leaseMs),
+            updatedAt: now,
+        })
+            .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.continuationGenerationId, input.generationId), eq(chatQueuedMessages.deliveryLeaseToken, input.leaseToken), eq(chatQueuedMessages.deliveryLeaseEpoch, input.leaseEpoch), inArray(chatQueuedMessages.status, SERVER_QUEUE_RUNNING_STATUSES)))
+            .returning({ id: chatQueuedMessages.id });
+        return Boolean(row);
+    }
+    async function completeServerQueuedMessageDelivery(input) {
+        const now = new Date();
+        return db.transaction(async (tx) => {
+            const item = await tx
+                .select()
+                .from(chatQueuedMessages)
+                .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.continuationGenerationId, input.generationId), eq(chatQueuedMessages.deliveryLeaseToken, input.leaseToken), eq(chatQueuedMessages.deliveryLeaseEpoch, input.leaseEpoch), inArray(chatQueuedMessages.status, SERVER_QUEUE_RUNNING_STATUSES)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!item)
+                return null;
+            const isSteer = item.deliveryIntent === "steer" || item.status === "running_next";
+            const succeeded = input.status === "completed";
+            const nextStatus = succeeded
+                ? (isSteer ? "delivered" : "completed")
+                : "failed_actionable";
+            const nextDisposition = succeeded
+                ? (isSteer ? "delivered" : null)
+                : "failed_actionable";
+            const [updated] = await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: nextStatus,
+                deliveryDisposition: nextDisposition,
+                deliveryLeaseToken: null,
+                deliveryLeaseOwner: null,
+                deliveryLeaseExpiresAt: null,
+                lastDeliveryReason: succeeded ? null : (input.reason ?? input.status),
+                reconciliationReason: succeeded ? null : (input.reason ?? input.status),
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.id, item.id), eq(chatQueuedMessages.version, item.version)))
+                .returning();
+            if (item.controlActionId) {
+                await tx
+                    .update(chatControlActions)
+                    .set({
+                    localDisposition: nextDisposition ?? (succeeded ? "delivered" : "failed_actionable"),
+                    lastError: succeeded ? null : (input.reason ?? input.status),
+                    resolvedAt: now,
+                    updatedAt: now,
+                })
+                    .where(eq(chatControlActions.id, item.controlActionId));
+            }
+            return updated ? hydrateQueuedMessage(updated) : null;
+        });
+    }
+    async function releaseServerQueuedMessageClaim(input) {
+        const now = new Date();
+        return db.transaction(async (tx) => {
+            const item = await tx
+                .select()
+                .from(chatQueuedMessages)
+                .where(and(eq(chatQueuedMessages.id, input.itemId), eq(chatQueuedMessages.continuationGenerationId, input.generationId), eq(chatQueuedMessages.deliveryLeaseToken, input.leaseToken), eq(chatQueuedMessages.deliveryLeaseEpoch, input.leaseEpoch), inArray(chatQueuedMessages.status, SERVER_QUEUE_RUNNING_STATUSES)))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            if (!item)
+                return null;
+            const generation = await tx
+                .select()
+                .from(chatGenerations)
+                .where(eq(chatGenerations.id, input.generationId))
+                .limit(1)
+                .then((rows) => rows[0] ?? null);
+            const providerMayHaveStarted = Boolean(generation && (generation.attemptEpoch > 0
+                || generation.status === "starting"
+                || generation.status === "running"
+                || generation.status === "tool_busy"
+                || generation.status === "closing"));
+            const isSteer = item.deliveryIntent === "steer" || item.status === "running_next";
+            const nextStatus = providerMayHaveStarted
+                ? (isSteer ? "acceptance_unknown" : "failed_actionable")
+                : (isSteer ? "continuation_pending" : "queued");
+            const nextDisposition = providerMayHaveStarted
+                ? (isSteer ? "acceptance_unknown" : "failed_actionable")
+                : (isSteer ? "continuation_pending" : null);
+            const [updated] = await tx
+                .update(chatQueuedMessages)
+                .set({
+                status: nextStatus,
+                deliveryDisposition: nextDisposition,
+                continuationGenerationId: null,
+                deliveryLeaseToken: null,
+                deliveryLeaseOwner: null,
+                deliveryLeaseExpiresAt: null,
+                lastDeliveryReason: input.reason,
+                reconciliationReason: input.reason,
+                version: sql `${chatQueuedMessages.version} + 1`,
+                updatedAt: now,
+            })
+                .where(and(eq(chatQueuedMessages.id, item.id), eq(chatQueuedMessages.version, item.version)))
+                .returning();
+            if (generation) {
+                await tx
+                    .update(chatGenerations)
+                    .set({
+                    status: "aborted",
+                    terminalReason: input.reason,
+                    controlState: providerMayHaveStarted ? "control_lost" : "terminal",
+                    runtimeTerminalAt: now,
+                    completedAt: now,
+                    updatedAt: now,
+                })
+                    .where(eq(chatGenerations.id, generation.id));
+            }
+            if (item.controlActionId) {
+                await tx
+                    .update(chatControlActions)
+                    .set({
+                    localDisposition: nextDisposition ?? "pending",
+                    providerDisposition: providerMayHaveStarted ? "unverified" : "not_sent",
+                    lastError: input.reason,
+                    resolvedAt: providerMayHaveStarted ? now : null,
+                    updatedAt: now,
+                })
+                    .where(eq(chatControlActions.id, item.controlActionId));
+            }
+            return updated ? hydrateQueuedMessage(updated) : null;
+        });
+    }
+    async function recoverExpiredServerQueueClaims(now = new Date()) {
+        const expired = await db
+            .select({
+            id: chatQueuedMessages.id,
+            generationId: chatQueuedMessages.continuationGenerationId,
+            leaseToken: chatQueuedMessages.deliveryLeaseToken,
+            leaseEpoch: chatQueuedMessages.deliveryLeaseEpoch,
+        })
+            .from(chatQueuedMessages)
+            .where(and(inArray(chatQueuedMessages.status, SERVER_QUEUE_RUNNING_STATUSES), lt(chatQueuedMessages.deliveryLeaseExpiresAt, now)));
+        let requeued = 0;
+        let ambiguous = 0;
+        for (const row of expired) {
+            if (!row.generationId || !row.leaseToken)
+                continue;
+            const recovered = await releaseServerQueuedMessageClaim({
+                itemId: row.id,
+                generationId: row.generationId,
+                leaseToken: row.leaseToken,
+                leaseEpoch: row.leaseEpoch,
+                reason: "server_continuation_lease_expired",
+            });
+            if (!recovered)
+                continue;
+            if (recovered.status === "continuation_pending" || recovered.status === "queued")
+                requeued += 1;
+            else
+                ambiguous += 1;
+        }
+        return { inspected: expired.length, requeued, ambiguous };
+    }
     async function claimNextQueuedMessage(conversationId) {
         await reclaimStaleQueuedMessageClaims(conversationId);
         const now = new Date();
@@ -770,6 +1986,16 @@ export function chatService(db) {
         if (status !== "all") {
             conditions.push(eq(chatConversations.status, status));
         }
+        if (options?.projectId) {
+            conditions.push(sql `EXISTS (
+          SELECT 1
+          FROM ${chatContextLinks}
+          WHERE ${chatContextLinks.conversationId} = ${chatConversations.id}
+            AND ${chatContextLinks.orgId} = ${orgId}
+            AND ${chatContextLinks.entityType} = 'project'
+            AND ${chatContextLinks.entityId} = ${options.projectId}
+        )`);
+        }
         if (hasSearch) {
             conditions.push(sql `(
           ${chatConversations.title} ILIKE ${containsPattern} ESCAPE '\\'
@@ -990,6 +2216,28 @@ export function chatService(db) {
     }
     async function forkConversation(input) {
         const created = await db.transaction(async (tx) => {
+            const initialSource = await tx
+                .select()
+                .from(chatConversations)
+                .where(and(eq(chatConversations.id, input.sourceConversationId), eq(chatConversations.orgId, input.orgId)))
+                .then((rows) => rows[0] ?? null);
+            if (!initialSource)
+                throw notFound("Chat conversation not found");
+            const initialRootConversationId = initialSource.forkRootConversationId ?? initialSource.id;
+            await tx.execute(sql `
+        SELECT ${chatConversations.id}
+        FROM ${chatConversations}
+        WHERE ${chatConversations.id} = ${initialRootConversationId}
+        FOR UPDATE
+      `);
+            if (initialSource.id !== initialRootConversationId) {
+                await tx.execute(sql `
+          SELECT ${chatConversations.id}
+          FROM ${chatConversations}
+          WHERE ${chatConversations.id} = ${initialSource.id}
+          FOR UPDATE
+        `);
+            }
             const source = await tx
                 .select()
                 .from(chatConversations)
@@ -998,6 +2246,12 @@ export function chatService(db) {
             if (!source)
                 throw notFound("Chat conversation not found");
             const rootConversationId = source.forkRootConversationId ?? source.id;
+            const familyTitles = await tx
+                .select({ title: chatConversations.title })
+                .from(chatConversations)
+                .where(and(eq(chatConversations.orgId, input.orgId), or(eq(chatConversations.id, rootConversationId), eq(chatConversations.forkRootConversationId, rootConversationId))))
+                .then((rows) => rows.map((row) => row.title));
+            const childTitle = input.title?.trim() || nextForkTitle(source, familyTitles);
             const messageConditions = [
                 eq(chatMessages.conversationId, source.id),
                 eq(chatMessages.orgId, input.orgId),
@@ -1028,7 +2282,7 @@ export function chatService(db) {
                 .values({
                 orgId: input.orgId,
                 status: "active",
-                title: input.title?.trim() || source.title,
+                title: childTitle,
                 summary: source.summary,
                 preferredAgentId: source.preferredAgentId,
                 routedAgentId: source.routedAgentId,
@@ -1073,22 +2327,77 @@ export function chatService(db) {
                 ? messagesToCopy.slice(0, messagesToCopy.findIndex((message) => message.id === input.sourceMessageId) + 1)
                 : messagesToCopy;
             if (forkMessages.length > 0) {
-                await tx.insert(chatMessages).values(forkMessages.map((message) => ({
-                    orgId: input.orgId,
-                    conversationId: child.id,
-                    role: message.role,
-                    kind: message.kind,
-                    status: message.status === "streaming" ? "interrupted" : message.status,
-                    body: message.body,
-                    structuredPayload: null,
-                    approvalId: null,
-                    runId: null,
-                    replyingAgentId: message.replyingAgentId,
-                    chatTurnId: null,
-                    turnVariant: 0,
-                    createdAt: message.createdAt,
-                    updatedAt: message.updatedAt,
-                })));
+                for (const message of forkMessages) {
+                    const copiedMessageId = randomUUID();
+                    const visualMappings = chatInlineVisualMappingsFromStructuredPayload(message.structuredPayload);
+                    const readyAttachmentIds = visualMappings
+                        .filter((mapping) => mapping.status === "ready")
+                        .map((mapping) => mapping.attachmentId);
+                    const copiedAttachmentIdBySourceId = new Map();
+                    const pendingVisualAttachments = [];
+                    if (readyAttachmentIds.length > 0) {
+                        const sourceVisualAttachments = await tx
+                            .select({
+                            id: chatAttachments.id,
+                            assetId: chatAttachments.assetId,
+                            contentType: assets.contentType,
+                            createdByAgentId: assets.createdByAgentId,
+                            createdByUserId: assets.createdByUserId,
+                        })
+                            .from(chatAttachments)
+                            .innerJoin(assets, eq(chatAttachments.assetId, assets.id))
+                            .where(and(eq(chatAttachments.conversationId, source.id), eq(chatAttachments.messageId, message.id), inArray(chatAttachments.id, readyAttachmentIds)));
+                        const safeVisualAttachments = sourceVisualAttachments.filter((attachment) => attachment.contentType === "text/html"
+                            && Boolean(attachment.createdByAgentId)
+                            && !attachment.createdByUserId);
+                        if (safeVisualAttachments.length > 0) {
+                            pendingVisualAttachments.push(...safeVisualAttachments.map((attachment) => {
+                                const copiedAttachmentId = randomUUID();
+                                copiedAttachmentIdBySourceId.set(attachment.id, copiedAttachmentId);
+                                return {
+                                    id: copiedAttachmentId,
+                                    orgId: input.orgId,
+                                    conversationId: child.id,
+                                    messageId: copiedMessageId,
+                                    assetId: attachment.assetId,
+                                };
+                            }));
+                        }
+                    }
+                    const copiedVisualMappings = visualMappings.map((mapping) => {
+                        if (mapping.status === "unavailable")
+                            return mapping;
+                        const copiedAttachmentId = copiedAttachmentIdBySourceId.get(mapping.attachmentId);
+                        return copiedAttachmentId
+                            ? { ...mapping, attachmentId: copiedAttachmentId }
+                            : {
+                                directiveIndex: mapping.directiveIndex,
+                                file: mapping.file,
+                                status: "unavailable",
+                                reason: "fork_source_missing",
+                            };
+                    });
+                    await tx.insert(chatMessages).values({
+                        id: copiedMessageId,
+                        orgId: input.orgId,
+                        conversationId: child.id,
+                        role: message.role,
+                        kind: message.kind,
+                        status: message.status === "streaming" ? "interrupted" : message.status,
+                        body: message.body,
+                        structuredPayload: copiedVisualMappings.length > 0 ? { inlineVisuals: copiedVisualMappings } : null,
+                        approvalId: null,
+                        runId: null,
+                        replyingAgentId: message.replyingAgentId,
+                        chatTurnId: null,
+                        turnVariant: 0,
+                        createdAt: message.createdAt,
+                        updatedAt: message.updatedAt,
+                    });
+                    if (pendingVisualAttachments.length > 0) {
+                        await tx.insert(chatAttachments).values(pendingVisualAttachments);
+                    }
+                }
             }
             const [systemEvent] = await tx
                 .insert(chatMessages)
@@ -1175,6 +2484,14 @@ export function chatService(db) {
             .where(eq(chatAttachments.conversationId, conversationId));
         return rows;
     }
+    async function assetHasAttachments(assetId) {
+        const [row] = await db
+            .select({ id: chatAttachments.id })
+            .from(chatAttachments)
+            .where(eq(chatAttachments.assetId, assetId))
+            .limit(1);
+        return Boolean(row);
+    }
     async function remove(id) {
         return db.transaction(async (tx) => {
             const attachmentRows = await tx
@@ -1189,7 +2506,10 @@ export function chatService(db) {
                 return null;
             const assetIds = [...new Set(attachmentRows.map((row) => row.assetId))];
             if (assetIds.length > 0) {
-                await tx.delete(assets).where(inArray(assets.id, assetIds));
+                await tx.delete(assets).where(and(inArray(assets.id, assetIds), sql `not exists (
+            select 1 from ${chatAttachments}
+            where ${chatAttachments.assetId} = ${assets.id}
+          )`));
             }
             return deleted;
         });
@@ -2081,6 +3401,7 @@ export function chatService(db) {
         });
     }
     return {
+        generationProtocol,
         list,
         listSummaries,
         listPinnedSummaries,
@@ -2091,6 +3412,7 @@ export function chatService(db) {
         updateDefaultTitle,
         replaceSystemGeneratedTitle,
         listAttachmentsForConversation,
+        assetHasAttachments,
         remove,
         forkConversation,
         resolve,
@@ -2098,6 +3420,11 @@ export function chatService(db) {
         markUnread,
         setPinned,
         createGeneration,
+        beginGenerationControlAttempt,
+        markGenerationControlReady,
+        renewGenerationControlLease,
+        markGenerationControlAttemptCompleted,
+        appendGenerationEvent,
         markGenerationTerminal,
         getLatestActiveGeneration,
         getLatestGeneration,
@@ -2106,7 +3433,17 @@ export function chatService(db) {
         createQueuedMessage,
         updateQueuedMessage,
         cancelQueuedMessage,
+        scheduleSteerContinuation,
         markQueuedMessageSteerFallback,
+        beginSteerControlAction,
+        claimSteerProviderSend,
+        releaseSteerProviderSendClaim,
+        resolveSteerControlAction,
+        claimNextServerQueuedMessage,
+        renewServerQueuedMessageClaim,
+        completeServerQueuedMessageDelivery,
+        releaseServerQueuedMessageClaim,
+        recoverExpiredServerQueueClaims,
         claimNextQueuedMessage,
         releaseQueuedMessageClaim,
         assertQueuedMessageClaimedForDelivery,