@opengeni/db 0.13.4 → 0.14.0

package/src/index.ts

@@ -16,6 +16,7 @@ import type {
   FileAsset,
   FileStatus,
   FileUploadStatus,
+  FirstPartyMcpToolName,
   HumanInputAnswer,
   HumanInputQuestion,
   HumanInputResponse,
@@ -113,6 +114,7 @@ import {
   RigChange as RigChangeContract,
   SessionGoal as SessionGoalContract,
   SessionSystemUpdatePayload,
+  sessionSystemUpdateBatchHistoryItem,
   HostEventExport as HostEventExportContract,
   HostEventExportBatch as HostEventExportBatchContract,
   HostExportConsumerId,
@@ -13888,6 +13890,7 @@ export type SessionCreateInput = {
   rigId?: string | null;
   rigVersionId?: string | null;
   firstPartyMcpPermissions?: Permission[] | null;
+  firstPartyMcpTools?: FirstPartyMcpToolName[] | null;
   instructions?: string | null;
   parentSessionId?: string | null;
   createIdempotencyKey?: string | null;
@@ -14288,6 +14291,7 @@ async function createSessionInTransaction(
       rigId: input.rigId ?? null,
       rigVersionId: input.rigVersionId ?? null,
       firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
+      firstPartyMcpTools: input.firstPartyMcpTools ?? null,
       instructions: input.instructions ?? null,
       parentSessionId: input.parentSessionId ?? null,
       createIdempotencyKey,
@@ -28985,7 +28989,7 @@ export async function materializeGoalContinuation(
               eq(schema.sessionSystemUpdates.workspaceId, input.workspaceId),
               eq(schema.sessionSystemUpdates.sessionId, input.sessionId),
               eq(schema.sessionSystemUpdates.kind, "agent_steer_instruction"),
-              inArray(schema.sessionSystemUpdates.state, ["pending", "deferred"]),
+              eq(schema.sessionSystemUpdates.state, "pending"),
             ),
           )
           .limit(1);
@@ -29148,6 +29152,7 @@ export async function materializeGoalContinuation(
           })
           .onConflictDoNothing({ target: schema.usageEvents.idempotencyKey });
 
+        const eventPreview = internalUpdateEventMember(update);
         const insertedEvents = await tx
           .insert(schema.sessionEvents)
           .values([
@@ -29158,11 +29163,13 @@ export async function materializeGoalContinuation(
               sequence: session.lastSequence + 1,
               type: "system.update.pending",
               payload: sanitizeEventPayload({
-                updateId: update.id,
-                kind: update.kind,
-                classification: update.classification,
-                sourceId: update.sourceId,
-                summary: update.summary,
+                updateId: eventPreview.id,
+                kind: eventPreview.kind,
+                classification: eventPreview.classification,
+                sourceId: eventPreview.sourceId,
+                sourceIdTruncated: eventPreview.sourceIdTruncated,
+                summary: eventPreview.summary,
+                summaryTruncated: eventPreview.summaryTruncated,
               }),
               occurredAt: now,
             },
@@ -29663,6 +29670,79 @@ export type SessionWorkTrigger = { kind: "next" } | { kind: "approval"; triggerE
 export const MAX_INTERNAL_UPDATE_BYTES = 64 * 1024;
 export const MAX_INTERNAL_UPDATE_BATCH_MEMBERS = 100;
 export const MAX_INTERNAL_UPDATE_BATCH_BYTES = 256 * 1024;
+const MAX_INTERNAL_UPDATE_EVENT_SUMMARY_BYTES = 512;
+const MAX_INTERNAL_UPDATE_EVENT_SOURCE_BYTES = 256;
+
+type BoundedSystemUpdate = Pick<
+  typeof schema.sessionSystemUpdates.$inferSelect,
+  "id" | "kind" | "classification" | "sourceId" | "summary" | "payload" | "lineage"
+>;
+
+function boundedInternalUpdateEventText(
+  value: string,
+  maxBytes: number,
+): {
+  text: string;
+  truncated: boolean;
+} {
+  if (Buffer.byteLength(value) <= maxBytes) return { text: value, truncated: false };
+  const suffix = "…";
+  const bodyBudget = maxBytes - Buffer.byteLength(suffix);
+  const bytes = Buffer.from(value);
+  let text = bytes.subarray(0, bodyBudget).toString("utf8");
+  if (text.endsWith("\uFFFD")) text = text.slice(0, -1);
+  return { text: `${text}${suffix}`, truncated: true };
+}
+
+function internalUpdateEventMember(update: BoundedSystemUpdate) {
+  const summary = boundedInternalUpdateEventText(
+    update.summary,
+    MAX_INTERNAL_UPDATE_EVENT_SUMMARY_BYTES,
+  );
+  const source = boundedInternalUpdateEventText(
+    update.sourceId,
+    MAX_INTERNAL_UPDATE_EVENT_SOURCE_BYTES,
+  );
+  return {
+    id: update.id,
+    kind: update.kind,
+    classification: update.classification,
+    sourceId: source.text,
+    sourceIdTruncated: source.truncated,
+    summary: summary.text,
+    summaryTruncated: summary.truncated,
+  };
+}
+
+function selectBoundedSystemUpdateBatch<T extends BoundedSystemUpdate>(updates: readonly T[]): T[] {
+  const selected: T[] = [];
+  let selectedBytes = 0;
+  for (const update of updates) {
+    const updateBytes = Buffer.byteLength(
+      JSON.stringify({
+        id: update.id,
+        kind: update.kind,
+        classification: update.classification,
+        sourceId: update.sourceId,
+        summary: update.summary,
+        payload: update.payload,
+        lineage: update.lineage,
+      }),
+    );
+    if (
+      selected.length >= MAX_INTERNAL_UPDATE_BATCH_MEMBERS ||
+      // One individually large canonical input must still make progress. The
+      // model/context boundary may reject it explicitly, but the queue cannot
+      // wedge forever merely because the coalescing target is smaller.
+      (selected.length > 0 && selectedBytes + updateBytes > MAX_INTERNAL_UPDATE_BATCH_BYTES)
+    ) {
+      break;
+    }
+    selected.push(update);
+    selectedBytes += updateBytes;
+  }
+  return selected;
+}
 
 export type ClaimSessionWorkForAttemptInput = {
   sessionId: string;
@@ -29708,7 +29788,10 @@ export async function claimSessionWorkForAttempt(
           count: number;
           lastSequence: number;
           triggerEventId: string | null;
+          historyItemId: string | null;
+          historyItem: Record<string, unknown> | null;
           updates: Array<typeof schema.sessionSystemUpdates.$inferSelect>;
+          events: Array<typeof schema.sessionEvents.$inferInsert>;
           event: typeof schema.sessionEvents.$inferInsert | null;
         }> => {
           const [agentSteer] = await tx
@@ -29718,7 +29801,7 @@ export async function claimSessionWorkForAttempt(
               and(
                 eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
                 eq(schema.sessionSystemUpdates.sessionId, sessionId),
-                inArray(schema.sessionSystemUpdates.state, ["pending", "deferred"]),
+                eq(schema.sessionSystemUpdates.state, "pending"),
                 eq(schema.sessionSystemUpdates.kind, "agent_steer_instruction"),
               ),
             )
@@ -29728,20 +29811,6 @@ export async function claimSessionWorkForAttempt(
             )
             .limit(1)
             .for("update");
-          if (agentSteer) {
-            await tx
-              .update(schema.sessionSystemUpdates)
-              .set({ state: "superseded" })
-              .where(
-                and(
-                  eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
-                  eq(schema.sessionSystemUpdates.sessionId, sessionId),
-                  eq(schema.sessionSystemUpdates.kind, "agent_steer_instruction"),
-                  inArray(schema.sessionSystemUpdates.state, ["pending", "deferred"]),
-                  ne(schema.sessionSystemUpdates.id, agentSteer.id),
-                ),
-              );
-          }
           const ordinary = await tx
             .select()
             .from(schema.sessionSystemUpdates)
@@ -29749,7 +29818,7 @@ export async function claimSessionWorkForAttempt(
               and(
                 eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
                 eq(schema.sessionSystemUpdates.sessionId, sessionId),
-                inArray(schema.sessionSystemUpdates.state, ["pending", "deferred"]),
+                eq(schema.sessionSystemUpdates.state, "pending"),
                 ne(schema.sessionSystemUpdates.kind, "agent_steer_instruction"),
               ),
             )
@@ -29765,12 +29834,15 @@ export async function claimSessionWorkForAttempt(
               count: 0,
               lastSequence: nextSequence - 1,
               triggerEventId: null,
+              historyItemId: null,
+              historyItem: null,
               updates: [],
+              events: [],
               event: null,
             };
           }
-          const deliverable: typeof updates = [];
-          let deliveredBytes = 0;
+          const validUpdates: typeof updates = [];
+          const cancelledUpdateIds: string[] = [];
           for (const update of updates) {
             const payload = update.payload;
             if (payload.type === "goal_continuation") {
@@ -29799,43 +29871,66 @@ export async function claimSessionWorkForAttempt(
                   .update(schema.sessionSystemUpdates)
                   .set({ state: "cancelled" })
                   .where(eq(schema.sessionSystemUpdates.id, update.id));
+                cancelledUpdateIds.push(update.id);
                 continue;
               }
             }
-            const updateBytes = Buffer.byteLength(
-              JSON.stringify({
-                id: update.id,
-                kind: update.kind,
-                classification: update.classification,
-                sourceId: update.sourceId,
-                summary: update.summary,
-                payload: update.payload,
-                lineage: update.lineage,
-              }),
-            );
-            if (
-              deliverable.length >= MAX_INTERNAL_UPDATE_BATCH_MEMBERS ||
-              deliveredBytes + updateBytes > MAX_INTERNAL_UPDATE_BATCH_BYTES
-            ) {
-              break;
-            }
-            deliverable.push(update);
-            deliveredBytes += updateBytes;
+            validUpdates.push(update);
           }
+          const deliverable = selectBoundedSystemUpdateBatch(validUpdates);
           if (deliverable.length === 0) {
+            const cancellationEvent =
+              cancelledUpdateIds.length > 0
+                ? {
+                    accountId,
+                    workspaceId,
+                    sessionId,
+                    // No receiving turn exists when every candidate was
+                    // cancelled before a model batch could be persisted.
+                    turnId: null,
+                    turnGeneration: null,
+                    turnAttemptId: null,
+                    turnAssociation: null,
+                    sequence: nextSequence,
+                    type: "system.update.cancelled" as const,
+                    payload: sanitizeEventPayload({
+                      updateIds: cancelledUpdateIds,
+                      count: cancelledUpdateIds.length,
+                      reason: "stale_goal_continuation",
+                    }),
+                    occurredAt,
+                  }
+                : null;
             return {
               count: 0,
-              lastSequence: nextSequence - 1,
+              lastSequence: cancellationEvent ? nextSequence : nextSequence - 1,
               triggerEventId: null,
+              historyItemId: null,
+              historyItem: null,
               updates: [],
+              events: cancellationEvent ? [cancellationEvent] : [],
               event: null,
             };
           }
+          // Inclusion gives the newest Steer first refusal on the bounded
+          // batch. Model ordering is deliberately the opposite: ordinary
+          // updates establish context, then the authoritative replacement
+          // direction is last so it cannot be overridden by an older goal or
+          // lifecycle notice.
+          const modelOrdered = [
+            ...deliverable.filter((update) => update.kind !== "agent_steer_instruction"),
+            ...deliverable.filter((update) => update.kind === "agent_steer_instruction"),
+          ];
+          const historyItemId = crypto.randomUUID();
+          const historyItem = sessionSystemUpdateBatchHistoryItem(
+            modelOrdered.map((update) => mapSessionSystemUpdate(update)),
+          ) as Record<string, unknown>;
           await tx
             .update(schema.sessionSystemUpdates)
             .set({
               state: "delivered",
               deliveredTurnId: turnId,
+              deliveredHistoryItemId: historyItemId,
               deliveredAt: occurredAt,
             })
             .where(
@@ -29849,6 +29944,27 @@ export async function claimSessionWorkForAttempt(
               ),
             );
           const eventId = triggerEventId ?? crypto.randomUUID();
+          let sequence = nextSequence - 1;
+          const events: Array<typeof schema.sessionEvents.$inferInsert> = [];
+          if (cancelledUpdateIds.length > 0) {
+            events.push({
+              accountId,
+              workspaceId,
+              sessionId,
+              turnId,
+              turnGeneration,
+              turnAttemptId: input.attemptId,
+              turnAssociation: "current",
+              sequence: ++sequence,
+              type: "system.update.cancelled",
+              payload: sanitizeEventPayload({
+                updateIds: cancelledUpdateIds,
+                count: cancelledUpdateIds.length,
+                reason: "stale_goal_continuation",
+              }),
+              occurredAt,
+            });
+          }
           const event: typeof schema.sessionEvents.$inferInsert = {
             id: eventId,
             accountId,
@@ -29858,24 +29974,64 @@ export async function claimSessionWorkForAttempt(
             turnGeneration,
             turnAttemptId: input.attemptId,
             turnAssociation: "current",
-            sequence: nextSequence,
+            sequence: ++sequence,
             type: "system.update.delivered",
             payload: sanitizeEventPayload({
               updateIds: deliverable.map((update) => update.id),
+              historyItemId,
               count: deliverable.length,
               classifications: [...new Set(deliverable.map((update) => update.classification))],
+              members: modelOrdered.map(internalUpdateEventMember),
             }),
             occurredAt,
           };
+          events.push(event);
           return {
             count: deliverable.length,
-            lastSequence: nextSequence,
+            lastSequence: sequence,
             triggerEventId: eventId,
+            historyItemId,
+            historyItem,
             updates: deliverable,
+            events,
             event,
           };
         };
 
+        const persistDeliveredUpdateBatch = async (
+          delivered: Awaited<ReturnType<typeof deliverPendingUpdates>>,
+          accountId: string,
+          turnId: string,
+        ): Promise<void> => {
+          if (!delivered.historyItemId || !delivered.historyItem) {
+            if (delivered.count !== 0) {
+              throw new Error("Delivered machine-input batch has no model-memory item");
+            }
+            return;
+          }
+          const [{ position } = { position: 0 }] = await tx
+            .select({
+              position: sql<number>`coalesce(max(${schema.sessionHistoryItems.position}), -1) + 1`,
+            })
+            .from(schema.sessionHistoryItems)
+            .where(
+              and(
+                eq(schema.sessionHistoryItems.workspaceId, workspaceId),
+                eq(schema.sessionHistoryItems.sessionId, sessionId),
+              ),
+            );
+          await tx.insert(schema.sessionHistoryItems).values({
+            id: delivered.historyItemId,
+            accountId,
+            workspaceId,
+            sessionId,
+            turnId,
+            position: Number(position),
+            item: sanitizeModelPayload(delivered.historyItem),
+            producerCodexCredentialId: null,
+          });
+        };
+
         // Capacity settlement and resume use session -> turn after their
         // workspace rotation lock. Claiming must preserve that shared order:
         // taking a queued turn first can deadlock with a settlement that owns
@@ -30211,7 +30367,7 @@ export async function claimSessionWorkForAttempt(
               eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
               eq(schema.sessionSystemUpdates.sessionId, sessionId),
               eq(schema.sessionSystemUpdates.kind, "agent_steer_instruction"),
-              inArray(schema.sessionSystemUpdates.state, ["pending", "deferred"]),
+              eq(schema.sessionSystemUpdates.state, "pending"),
             ),
           )
           .orderBy(
@@ -30448,6 +30604,22 @@ export async function claimSessionWorkForAttempt(
             triggerEventId,
           );
           if (delivered.count === 0) {
+            if (delivered.events.length > 0) {
+              await tx.insert(schema.sessionEvents).values(delivered.events);
+              await tx
+                .update(schema.sessions)
+                .set({
+                  status: "idle",
+                  lastSequence: delivered.lastSequence,
+                  updatedAt: now,
+                })
+                .where(
+                  and(
+                    eq(schema.sessions.workspaceId, workspaceId),
+                    eq(schema.sessions.id, sessionId),
+                  ),
+                );
+            }
             return { action: "unclaimed", reason: "no-work" };
           }
           const goalUpdate = delivered.updates.find(
@@ -30634,9 +30806,10 @@ export async function claimSessionWorkForAttempt(
             })
             .returning();
           if (!internalTurn) throw new Error("Failed to create internal update inference");
+          await persistDeliveredUpdateBatch(delivered, session.accountId, internalTurn.id);
           await registerAttempt(internalTurn);
           if (!delivered.event) throw new Error("Delivered update batch has no durable event");
-          await tx.insert(schema.sessionEvents).values(delivered.event);
+          await tx.insert(schema.sessionEvents).values(delivered.events);
           if (goalUpdate && typeof goalUpdate.payload.goalId === "string") {
             await tx
               .update(schema.sessionGoals)
@@ -30753,8 +30926,9 @@ export async function claimSessionWorkForAttempt(
           session.lastSequence + 1,
           now,
         );
-        if (delivered.event) {
-          await tx.insert(schema.sessionEvents).values(delivered.event);
+        await persistDeliveredUpdateBatch(delivered, session.accountId, row.id);
+        if (delivered.events.length > 0) {
+          await tx.insert(schema.sessionEvents).values(delivered.events);
         }
         await tx
           .update(schema.sessions)
@@ -30998,6 +31172,196 @@ export async function markSessionAttemptQuiesced(
   });
 }
 
+export type ReconcileSessionAttemptQuiescenceResult =
+  | { action: "quiesced"; events: SessionEvent[] }
+  | { action: "pending"; events: [] }
+  | { action: "stale"; events: [] };
+
+export type SessionAttemptActivityRef = {
+  workflowId: string;
+  workflowRunId: string;
+  activityId: string;
+  quiesced: boolean;
+};
+
+export async function getSessionAttemptActivityRef(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    attemptId: string;
+    temporalWorkflowId: string;
+  },
+): Promise<SessionAttemptActivityRef | null> {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [attempt] = await scopedDb
+        .select({
+          workflowId: schema.sessionTurnAttempts.temporalWorkflowId,
+          workflowRunId: schema.sessionTurnAttempts.temporalWorkflowRunId,
+          activityId: schema.sessionTurnAttempts.temporalActivityId,
+          quiescedAt: schema.sessionTurnAttempts.quiescedAt,
+        })
+        .from(schema.sessionTurnAttempts)
+        .where(
+          and(
+            eq(schema.sessionTurnAttempts.accountId, input.accountId),
+            eq(schema.sessionTurnAttempts.workspaceId, input.workspaceId),
+            eq(schema.sessionTurnAttempts.sessionId, input.sessionId),
+            eq(schema.sessionTurnAttempts.id, input.attemptId),
+            eq(schema.sessionTurnAttempts.temporalWorkflowId, input.temporalWorkflowId),
+          ),
+        )
+        .limit(1);
+      return attempt
+        ? {
+            workflowId: attempt.workflowId,
+            workflowRunId: attempt.workflowRunId,
+            activityId: attempt.activityId,
+            quiesced: attempt.quiescedAt !== null,
+          }
+        : null;
+    },
+  );
+}
+
+/**
+ * Recover the quiescence receipt when the original activity disappeared after
+ * its attempt was durably interrupted. The caller first proves through
+ * Temporal that the exact activity is absent or its server-owned heartbeat
+ * lease expired. The closed attempt then cannot admit another workspace writer,
+ * and every writer it did admit (including retained-process child writes) must
+ * carry a physical settlement before the ordinary receipt transaction is
+ * allowed to run.
+ */
+export async function reconcileSessionAttemptQuiescence(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    attemptId: string;
+    temporalWorkflowId: string;
+    temporalWorkflowRunId: string;
+    temporalActivityId: string;
+    activitySettled: boolean;
+  },
+): Promise<ReconcileSessionAttemptQuiescenceResult> {
+  const eligibility = await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.execute<{
+        account_id: string;
+        state: string;
+        quiesced_at: Date | string | null;
+        temporal_workflow_id: string;
+        temporal_workflow_run_id: string;
+        temporal_activity_id: string;
+        interruption_settled: boolean;
+        interruption_pending: boolean;
+        writer_pending: boolean;
+      }>(sql`
+        select
+          attempt.account_id,
+          attempt.state,
+          attempt.quiesced_at,
+          attempt.temporal_workflow_id,
+          attempt.temporal_workflow_run_id,
+          attempt.temporal_activity_id,
+          exists (
+            select 1
+            from session_attempt_interruptions interruption
+            where interruption.workspace_id = attempt.workspace_id
+              and interruption.session_id = attempt.session_id
+              and interruption.attempt_id = attempt.id
+              and interruption.state in ('settled', 'rejected_stale')
+          ) as interruption_settled,
+          exists (
+            select 1
+            from session_attempt_interruptions interruption
+            where interruption.workspace_id = attempt.workspace_id
+              and interruption.session_id = attempt.session_id
+              and interruption.attempt_id = attempt.id
+              and interruption.state in ('pending', 'delivered', 'acknowledged')
+          ) as interruption_pending,
+          (
+            exists (
+              select 1
+              from sandbox_workspace_mutation_admissions admission
+              where admission.account_id = attempt.account_id
+                and admission.workspace_id = attempt.workspace_id
+                and admission.session_id = attempt.session_id
+                and admission.settled_at is null
+                and (
+                  admission.attempt_id = attempt.id
+                  or (
+                    admission.actor_kind = 'process'
+                    and exists (
+                      select 1
+                      from sandbox_retained_processes process
+                      where process.account_id = attempt.account_id
+                        and process.workspace_id = attempt.workspace_id
+                        and process.session_id = attempt.session_id
+                        and process.id = admission.actor_id
+                        and process.owner_attempt_id = attempt.id
+                    )
+                  )
+                )
+            )
+            or exists (
+              select 1
+              from sandbox_retained_processes process
+              where process.account_id = attempt.account_id
+                and process.workspace_id = attempt.workspace_id
+                and process.session_id = attempt.session_id
+                and process.owner_attempt_id = attempt.id
+                and process.state = 'active'
+            )
+          ) as writer_pending
+        from session_turn_attempts attempt
+        where attempt.account_id = ${input.accountId}
+          and attempt.workspace_id = ${input.workspaceId}
+          and attempt.session_id = ${input.sessionId}
+          and attempt.id = ${input.attemptId}
+        limit 1
+      `);
+      return rows[0] ?? null;
+    },
+  );
+  if (
+    !eligibility ||
+    eligibility.account_id !== input.accountId ||
+    eligibility.temporal_workflow_id !== input.temporalWorkflowId ||
+    eligibility.temporal_workflow_run_id !== input.temporalWorkflowRunId ||
+    eligibility.temporal_activity_id !== input.temporalActivityId ||
+    eligibility.state !== "closed" ||
+    !eligibility.interruption_settled ||
+    eligibility.interruption_pending
+  ) {
+    return { action: "stale", events: [] };
+  }
+  if (eligibility.quiesced_at) {
+    return { action: "quiesced", events: [] };
+  }
+  if (!input.activitySettled || eligibility.writer_pending) {
+    return { action: "pending", events: [] };
+  }
+  const events = await markSessionAttemptQuiesced(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    attemptId: input.attemptId,
+    temporalWorkflowId: input.temporalWorkflowId,
+    temporalWorkflowRunId: input.temporalWorkflowRunId,
+    temporalActivityId: input.temporalActivityId,
+  });
+  return { action: "quiesced", events };
+}
+
 /**
  * Settle every durable interruption cause for one exact first-class attempt.
  * Steer wins the logical-turn fate when causes coexist; effective control after
@@ -31168,13 +31532,6 @@ export async function settleSessionAttemptInterruptions(
         outcome,
         closedAt: now,
       });
-      await requeueInterruptedSessionSystemUpdatesForTurnTx(
-        tx as unknown as Database,
-        workspaceId,
-        sessionId,
-        turn.id,
-      );
-
       const eventValues: Array<typeof schema.sessionEvents.$inferInsert> = steer
         ? [
             {
@@ -32459,10 +32816,45 @@ export async function applySessionTurnSettlement(
           },
         }),
       );
+      const settledMachineInputs = ["completed", "failed", "cancelled", "superseded"].includes(
+        input.turnStatus,
+      )
+        ? await tx
+            .select({
+              id: schema.sessionSystemUpdates.id,
+              historyItemId: schema.sessionSystemUpdates.deliveredHistoryItemId,
+            })
+            .from(schema.sessionSystemUpdates)
+            .where(
+              and(
+                eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
+                eq(schema.sessionSystemUpdates.sessionId, input.sessionId),
+                eq(schema.sessionSystemUpdates.deliveredTurnId, input.turnId),
+                eq(schema.sessionSystemUpdates.state, "delivered"),
+              ),
+            )
+            .orderBy(
+              asc(schema.sessionSystemUpdates.createdAt),
+              asc(schema.sessionSystemUpdates.id),
+            )
+        : [];
+      const machineInputSettlementEvent: AppendEventInput | null =
+        settledMachineInputs.length > 0
+          ? {
+              type: "system.update.settled",
+              payload: {
+                updateIds: settledMachineInputs.map((update) => update.id),
+                count: settledMachineInputs.length,
+                historyItemId: settledMachineInputs[0]!.historyItemId,
+                outcome: input.turnStatus,
+              },
+            }
+          : null;
       const settlementEvents = [
         ...(recordingEvent ? [recordingEvent] : []),
         ...(compactionRequestEvent ? [compactionRequestEvent] : []),
         ...terminalHumanInputEvents,
+        ...(machineInputSettlementEvent ? [machineInputSettlementEvent] : []),
         ...input.events,
       ];
       const values = settlementEvents.map((event) => {
@@ -32545,21 +32937,6 @@ export async function applySessionTurnSettlement(
           turn,
         );
       }
-      if (input.turnStatus === "failed") {
-        await deferFailedSessionSystemUpdatesForTurnTx(
-          tx as unknown as Database,
-          workspaceId,
-          input.sessionId,
-          input.turnId,
-        );
-      } else if (["cancelled", "superseded"].includes(input.turnStatus)) {
-        await requeueInterruptedSessionSystemUpdatesForTurnTx(
-          tx as unknown as Database,
-          workspaceId,
-          input.sessionId,
-          input.turnId,
-        );
-      }
       await tx
         .update(schema.sessions)
         .set({
@@ -32843,14 +33220,6 @@ export async function settleCodexCredentialLeaseLoss(
               eq(schema.sessions.activeTurnId, input.turnId),
             ),
           );
-        if (!input.checkpointDurable) {
-          await deferFailedSessionSystemUpdatesForTurnTx(
-            tx as unknown as Database,
-            input.workspaceId,
-            input.sessionId,
-            input.turnId,
-          );
-        }
         await tx.execute(sql`
           delete from codex_credential_leases
           where account_id = ${input.accountId}
@@ -33794,11 +34163,34 @@ export async function getSessionQueueSnapshot(
         ),
       )
       .orderBy(asc(schema.sessionTurns.position), asc(schema.sessionTurns.createdAt));
+    const pendingInputs = await scopedDb
+      .select()
+      .from(schema.sessionSystemUpdates)
+      .where(
+        and(
+          eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
+          eq(schema.sessionSystemUpdates.sessionId, sessionId),
+          eq(schema.sessionSystemUpdates.state, "pending"),
+        ),
+      )
+      .orderBy(
+        sql`case when ${schema.sessionSystemUpdates.kind} = 'agent_steer_instruction' then 0 else 1 end`,
+        asc(schema.sessionSystemUpdates.createdAt),
+        asc(schema.sessionSystemUpdates.id),
+      );
     const latestInterruption = await latestSessionAttemptInterruption(
       scopedDb,
       workspaceId,
       sessionId,
     );
+    const items = rows.map(mapSessionTurn);
+    const nextInputBatch = selectBoundedSystemUpdateBatch(pendingInputs);
+    const hasPendingAgentSteer = pendingInputs.some(
+      (update) => update.kind === "agent_steer_instruction",
+    );
+    const attachmentTurn = hasPendingAgentSteer
+      ? items.find((turn) => turn.metadata.delivery === "steer")
+      : items[0];
     return {
       version: session.queueVersion,
       effectiveControl: serializeEffectiveSessionControl(effectiveControl),
@@ -33806,7 +34198,26 @@ export async function getSessionQueueSnapshot(
         latestInterruption !== null &&
         latestInterruption.interruptionState !== "rejected_stale" &&
         latestInterruption.quiescedAt === null,
-      items: rows.map(mapSessionTurn),
+      items,
+      pendingInputs: pendingInputs.map((update) => {
+        const canonical = mapSessionSystemUpdate(update);
+        return {
+          id: canonical.id,
+          sessionId: canonical.sessionId,
+          kind: canonical.kind,
+          classification: canonical.classification,
+          sourceId: boundedInternalUpdateEventText(canonical.sourceId, 256).text,
+          summary: boundedInternalUpdateEventText(canonical.summary, 512).text,
+          createdAt: canonical.createdAt,
+        };
+      }),
+      pendingInputAttachment:
+        attachmentTurn && nextInputBatch.length > 0
+          ? {
+              turnId: attachmentTurn.id,
+              inputIds: nextInputBatch.map((update) => update.id),
+            }
+          : null,
     };
   });
 }
@@ -34155,12 +34566,13 @@ export async function claimPendingSessionWorkflowWakes(
 
 /**
  * Acknowledge an immediate post-commit signal only after it cannot strand an
- * accepted Agent Steer. Temporal accepting a signal is transport evidence, not
- * proof that a closing workflow observed Postgres or admitted its pending
- * direction. While active control still has an actionable Agent Steer, retain
- * the revision so the bounded outbox dispatcher retries signalWithStart. The
- * attempt-fenced claim consumes the update once; a real Pause is the typed
- * blocker and may acknowledge this revision because Resume commits a new one.
+ * accepted direction or an interrupted attempt awaiting writer-set proof.
+ * Temporal accepting a signal is transport evidence, not proof that a closing
+ * workflow observed Postgres. While active control still has an actionable
+ * Agent Steer or pending quiescence, retain the revision so the bounded outbox
+ * dispatcher retries signalWithStart. The attempt-fenced claim consumes an
+ * Agent Steer once; a real Pause is the typed blocker and may acknowledge this
+ * revision because Resume commits a new one.
  *
  * An older sender may advance only its own revision; it cannot clear a claim or
  * failure state belonging to a newer revision. The control -> workspace ->
@@ -34169,7 +34581,10 @@ export async function claimPendingSessionWorkflowWakes(
  */
 export type SessionWorkflowWakeDeliveryResult =
   | { action: "acknowledged" }
-  | { action: "pending_admission"; blocker: "pending_agent_steer" };
+  | {
+      action: "pending_admission";
+      blocker: "pending_agent_steer" | "pending_quiescence";
+    };
 
 export async function markSessionWorkflowWakeDelivered(
   db: Database,
@@ -34209,6 +34624,35 @@ export async function markSessionWorkflowWakeDelivered(
           if (pendingAgentSteer) {
             return { action: "pending_admission", blocker: "pending_agent_steer" } as const;
           }
+          const [pendingQuiescence] = await tx
+            .select({ id: schema.sessionTurnAttempts.id })
+            .from(schema.sessionTurnAttempts)
+            .innerJoin(
+              schema.sessionAttemptInterruptions,
+              and(
+                eq(
+                  schema.sessionAttemptInterruptions.workspaceId,
+                  schema.sessionTurnAttempts.workspaceId,
+                ),
+                eq(
+                  schema.sessionAttemptInterruptions.sessionId,
+                  schema.sessionTurnAttempts.sessionId,
+                ),
+                eq(schema.sessionAttemptInterruptions.attemptId, schema.sessionTurnAttempts.id),
+              ),
+            )
+            .where(
+              and(
+                eq(schema.sessionTurnAttempts.workspaceId, input.workspaceId),
+                eq(schema.sessionTurnAttempts.sessionId, input.sessionId),
+                isNull(schema.sessionTurnAttempts.quiescedAt),
+                inArray(schema.sessionAttemptInterruptions.state, ["settled", "rejected_stale"]),
+              ),
+            )
+            .limit(1);
+          if (pendingQuiescence) {
+            return { action: "pending_admission", blocker: "pending_quiescence" } as const;
+          }
         }
         const [row] = await tx
           .update(schema.sessionWorkflowWakeOutbox)
@@ -34443,55 +34887,6 @@ export async function addSessionSystemUpdate(
   return await addSessionSystemUpdateWithSourceMutation(db, input, async () => undefined);
 }
 
-async function requeueInterruptedSessionSystemUpdatesForTurnTx(
-  tx: Database,
-  workspaceId: string,
-  sessionId: string,
-  turnId: string,
-): Promise<void> {
-  await tx
-    .update(schema.sessionSystemUpdates)
-    .set({ state: "pending", deliveredTurnId: null, deliveredAt: null })
-    .where(
-      and(
-        eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
-        eq(schema.sessionSystemUpdates.sessionId, sessionId),
-        eq(schema.sessionSystemUpdates.deliveredTurnId, turnId),
-        eq(schema.sessionSystemUpdates.state, "delivered"),
-      ),
-    );
-}
-
-/**
- * A failed internal-only inference must not manufacture another inference by
- * making its inputs immediately runnable again. Preserve ordinary internal
- * updates as deferred input for the next real prompt/new update. Goal
- * continuation notices are derivable from the durable goal and become terminal
- * so the goal evaluator can pause or synthesize the next valid continuation.
- */
-async function deferFailedSessionSystemUpdatesForTurnTx(
-  tx: Database,
-  workspaceId: string,
-  sessionId: string,
-  turnId: string,
-): Promise<void> {
-  await tx
-    .update(schema.sessionSystemUpdates)
-    .set({
-      state: sql`case when ${schema.sessionSystemUpdates.payload} ->> 'type' = 'goal_continuation' then 'failed' else 'deferred' end`,
-      deliveredTurnId: null,
-      deliveredAt: null,
-    })
-    .where(
-      and(
-        eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
-        eq(schema.sessionSystemUpdates.sessionId, sessionId),
-        eq(schema.sessionSystemUpdates.deliveredTurnId, turnId),
-        eq(schema.sessionSystemUpdates.state, "delivered"),
-      ),
-    );
-}
-
 /**
  * Persist one internal update without fabricating a user prompt or queue row.
  * Dedupe and any producer/outbox mutation commit in the same transaction.
@@ -34593,6 +34988,7 @@ export async function addSessionSystemUpdateWithSourceMutation(
         }
 
         const now = new Date();
+        const eventPreview = internalUpdateEventMember(inserted);
         const [event] = await tx
           .insert(schema.sessionEvents)
           .values({
@@ -34602,11 +34998,13 @@ export async function addSessionSystemUpdateWithSourceMutation(
             sequence: session.lastSequence + 1,
             type: "system.update.pending",
             payload: sanitizeEventPayload({
-              updateId: inserted.id,
-              kind: input.kind,
-              classification: input.classification,
-              sourceId: input.sourceId,
-              summary: input.summary,
+              updateId: eventPreview.id,
+              kind: eventPreview.kind,
+              classification: eventPreview.classification,
+              sourceId: eventPreview.sourceId,
+              sourceIdTruncated: eventPreview.sourceIdTruncated,
+              summary: eventPreview.summary,
+              summaryTruncated: eventPreview.summaryTruncated,
             }),
             occurredAt: now,
           })
@@ -34657,7 +35055,7 @@ export async function listOutstandingSessionSystemUpdates(
         and(
           eq(schema.sessionSystemUpdates.workspaceId, workspaceId),
           eq(schema.sessionSystemUpdates.sessionId, sessionId),
-          inArray(schema.sessionSystemUpdates.state, ["pending", "deferred"]),
+          eq(schema.sessionSystemUpdates.state, "pending"),
         ),
       )
       .orderBy(asc(schema.sessionSystemUpdates.createdAt), asc(schema.sessionSystemUpdates.id));
@@ -34713,6 +35111,7 @@ function mapSessionSystemUpdate(
     lineage: row.lineage,
     state: row.state as SessionSystemUpdateState,
     deliveredTurnId: row.deliveredTurnId,
+    deliveredHistoryItemId: row.deliveredHistoryItemId,
     deliveredAt: row.deliveredAt?.toISOString() ?? null,
     createdAt: row.createdAt.toISOString(),
   };
@@ -35590,6 +35989,7 @@ function mapSession(
     rigId: row.rigId ?? null,
     rigVersionId: row.rigVersionId ?? null,
     firstPartyMcpPermissions: (row.firstPartyMcpPermissions as Permission[] | null) ?? null,
+    firstPartyMcpTools: (row.firstPartyMcpTools as FirstPartyMcpToolName[] | null) ?? null,
     mcpServers,
     parentSessionId: row.parentSessionId ?? null,
     rootSessionId: row.rootSessionId,