@@ -2,7 +2,7 @@ import type { WorkspaceSearchFilters } from '@/lib/api/contracts/knowledge/searc
 import type { MothershipChat } from '@/lib/api/contracts/mothership-chats'
 import type { ManagedMcpConnectorId } from '@/lib/credential-groups/managed-mcp-connectors'
 import type { AssistantSearchLevel } from '@/lib/mothership/generated/assistant'
-import type { ToolActivity } from '@/lib/mothership/generated/protocol'
+import type { ToolActivity, TurnOrigin } from '@/lib/mothership/generated/protocol'
 import type { ChatContext } from '@/stores/panel'
 import type { BrowserTextSelection, TerminalTextSelection } from '@/stores/panel/types'
 
@@ -197,11 +197,8 @@ export interface ChatMessage {
   role: 'user' | 'assistant'
   requestMode?: 'agent' | 'assistant' | 'plan'
   content: string
-  /**
-   * "task": a background-task notification opened this turn, not the user (a system chip, not a
-   * bubble). "job": a scheduled job's occurrence opened it with the job brief.
-   */
-  origin?: 'task' | 'job'
+  /** Automation opened this turn, not the user: a system chip, not a bubble. */
+  origin?: TurnOrigin
   contentBlocks?: ContentBlock[]
   attachments?: ChatMessageAttachment[]
   fileAttachments?: FileAttachmentForApi[]
 
@@ -5,7 +5,11 @@ import {
   usageLimitReadSchema,
   usageLimitUpdateSchema,
 } from '@/lib/billing/application/usage-limit-validation'
-import { BillingCallbackBody, BillingCallbackHeaders } from '@/lib/mothership/generated/billing'
+import {
+  BillingCallbackBody,
+  BillingCallbackHeaders,
+  UsageUpgrade,
+} from '@/lib/mothership/generated/billing'
 
 const booleanQueryParamSchema = z
   .preprocess((value) => {
@@ -316,8 +320,8 @@ export const billingSwitchPlanResponseSchema = z.object({
  */
 export const usageUpgradePayloadSchema = z.object({
   /** `job_run_budget`: a scheduled job's run reached its own spend cap, not the payer's plan. */
-  reason: z.enum(['usage_limit', 'job_run_budget']),
-  action: z.enum(['upgrade_plan', 'increase_limit']),
+  reason: UsageUpgrade.shape.reason,
+  action: UsageUpgrade.shape.action,
   message: z.string(),
 })
 export type UsageUpgradePayload = z.infer<typeof usageUpgradePayloadSchema>
 
@@ -84,7 +84,7 @@ import { chatSandboxSessionKey } from '@/lib/mothership/tools/sandbox-session-ke
 
 const logger = createLogger('CopilotAsyncRunsRepo')
 const WORKFLOW_EXECUTION_CLAIM_PREFIX = 'workflow:'
-const TERMINAL_RUN_STATUSES: CopilotRunStatus[] = ['complete', 'error', 'cancelled']
+export const TERMINAL_RUN_STATUSES: CopilotRunStatus[] = ['complete', 'error', 'cancelled']
 // Resolve the tracer lazily per-call to avoid capturing the NoOp tracer
 // before NodeSDK installs the global TracerProvider (Next.js 16/Turbopack
 // can evaluate modules before instrumentation-node.ts finishes).
 
@@ -7,6 +7,7 @@ import type { z } from 'zod'
 import { defineWorkspaceOperation } from '@/lib/core/application'
 import { defineOrganizationOperation } from '@/lib/core/application/organization-operation'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
+import type { DbTransaction } from '@/lib/db/types'
 import { resolveTurnDesktopDevice } from '@/lib/desktop/application/executor'
 import { requireOrganizationSearchAvailable } from '@/lib/knowledge/access/availability'
 import { insertRunSegment, withRunAdmissionLock } from '@/lib/mothership/async-runs/repository'
@@ -58,6 +59,50 @@ export async function turnDesktopDevice(
   return resolveTurnDesktopDevice(principal, offeredDeviceId)
 }
 
+interface TurnChat {
+  userId: string
+  workspaceId?: string | null
+  organizationId?: string | null
+  chatId: string
+}
+
+/**
+ * Makes an admitted turn its chat's current conversation, inside the admission's transaction:
+ * the chat's conversation mode follows the turn's, and a send's effort pick stays as the chat's
+ * choice. A chat deleted or moved since its context was resolved is `not_found`.
+ */
+export async function moveChatToTurn(
+  tx: DbTransaction,
+  chat: TurnChat,
+  turn: { messageId: string; mode?: string },
+  effortChoice?: MothershipEffort
+): Promise<{ model: string | null }> {
+  const turnConfig = sql`COALESCE(${copilotChats.config}, '{}'::jsonb) || jsonb_build_object('conversationMode', ${turn.mode ?? 'agent'}::text)`
+  const [updated] = await tx
+    .update(copilotChats)
+    .set({
+      conversationId: turn.messageId,
+      updatedAt: new Date(),
+      config: effortChoice ? withChatEffortChoice(turnConfig, effortChoice) : turnConfig,
+    })
+    .where(
+      and(
+        eq(copilotChats.id, chat.chatId),
+        eq(copilotChats.userId, chat.userId),
+        chat.workspaceId
+          ? eq(copilotChats.workspaceId, chat.workspaceId)
+          : isNull(copilotChats.workspaceId),
+        chat.organizationId
+          ? eq(copilotChats.organizationId, chat.organizationId)
+          : isNull(copilotChats.organizationId),
+        isNull(copilotChats.deletedAt)
+      )
+    )
+    .returning({ model: copilotChats.model })
+  if (!updated) throw new OrchestrationError('not_found', 'Chat not found')
+  return updated
+}
+
 /** The accepted message, its start intent and retry destination commit together. */
 export const admitChatTurn = defineAuthorizedChatUseCase({
   operation: defineWorkspaceOperation({
@@ -102,32 +147,8 @@ export const admitChatTurn = defineAuthorizedChatUseCase({
     }
     await assertChatStreamLease(input.lease)
     const desktopDeviceId = await turnDesktopDevice(principal, workspaceId, input.desktopDeviceId)
-    const turnConfig = sql`COALESCE(${copilotChats.config}, '{}'::jsonb) || jsonb_build_object('conversationMode', ${request.mode ?? 'agent'}::text)`
     return withRunAdmissionLock(userId, request.messageId, async (tx) => {
-      const [chat] = await tx
-        .update(copilotChats)
-        .set({
-          conversationId: request.messageId,
-          updatedAt: new Date(),
-          config: input.effortChoice
-            ? withChatEffortChoice(turnConfig, input.effortChoice)
-            : turnConfig,
-        })
-        .where(
-          and(
-            eq(copilotChats.id, chatId),
-            eq(copilotChats.userId, userId),
-            workspaceId
-              ? eq(copilotChats.workspaceId, workspaceId)
-              : isNull(copilotChats.workspaceId),
-            organizationId
-              ? eq(copilotChats.organizationId, organizationId)
-              : isNull(copilotChats.organizationId),
-            isNull(copilotChats.deletedAt)
-          )
-        )
-        .returning({ model: copilotChats.model })
-      if (!chat) throw new OrchestrationError('not_found', 'Chat not found')
+      const chat = await moveChatToTurn(tx, context, request, input.effortChoice)
       await appendCopilotChatMessages(
         chatId,
         [buildPersistedUserMessage(input.message)],
 
@@ -1,11 +1,12 @@
 import type { DelegatedPrincipal, OrganizationDelegatedPrincipal } from '@sim/auth/principal'
-import { copilotChats, copilotRuns } from '@sim/db/schema'
-import { and, eq, isNull } from 'drizzle-orm'
+import { copilotRuns } from '@sim/db/schema'
+import { eq } from 'drizzle-orm'
 import type { z } from 'zod'
 import { defineWorkspaceOperation } from '@/lib/core/application'
 import { defineOrganizationOperation } from '@/lib/core/application/organization-operation'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { insertRunSegment, withRunAdmissionLock } from '@/lib/mothership/async-runs/repository'
+import { moveChatToTurn } from '@/lib/mothership/chat/application/admit-turn'
 import { defineAuthorizedChatUseCase } from '@/lib/mothership/chat/application/authorized-chat-use-case'
 import { resolveOwnedWorkspaceChatContext } from '@/lib/mothership/chat/application/context'
 import { appendCopilotChatMessages } from '@/lib/mothership/chat/messages-store'
@@ -21,19 +22,13 @@ import type { TurnSecretAuthority } from '@/lib/mothership/secret-mount-policy'
 export const UNATTENDED_TURN_AUDIENCE = 'sim:copilot-jobs'
 
 interface AdmitUnattendedTurnInput {
-  chatId: string
-  /** The occurrence's id: the run, its stream and its user message all carry it. */
-  messageId: string
-  executionId: string
-  requestId: string
-  message: string
-  origin: 'job'
+  /** The turn's request is its identity: its message id names the run, its stream and its user message. */
   recovery: z.input<typeof StreamRecoveryConfigSchema>
   lease: ChatStreamLease
   secretAuthority: TurnSecretAuthority
 }
 
-export type UnattendedAdmission =
+type UnattendedAdmission =
   | { kind: 'admitted'; run: Awaited<ReturnType<typeof insertRunSegment>> }
   | { kind: 'duplicate' }
 
@@ -69,7 +64,7 @@ export const admitUnattendedTurn = defineAuthorizedChatUseCase({
   }: {
     principal: DelegatedPrincipal | OrganizationDelegatedPrincipal
     input: AdmitUnattendedTurnInput
-  }) => resolveOwnedWorkspaceChatContext(principal, input.chatId),
+  }) => resolveOwnedWorkspaceChatContext(principal, input.recovery.request.chatId),
   authorizationOptions: {
     delegation: {
       audience: UNATTENDED_TURN_AUDIENCE,
@@ -85,61 +80,46 @@ export const admitUnattendedTurn = defineAuthorizedChatUseCase({
     const request = recovery.request
     if (
       recovery.kind !== 'unattended_stream' ||
+      !request.origin ||
       request.userId !== userId ||
       request.workspaceId !== workspaceId ||
       request.organizationId !== undefined ||
-      request.chatId !== chatId ||
-      request.messageId !== input.messageId ||
-      request.message !== input.message ||
-      request.origin !== input.origin
+      request.chatId !== chatId
     ) {
       throw new OrchestrationError('validation', 'Turn identity does not match its chat')
     }
+    const { messageId, message, origin } = request
     await assertChatStreamLease(input.lease)
-    return withRunAdmissionLock(userId, input.messageId, async (tx) => {
+    return withRunAdmissionLock(userId, messageId, async (tx) => {
       const [existing] = await tx
         .select({ id: copilotRuns.id })
         .from(copilotRuns)
-        .where(eq(copilotRuns.streamId, input.messageId))
+        .where(eq(copilotRuns.streamId, messageId))
         .limit(1)
       if (existing) return { kind: 'duplicate' } as const
-      const [chat] = await tx
-        .update(copilotChats)
-        .set({ conversationId: input.messageId, updatedAt: new Date() })
-        .where(
-          and(
-            eq(copilotChats.id, chatId),
-            eq(copilotChats.userId, userId),
-            workspaceId
-              ? eq(copilotChats.workspaceId, workspaceId)
-              : isNull(copilotChats.workspaceId),
-            isNull(copilotChats.deletedAt)
-          )
-        )
-        .returning({ model: copilotChats.model })
-      if (!chat) throw new OrchestrationError('not_found', 'Chat not found')
+      const chat = await moveChatToTurn(tx, context, request)
       await appendCopilotChatMessages(
         chatId,
         [
           buildPersistedUserMessage({
-            id: input.messageId,
-            content: input.message,
-            origin: input.origin,
+            id: messageId,
+            content: message,
+            origin,
             requestMode: 'agent',
           }),
         ],
-        { streamId: input.messageId, chatModel: chat.model },
+        { streamId: messageId, chatModel: chat.model },
         tx
       )
       const run = await insertRunSegment(tx, {
-        id: input.messageId,
-        executionId: input.executionId,
+        id: messageId,
+        executionId: messageId,
         chatId,
         userId,
         workspaceId,
-        streamId: input.messageId,
+        streamId: messageId,
         requestContext: {
-          requestId: input.requestId,
+          requestId: messageId,
           controllerToken: input.lease.value,
           recovery,
           secretAuthority: input.secretAuthority,
 
@@ -24,7 +24,7 @@ import {
   MothershipStreamV1ToolOutcome,
   MothershipStreamV1ToolPhase,
 } from '@/lib/mothership/generated/mothership-stream-v1'
-import { ToolActivity } from '@/lib/mothership/generated/protocol'
+import { ToolActivity, TurnOrigin } from '@/lib/mothership/generated/protocol'
 import type {
   ContentBlock,
   LocalToolCallStatus,
@@ -137,11 +137,8 @@ export interface PersistedMessage {
   requestMode?: 'agent' | 'assistant' | 'plan'
   content: string
   timestamp: string
-  /**
-   * "task": a background-task notification opened this turn, not the user (rendered as a system
-   * chip). "job": a scheduled job's occurrence opened it with the job brief.
-   */
-  origin?: 'task' | 'job'
+  /** Automation opened this turn, not the user (rendered as a system chip). */
+  origin?: TurnOrigin
   requestId?: string
   contentBlocks?: PersistedContentBlock[]
   fileAttachments?: PersistedFileAttachment[]
@@ -574,7 +571,7 @@ export interface UserMessageParams {
   content: string
   fileAttachments?: PersistedFileAttachment[]
   contexts?: PersistedMessageContext[]
-  origin?: 'task' | 'job'
+  origin?: TurnOrigin
 }
 
 export function buildPersistedUserMessage(params: UserMessageParams): PersistedMessage {
@@ -899,7 +896,8 @@ export function normalizeMessage(raw: Record<string, unknown>): PersistedMessage
   if (raw.requestId && typeof raw.requestId === 'string') {
     msg.requestId = raw.requestId
   }
-  if (raw.origin === 'task' || raw.origin === 'job') msg.origin = raw.origin
+  const origin = TurnOrigin.safeParse(raw.origin)
+  if (origin.success) msg.origin = origin.data
 
   const rawBlocks = raw.contentBlocks as RawBlock[] | undefined
   const rawToolCalls = raw.toolCalls as LegacyToolCall[] | undefined
 
@@ -146,6 +146,12 @@ export const ENTITLEMENTS = { dashboards: "dashboards", tests: "tests", changelo
 export type Entitlement = (typeof ENTITLEMENTS)[keyof typeof ENTITLEMENTS];
 export const Entitlements = z.array(z.string().min(1).max(64)).max(32);
 
+/** What opened a turn when no person typed it: "task", Sim's wake for a background-task
+ * notification (21-background-tasks.md); "job", Sim's schedule for one occurrence of a scheduled
+ * job (D92), its message the job brief. Absent on a person's turn. */
+export const TurnOrigin = z.enum(["task", "job"]);
+export type TurnOrigin = z.infer<typeof TurnOrigin>;
+
 export const ChatPayloadSchema = z
   .strictObject({
     desktop: DesktopContextSchema.optional(),
@@ -192,10 +198,8 @@ export const ChatPayloadSchema = z
     /** Explicit client-executor declaration (see contracts ChatRequest.clientCapabilities);
      * the worker accepts and ignores it — dispatch semantics live on the sim side. */
     clientCapabilities: z.array(z.string()).default([]),
-    /** "task": sim opened this turn for a background-task notification, not for a typed
-     * message (21-background-tasks.md); "job": sim's schedule opened it for one occurrence of a
-     * scheduled job (D92), its message the job brief. Recorded on the turn's user_message event. */
-    origin: z.enum(["task", "job"]).optional(),
+    /** Recorded on the turn's user_message event. */
+    origin: TurnOrigin.optional(),
     /** Per-turn effort dial (user-selected in the composer); absent = deployment default. */
     effort: z.enum(["none", "low", "medium", "high", "xhigh", "max"]).optional(),
     modelSelection: ModelSelectionSchema.optional(),
 
@@ -1,20 +1,16 @@
 import { db, jobExecutionLogs } from '@sim/db'
 import { truncate } from '@sim/utils/string'
 import { and, desc, eq, isNotNull, lt } from 'drizzle-orm'
+import type { JobRun } from '@/lib/mothership/jobs/runs'
 
 /** How many earlier runs' outcomes a brief carries. */
 const BRIEF_RECENT_RUNS = 5
 const BRIEF_SUMMARY_CHARS = 400
 
-export interface JobBriefSchedule {
-  id: string
-  jobTitle: string | null
-  prompt: string | null
-  successCondition: string | null
-  lifecycle: string
-  maxRuns: number | null
-  runCount: number
-}
+type JobBriefSchedule = Pick<
+  JobRun,
+  'scheduleId' | 'jobTitle' | 'prompt' | 'successCondition' | 'lifecycle' | 'maxRuns' | 'runCount'
+>
 
 /**
  * The user message of one occurrence's turn: what the job is, how far along it is, and how its
@@ -35,7 +31,7 @@ export async function buildJobBrief(
     .from(jobExecutionLogs)
     .where(
       and(
-        eq(jobExecutionLogs.scheduleId, schedule.id),
+        eq(jobExecutionLogs.scheduleId, schedule.scheduleId),
         isNotNull(jobExecutionLogs.outcome),
         lt(jobExecutionLogs.occurrenceAt, occurrenceAt)
       )