@opengeni/db 0.36.0 → 1.0.1

package/src/index.ts

@@ -156,7 +156,7 @@ import {
   MODEL_ATTACHMENT_REFS_FIELD,
   MODEL_TIMELINE_ANNOTATIONS_FIELD,
   TimelineAnnotations,
-  renderTimelineAnnotationsForModel,
+  renderUserMessageContentForModel,
   SessionMcpApprovalPolicy as SessionMcpApprovalPolicySchema,
   RequestHumanInteractionToolInput,
   WORKSPACE_XAI_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1,
@@ -4331,7 +4331,7 @@ export type EnqueueSessionTurnInput = {
   temporalWorkflowId: string;
   source: SessionTurnSource;
   prompt: string;
-  turnInstructions?: string | null;
+  modelContext?: string | null;
   resources: ResourceRef[];
   tools: ToolRef[];
   toolsProvided?: boolean;
@@ -4350,12 +4350,8 @@ export type EnqueueSessionTurnInput = {
   placement?: "head" | "tail";
 };
 
-/**
- * Worker-only turn projection. Host instructions are durable execution input,
- * never part of the public SessionTurn/queue/HTTP contract.
- */
+/** Worker-only turn projection with causal authority omitted from public APIs. */
 export type SessionTurnForExecution = SessionTurn & {
-  turnInstructions: string | null;
   personalConnectionDelegations: McpPersonalConnectionDelegation[];
   /** Worker-only causal authority; never inferred from the current worker. */
   initiatingHumanSubjectId: string | null;
@@ -4581,6 +4577,89 @@ export async function requireFile(
   return file;
 }
 
+/**
+ * Subject-bound file read for user-visible and model-injection surfaces. The
+ * database predicate returns true for ordinary workspace files, but Drive-
+ * derived bytes require current per-object ACL evidence for every protecting
+ * mapping. Missing/stale/mixed denied mappings therefore look not found.
+ */
+export async function requireFileForSubject(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string | null;
+    fileId: string;
+  },
+): Promise<FileAsset> {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      if (input.subjectId) await setSubjectRlsContext(scopedDb, input.subjectId);
+      const subjectIdSql = input.subjectId === null ? sql`NULL::text` : sql`${input.subjectId}`;
+      const [row] = await scopedDb
+        .select()
+        .from(schema.files)
+        .where(
+          and(
+            eq(schema.files.accountId, input.accountId),
+            eq(schema.files.workspaceId, input.workspaceId),
+            eq(schema.files.id, input.fileId),
+            sql`google_drive_file_authorized(
+              ${input.accountId}::uuid,
+              ${input.workspaceId}::uuid,
+              ${subjectIdSql},
+              ${input.fileId}::uuid
+            )`,
+          ),
+        )
+        .limit(1);
+      if (!row) throw new Error(`File not found: ${input.fileId}`);
+      return mapFile(row);
+    },
+  );
+}
+
+/** Batch form of requireFileForSubject for durable model-history projection. */
+export async function getFilesForSubject(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string | null;
+    fileIds: readonly string[];
+  },
+): Promise<FileAsset[]> {
+  const ids = [...new Set(input.fileIds)];
+  if (ids.length === 0) return [];
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      if (input.subjectId) await setSubjectRlsContext(scopedDb, input.subjectId);
+      const subjectIdSql = input.subjectId === null ? sql`NULL::text` : sql`${input.subjectId}`;
+      const rows = await scopedDb
+        .select()
+        .from(schema.files)
+        .where(
+          and(
+            eq(schema.files.accountId, input.accountId),
+            eq(schema.files.workspaceId, input.workspaceId),
+            inArray(schema.files.id, ids),
+            sql`google_drive_file_authorized(
+              ${input.accountId}::uuid,
+              ${input.workspaceId}::uuid,
+              ${subjectIdSql},
+              ${schema.files.id}
+            )`,
+          ),
+        );
+      return rows.map(mapFile);
+    },
+  );
+}
+
 /** One RLS-scoped query for all attachment metadata needed by a model turn. */
 export async function getFiles(
   db: Database,
@@ -4603,6 +4682,7 @@ export function durableUserHistoryItem(
   prompt: string,
   resources: readonly ResourceRef[],
   annotations: readonly TimelineAnnotation[] = [],
+  modelContext?: string | null,
 ): Record<string, unknown> {
   const attachmentRefs = resources.filter(
     (resource): resource is Extract<ResourceRef, { kind: "file" }> => resource.kind === "file",
@@ -4610,7 +4690,7 @@ export function durableUserHistoryItem(
   return {
     type: "message",
     role: "user",
-    content: renderTimelineAnnotationsForModel(prompt, annotations),
+    content: renderUserMessageContentForModel(prompt, annotations, modelContext),
     ...(attachmentRefs.length > 0 ? { [MODEL_ATTACHMENT_REFS_FIELD]: attachmentRefs } : {}),
     ...(annotations.length > 0
       ? {
@@ -22578,6 +22658,122 @@ export async function upsertConnectorActionPolicy(
   );
 }
 
+/**
+ * Install a risk-appropriate connector default without overwriting an explicit
+ * user choice that already exists for the same immutable connector action.
+ */
+export async function ensureConnectorActionPolicyDefault(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    connectionId: string;
+    serverId: string;
+    toolName: string;
+    actionName: string;
+    policy: ConnectorActionPolicyDecision;
+  },
+): Promise<{
+  policy: typeof schema.connectorActionPolicies.$inferSelect;
+  changed: boolean;
+}> {
+  const scope = {
+    connectionId: boundedConnectorActionText(
+      input.connectionId,
+      "connector connection id",
+      CONNECTOR_ACTION_CONNECTION_ID_MAX,
+    ),
+    serverId: boundedConnectorActionText(
+      input.serverId,
+      "connector server id",
+      CONNECTOR_ACTION_SERVER_ID_MAX,
+    ),
+    toolName: boundedConnectorActionText(
+      input.toolName,
+      "connector tool name",
+      CONNECTOR_ACTION_NAME_MAX,
+    ),
+    actionName: boundedConnectorActionText(
+      input.actionName,
+      "connector action name",
+      CONNECTOR_ACTION_NAME_MAX,
+    ),
+  };
+  const subjectId = boundedConnectorActionText(input.subjectId, "policy actor", 1024);
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) =>
+      await scopedDb.transaction(async (tx) => {
+        await assertWorkspaceAccountPairInScope(tx, input.accountId, input.workspaceId);
+        const [inserted] = await tx
+          .insert(schema.connectorActionPolicies)
+          .values({
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            ...scope,
+            policy: input.policy,
+            createdBySubjectId: subjectId,
+            updatedBySubjectId: subjectId,
+          })
+          .onConflictDoNothing({
+            target: [
+              schema.connectorActionPolicies.workspaceId,
+              schema.connectorActionPolicies.connectionId,
+              schema.connectorActionPolicies.serverId,
+              schema.connectorActionPolicies.toolName,
+              schema.connectorActionPolicies.actionName,
+            ],
+          })
+          .returning();
+        if (!inserted) {
+          const [existing] = await tx
+            .select()
+            .from(schema.connectorActionPolicies)
+            .where(
+              and(
+                eq(schema.connectorActionPolicies.workspaceId, input.workspaceId),
+                eq(schema.connectorActionPolicies.connectionId, scope.connectionId),
+                eq(schema.connectorActionPolicies.serverId, scope.serverId),
+                eq(schema.connectorActionPolicies.toolName, scope.toolName),
+                eq(schema.connectorActionPolicies.actionName, scope.actionName),
+              ),
+            )
+            .limit(1);
+          if (!existing) throw new Error("Failed to reconcile connector action policy default");
+          return { policy: existing, changed: false };
+        }
+        await tx.insert(schema.auditEvents).values(
+          withLosslessContentWriteVersion(
+            {
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              subjectId,
+              action: "connector.action.policy_changed",
+              targetType: "connector_action_policy",
+              targetId: inserted.id,
+              metadata: {
+                connectionId: inserted.connectionId,
+                serverId: inserted.serverId,
+                toolName: inserted.toolName,
+                actionName: inserted.actionName,
+                policy: inserted.policy,
+                version: inserted.version,
+                previousPolicy: null,
+                previousVersion: null,
+                source: "connector_default",
+              },
+            },
+            "metadata",
+            "metadataCodecVersion",
+          ),
+        );
+        return { policy: inserted, changed: true };
+      }),
+  );
+}
+
 export async function prepareConnectorActionApproval(
   db: Database,
   identity: ConnectorActionAttemptIdentity,
@@ -22916,7 +23112,7 @@ export type SessionCreateInput = {
   accountId: string;
   workspaceId: string;
   initialMessage: string;
-  initialTurnInstructions?: string | null;
+  initialModelContext?: string | null;
   resources: ResourceRef[];
   skills?: SessionSkill[];
   tools?: ToolRef[];
@@ -23366,7 +23562,7 @@ async function createSessionInTransaction(
             accountId: input.accountId,
             workspaceId: input.workspaceId,
             initialMessage: input.initialMessage,
-            initialTurnInstructions: input.initialTurnInstructions ?? null,
+            initialModelContext: input.initialModelContext ?? null,
             resources: input.resources,
             skills: input.skills ?? [],
             tools: input.tools ?? [],
@@ -45617,6 +45813,7 @@ export async function materializeGoalContinuation(
         if (
           !goalRead ||
           goalRead.status !== "active" ||
+          session.status === "failed" ||
           session.status === "cancelled" ||
           effectiveControl.state !== "active"
         ) {
@@ -46370,6 +46567,9 @@ export async function initializeSessionStartAtomically(
                     type: "user.message",
                     payload: {
                       ...initialPayload,
+                      ...(session.initialModelContext
+                        ? { modelContext: session.initialModelContext }
+                        : {}),
                       initiator: creator.initiator,
                     },
                     clientEventId: input.clientEventId ?? `session-initial:${session.id}`,
@@ -46425,7 +46625,7 @@ export async function initializeSessionStartAtomically(
                   source: "user",
                   position: queueTailPosition,
                   prompt: canonicalInitialMessage,
-                  turnInstructions: session.initialTurnInstructions ?? null,
+                  modelContext: session.initialModelContext ?? null,
                   resources: session.resources,
                   tools: session.tools,
                   toolsProvided: session.toolPolicy?.mode === "explicit",
@@ -46626,7 +46826,7 @@ export async function enqueueSessionTurn(
                 source: input.source,
                 position,
                 prompt: input.prompt,
-                turnInstructions: input.turnInstructions ?? null,
+                modelContext: input.modelContext ?? null,
                 resources: input.resources,
                 tools: input.tools,
                 toolsProvided: input.toolsProvided ?? false,
@@ -46974,9 +47174,14 @@ export async function claimSessionWorkForAttempt(
   input: ClaimSessionWorkForAttemptInput,
 ): Promise<ClaimSessionWorkForAttemptResult> {
   const { sessionId, workflowId } = input;
-  return await withWorkspaceSessionActivityRls(
+  return await retrySessionActivityRls(
     db,
     workspaceId,
+    {
+      stage: "session_attempts.claim",
+      eventTypes: ["session.turn.attempt_claimed"],
+      maxAttempts: 3,
+    },
     async (scopedDb) =>
       await withSessionActivitySavepoint(scopedDb, async (tx) => {
         const deliverPendingUpdates = async (
@@ -48372,6 +48577,7 @@ export async function claimSessionWorkForAttempt(
                 fromPostgresLosslessText(row.prompt, row.promptCodecVersion),
                 Array.isArray(row.resources) ? (row.resources as ResourceRef[]) : [],
                 TimelineAnnotations.parse(row.annotations),
+                row.modelContext,
               ),
             },
             "item",
@@ -50003,6 +50209,405 @@ export async function peekSessionWork(
   });
 }
 
+export type FailSessionWorkBeforeAttemptClaimInput = {
+  accountId: string;
+  sessionId: string;
+  workflowId: string;
+  trigger: SessionWorkTrigger;
+  error: string;
+};
+
+export type FailSessionWorkBeforeAttemptClaimResult =
+  | { action: "failed"; turnId: string | null; events: SessionEvent[] }
+  | { action: "terminal"; turnId: null; events: [] }
+  | { action: "stale"; turnId: null; events: [] };
+
+/**
+ * Terminally settle a permanent admission failure that happened before an
+ * attempt row existed. The workflow supplies the exact trigger recorded in
+ * Temporal history; this transaction re-evaluates it under the canonical
+ * control -> workspace -> session -> turn lock order and refuses stale,
+ * paused, capacity-blocked, or concurrently claimed work. No attempt row is
+ * fabricated because provider/tool execution never started.
+ */
+export async function failSessionWorkBeforeAttemptClaim(
+  db: Database,
+  workspaceId: string,
+  input: FailSessionWorkBeforeAttemptClaimInput,
+): Promise<FailSessionWorkBeforeAttemptClaimResult> {
+  return await retrySessionActivityRls(
+    db,
+    workspaceId,
+    {
+      stage: "session_lifecycle_outbox.fail_before_attempt_claim",
+      eventTypes: ["child_terminal_result", "session.status.changed", "turn.failed"],
+      maxAttempts: 3,
+    },
+    async (scopedDb) =>
+      await scopedDb.transaction(async (tx) => {
+        const baseLocks = await lockChildLifecycleOutboxWriteRowsTx(
+          tx as unknown as Database,
+          workspaceId,
+          { sessionId: input.sessionId },
+        );
+        const session = baseLocks.session;
+        if (session.accountId !== input.accountId) {
+          throw new SessionControlInvariantError(
+            `Session ${input.sessionId} does not belong to account ${input.accountId}`,
+          );
+        }
+        if (session.status === "failed" || session.status === "cancelled") {
+          return { action: "terminal", turnId: null, events: [] } as const;
+        }
+        if (
+          session.temporalWorkflowId !== null &&
+          session.temporalWorkflowId !== input.workflowId
+        ) {
+          return { action: "stale", turnId: null, events: [] } as const;
+        }
+        const effectiveControl = await evaluateSessionControl(
+          tx as unknown as Database,
+          workspaceId,
+          input.sessionId,
+          { workspaceControl: baseLocks.control ?? undefined },
+        );
+        if (!baseLocks.workspace || effectiveControl.state !== "active") {
+          return { action: "stale", turnId: null, events: [] } as const;
+        }
+
+        // The session lock serializes this check with claim. If another worker
+        // committed ownership while the activity response was ambiguous, its
+        // attempt is authoritative and this terminal path must no-op.
+        const [liveAttempt] = await tx
+          .select({ id: schema.sessionTurnAttempts.id })
+          .from(schema.sessionTurnAttempts)
+          .where(
+            and(
+              eq(schema.sessionTurnAttempts.workspaceId, workspaceId),
+              eq(schema.sessionTurnAttempts.sessionId, input.sessionId),
+              inArray(schema.sessionTurnAttempts.state, ["claimed", "running"]),
+            ),
+          )
+          .limit(1);
+        if (liveAttempt) {
+          return { action: "stale", turnId: null, events: [] } as const;
+        }
+
+        let turn: typeof schema.sessionTurns.$inferSelect | null = null;
+        if (session.activeTurnId) {
+          const exactLocks = await lockSessionEventWriteRows(tx as unknown as Database, {
+            workspaceId,
+            controlLock: "already_locked",
+            workspaceLock: "already_locked",
+            turnIds: [session.activeTurnId],
+          });
+          turn = exactLocks.turns[0] ?? null;
+          if (!turn || turn.accountId !== session.accountId || turn.sessionId !== input.sessionId) {
+            // The claim failed on this same locked corrupt pointer. There is no
+            // safe turn identity to settle, but retrying can never repair it;
+            // fail the owning session and its session-level obligations below.
+            turn = null;
+          }
+          if (turn && isTerminalSessionTurnStatus(turn.status as SessionTurnStatus)) {
+            // Repair the corrupt session pointer without writing a second
+            // terminal event onto an already-terminal logical turn.
+            turn = null;
+          } else if (turn && input.trigger.kind === "approval") {
+            if (
+              turn.status !== "requires_action" ||
+              !(await isNewerApprovalTrigger(
+                tx as unknown as Database,
+                workspaceId,
+                input.sessionId,
+                turn.triggerEventId,
+                input.trigger.triggerEventId,
+              ))
+            ) {
+              return { action: "stale", turnId: null, events: [] } as const;
+            }
+          } else if (turn) {
+            if (turn.status === "requires_action") {
+              return { action: "stale", turnId: null, events: [] } as const;
+            }
+            if (turn.status === "waiting_capacity") {
+              const [codexWaiter] = await tx
+                .select({ id: schema.codexCapacityWaiters.id })
+                .from(schema.codexCapacityWaiters)
+                .where(
+                  and(
+                    eq(schema.codexCapacityWaiters.workspaceId, workspaceId),
+                    eq(schema.codexCapacityWaiters.sessionId, input.sessionId),
+                    eq(schema.codexCapacityWaiters.status, "waiting"),
+                  ),
+                )
+                .limit(1);
+              const xaiWaiter = await getXaiCapacityWaitForSessionInTransaction(
+                tx as unknown as Database,
+                workspaceId,
+                input.sessionId,
+              );
+              if (codexWaiter || xaiWaiter) {
+                return { action: "stale", turnId: null, events: [] } as const;
+              }
+            }
+          }
+        } else {
+          if (input.trigger.kind === "approval") {
+            return { action: "stale", turnId: null, events: [] } as const;
+          }
+          const [pendingAgentSteer] = await tx
+            .select({ id: schema.sessionSystemUpdates.id })
+            .from(schema.sessionSystemUpdates)
+            .where(
+              and(
+                eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
+                eq(schema.sessionSystemUpdates.sessionId, input.sessionId),
+                eq(schema.sessionSystemUpdates.kind, "agent_steer_instruction"),
+                eq(schema.sessionSystemUpdates.state, "pending"),
+              ),
+            )
+            .orderBy(
+              desc(schema.sessionSystemUpdates.createdAt),
+              desc(schema.sessionSystemUpdates.id),
+            )
+            .limit(1);
+          const queuedRows = await rawRows<{ id: string }>(
+            tx as unknown as Database,
+            sql`select id from session_turns
+                where workspace_id = ${workspaceId} and session_id = ${input.sessionId}
+                  and status = 'queued' and source in ('user', 'api')
+                  and (
+                    ${Boolean(pendingAgentSteer)} = false
+                    or metadata->>'delivery' = 'steer'
+                  )
+                order by position asc, created_at asc, id asc
+                limit 1`,
+          );
+          const queuedPreview = queuedRows[0];
+          if (queuedPreview) {
+            const exactLocks = await lockSessionEventWriteRows(tx as unknown as Database, {
+              workspaceId,
+              controlLock: "already_locked",
+              workspaceLock: "already_locked",
+              turnIds: [queuedPreview.id],
+            });
+            turn = exactLocks.turns[0] ?? null;
+            if (
+              !turn ||
+              turn.accountId !== session.accountId ||
+              turn.sessionId !== input.sessionId ||
+              turn.status !== "queued" ||
+              turn.activeAttemptId !== null
+            ) {
+              return { action: "stale", turnId: null, events: [] } as const;
+            }
+          } else if (!session.compactRequested) {
+            if (
+              !pendingAgentSteer &&
+              (await latestFinishedTurnHasFailureCodeTx(
+                tx as unknown as Database,
+                workspaceId,
+                input.sessionId,
+                "context_compaction_failed",
+              ))
+            ) {
+              return { action: "stale", turnId: null, events: [] } as const;
+            }
+            const [pendingUpdate] = await tx
+              .select({ id: schema.sessionSystemUpdates.id })
+              .from(schema.sessionSystemUpdates)
+              .where(
+                and(
+                  eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
+                  eq(schema.sessionSystemUpdates.sessionId, input.sessionId),
+                  eq(schema.sessionSystemUpdates.state, "pending"),
+                ),
+              )
+              .limit(1)
+              .for("update");
+            if (!pendingUpdate) {
+              return { action: "stale", turnId: null, events: [] } as const;
+            }
+          }
+        }
+
+        const now = new Date();
+        let sequence = session.lastSequence;
+        let closedToolEvents: SessionEvent[] = [];
+        if (turn) {
+          await cancelTurnInteractionInterventionsInTransaction(tx as unknown as Database, {
+            accountId: session.accountId,
+            workspaceId,
+            sessionId: input.sessionId,
+            turnId: turn.id,
+          });
+          const closedTools = await closePendingSessionToolCallsInTransaction(
+            tx as unknown as Database,
+            {
+              accountId: session.accountId,
+              workspaceId,
+              sessionId: input.sessionId,
+              turnId: turn.id,
+              reason: "turn_failed",
+              sequence,
+              now,
+            },
+          );
+          sequence = closedTools.sequence;
+          closedToolEvents = closedTools.events;
+          await tx
+            .update(schema.sessionHumanInputRequests)
+            .set({
+              status: "cancelled",
+              response: { outcome: "cancelled" },
+              respondedBy: "system:turn_failed",
+              respondedAt: now,
+              updatedAt: now,
+            })
+            .where(
+              and(
+                eq(schema.sessionHumanInputRequests.workspaceId, workspaceId),
+                eq(schema.sessionHumanInputRequests.sessionId, input.sessionId),
+                eq(schema.sessionHumanInputRequests.turnId, turn.id),
+                eq(schema.sessionHumanInputRequests.status, "pending"),
+              ),
+            );
+        }
+        await settleSessionMaintenanceInTransaction(tx as unknown as Database, {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId: input.sessionId,
+        });
+        if (!turn) {
+          await tx
+            .update(schema.sessionSystemUpdates)
+            .set({ state: "failed" })
+            .where(
+              and(
+                eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
+                eq(schema.sessionSystemUpdates.sessionId, input.sessionId),
+                eq(schema.sessionSystemUpdates.state, "pending"),
+              ),
+            );
+        }
+        const values = [
+          ...(turn
+            ? [
+                {
+                  accountId: session.accountId,
+                  workspaceId,
+                  sessionId: input.sessionId,
+                  sequence: ++sequence,
+                  type: "turn.failed" as const,
+                  payload: {
+                    triggerEventId: turn.triggerEventId,
+                    code: "pre_claim_failure",
+                    error: input.error,
+                  },
+                  turnId: turn.id,
+                  turnGeneration: turn.executionGeneration,
+                  turnAttemptId: null,
+                  turnAssociation: "current" as const,
+                  occurredAt: now,
+                },
+              ]
+            : []),
+          {
+            accountId: session.accountId,
+            workspaceId,
+            sessionId: input.sessionId,
+            sequence: ++sequence,
+            type: "session.status.changed" as const,
+            payload: { status: "failed", code: "pre_claim_failure" },
+            turnId: turn?.id ?? null,
+            turnGeneration: turn?.executionGeneration ?? null,
+            turnAttemptId: null,
+            turnAssociation: turn ? ("current" as const) : null,
+            occurredAt: now,
+          },
+        ];
+        const inserted = await tx
+          .insert(schema.sessionEvents)
+          .values(withLosslessContentWriteVersion(values, "payload", "payloadCodecVersion"))
+          .returning();
+        if (turn) {
+          const failedEvent = inserted.find((event) => event.type === "turn.failed");
+          if (!failedEvent) {
+            throw new SessionControlInvariantError(
+              `Pre-claim failure for turn ${turn.id} has no terminal event`,
+            );
+          }
+          await projectSessionRealtimeDelegationTerminalInTransaction(tx as unknown as Database, {
+            accountId: session.accountId,
+            workspaceId,
+            sessionId: input.sessionId,
+            turnId: turn.id,
+            turnStatus: "failed",
+            terminalEvent: {
+              id: failedEvent.id,
+              type: "turn.failed",
+              payload: sessionEventPayloadRecord(
+                failedEvent.payload,
+                failedEvent.payloadCodecVersion,
+              ),
+            },
+            now,
+          });
+          await tx
+            .update(schema.sessionTurns)
+            .set({
+              status: "failed",
+              activeAttemptId: null,
+              version: turn.version + 1,
+              finishedAt: now,
+              updatedAt: now,
+            })
+            .where(
+              and(
+                eq(schema.sessionTurns.workspaceId, workspaceId),
+                eq(schema.sessionTurns.sessionId, input.sessionId),
+                eq(schema.sessionTurns.id, turn.id),
+              ),
+            );
+          await enqueueFailedChildOutboxForTurnTx(
+            tx as unknown as Database,
+            workspaceId,
+            session,
+            turn,
+          );
+        } else {
+          await enqueueFailedChildOutboxWithoutTurnTx(
+            tx as unknown as Database,
+            workspaceId,
+            session,
+            sequence,
+          );
+        }
+        await tx
+          .update(schema.sessions)
+          .set({
+            status: "failed",
+            activeTurnId: null,
+            compactRequested: false,
+            lastSequence: sequence,
+            queueVersion: session.queueVersion + 1,
+            updatedAt: now,
+          })
+          .where(
+            and(
+              eq(schema.sessions.workspaceId, workspaceId),
+              eq(schema.sessions.id, input.sessionId),
+            ),
+          );
+        return {
+          action: "failed",
+          turnId: turn?.id ?? null,
+          events: [...closedToolEvents, ...inserted.map(mapEvent)],
+        } as const;
+      }),
+  );
+}
+
 /**
  * Child lifecycle transactions discover immutable parentage only after taking
  * the control/workspace prefix. They must then lock child and parent together,
@@ -52804,14 +53409,16 @@ function queuedSteerReplacementAttemptId(metadata: Record<string, unknown>): str
   return null;
 }
 
-async function enqueueFailedChildOutboxForTurnTx(
+async function enqueueFailedChildOutboxTx(
   tx: Database,
   workspaceId: string,
-  session: Pick<typeof schema.sessions.$inferSelect, "id" | "parentSessionId" | "parentTurnId">,
-  turn: Pick<typeof schema.sessionTurns.$inferSelect, "id" | "accountId" | "sessionId">,
+  session: Pick<
+    typeof schema.sessions.$inferSelect,
+    "id" | "accountId" | "parentSessionId" | "parentTurnId"
+  >,
+  input: { turnId: string | null; dedupeKey: string },
 ): Promise<void> {
   if (!session.parentSessionId) return;
-  const dedupeKey = `child-completion:${turn.sessionId}:turn:${turn.id}`;
   const personalConnectionDelegations = session.parentTurnId
     ? await personalConnectionDelegationsForTurnInTransaction(
         tx,
@@ -52859,26 +53466,26 @@ async function enqueueFailedChildOutboxForTurnTx(
       withLosslessContentWriteVersion(
         withLosslessContentWriteVersion(
           {
-            accountId: turn.accountId,
+            accountId: session.accountId,
             workspaceId,
-            sourceSessionId: turn.sessionId,
+            sourceSessionId: session.id,
             targetSessionId: session.parentSessionId,
-            dedupeKey,
+            dedupeKey: input.dedupeKey,
             kind: "child_terminal_result",
             classification: "failure",
-            sourceId: turn.sessionId,
+            sourceId: session.id,
             summary: "Child session failed; inspect the durable child timeline.",
             payload: {
               type: "child_terminal_result",
-              childSessionId: turn.sessionId,
+              childSessionId: session.id,
               status: "failed",
-              turnId: turn.id,
+              ...(input.turnId ? { turnId: input.turnId } : {}),
             },
             lineage: {
-              childSessionId: turn.sessionId,
+              childSessionId: session.id,
               parentSessionId: session.parentSessionId,
               ...(session.parentTurnId ? { parentTurnId: session.parentTurnId } : {}),
-              turnId: turn.id,
+              ...(input.turnId ? { turnId: input.turnId } : {}),
               ...(xaiAuthoritySubjectId ? { xaiAuthoritySubjectId } : {}),
             },
             personalConnectionDelegations,
@@ -52899,6 +53506,41 @@ async function enqueueFailedChildOutboxForTurnTx(
     });
 }
 
+async function enqueueFailedChildOutboxForTurnTx(
+  tx: Database,
+  workspaceId: string,
+  session: Pick<
+    typeof schema.sessions.$inferSelect,
+    "id" | "accountId" | "parentSessionId" | "parentTurnId"
+  >,
+  turn: Pick<typeof schema.sessionTurns.$inferSelect, "id" | "accountId" | "sessionId">,
+): Promise<void> {
+  if (turn.accountId !== session.accountId || turn.sessionId !== session.id) {
+    throw new SessionControlInvariantError(
+      `Failed child turn ${turn.id} lost session ${session.id} ownership`,
+    );
+  }
+  await enqueueFailedChildOutboxTx(tx, workspaceId, session, {
+    turnId: turn.id,
+    dedupeKey: `child-completion:${turn.sessionId}:turn:${turn.id}`,
+  });
+}
+
+async function enqueueFailedChildOutboxWithoutTurnTx(
+  tx: Database,
+  workspaceId: string,
+  session: Pick<
+    typeof schema.sessions.$inferSelect,
+    "id" | "accountId" | "parentSessionId" | "parentTurnId"
+  >,
+  terminalSequence: number,
+): Promise<void> {
+  await enqueueFailedChildOutboxTx(tx, workspaceId, session, {
+    turnId: null,
+    dedupeKey: `child-completion:${session.id}:pre-claim:${terminalSequence}`,
+  });
+}
+
 type ChildTerminalResultPayload = Extract<
   SessionSystemUpdatePayload,
   { type: "child_terminal_result" }
@@ -53106,10 +53748,19 @@ export async function enqueueSessionWorkflowWakeInTransaction(
           : sql`${schema.sessionWorkflowWakeOutbox.controlRevision}`,
         reason: input.reason,
         attempts: 0,
-        // Coalescing a delayed retry must never postpone an already-due wake
-        // owned by another producer. A later revision makes the batch richer;
-        // it does not revoke the earlier delivery obligation.
-        nextAttemptAt: sql`least(${schema.sessionWorkflowWakeOutbox.nextAttemptAt}, ${nextAttemptAt.toISOString()}::timestamptz)`,
+        // Coalescing a delayed retry must never postpone an undelivered wake
+        // owned by another producer. Once every prior revision is delivered,
+        // however, this is a new obligation and must honor its own deadline;
+        // retaining the old (usually past) deadline would defeat backoff.
+        nextAttemptAt: sql`case
+          when ${schema.sessionWorkflowWakeOutbox.wakeRevision}
+            > ${schema.sessionWorkflowWakeOutbox.deliveredRevision}
+          then least(
+            ${schema.sessionWorkflowWakeOutbox.nextAttemptAt},
+            ${nextAttemptAt.toISOString()}::timestamptz
+          )
+          else ${nextAttemptAt.toISOString()}::timestamptz
+        end`,
         lastError: null,
         updatedAt: now,
       },
@@ -55307,7 +55958,6 @@ function mapSessionTurnForExecution(
 ): SessionTurnForExecution {
   return {
     ...mapSessionTurn(row),
-    turnInstructions: row.turnInstructions ?? null,
     initiatingHumanSubjectId: row.initiatingHumanSubjectId ?? null,
     personalConnectionDelegations: parsedPersonalConnectionDelegations(
       row.personalConnectionDelegations,