@opengeni/db 0.13.4 → 0.14.0

package/dist/index.js

@@ -76,7 +76,7 @@ import {
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces
-} from "./chunk-IQOXTFKA.js";
+} from "./chunk-PQKVUWQW.js";
 import {
   migrate,
   runMigrations
@@ -119,6 +119,7 @@ import {
   RigChange as RigChangeContract,
   SessionGoal as SessionGoalContract,
   SessionSystemUpdatePayload,
+  sessionSystemUpdateBatchHistoryItem,
   HostEventExport as HostEventExportContract,
   HostEventExportBatch as HostEventExportBatchContract,
   HostExportConsumerId,
@@ -2892,14 +2893,6 @@ async function supersedeSessionCurrentDirectionInTransaction(db, input) {
     finishedAt: now,
     updatedAt: now
   }).where(eq5(sessionTurns.id, current.id));
-  await db.update(sessionSystemUpdates).set({ state: "pending", deliveredTurnId: null, deliveredAt: null }).where(
-    and5(
-      eq5(sessionSystemUpdates.workspaceId, input.workspaceId),
-      eq5(sessionSystemUpdates.sessionId, input.sessionId),
-      eq5(sessionSystemUpdates.deliveredTurnId, current.id),
-      eq5(sessionSystemUpdates.state, "delivered")
-    )
-  );
   if (current.status === "waiting_capacity") {
     await db.update(codexCapacityWaiters).set({ status: "superseded", updatedAt: now }).where(
       and5(
@@ -4186,14 +4179,14 @@ async function steerAgentSessionInTransaction(db, input) {
     controlRevision: resumed.revision,
     lastSequence: session.lastSequence
   });
-  await db.update(sessionSystemUpdates).set({ state: "superseded" }).where(
+  const supersededUpdates = await db.update(sessionSystemUpdates).set({ state: "superseded" }).where(
     and5(
       eq5(sessionSystemUpdates.workspaceId, input.workspaceId),
       eq5(sessionSystemUpdates.sessionId, input.targetSessionId),
       eq5(sessionSystemUpdates.kind, "agent_steer_instruction"),
-      inArray2(sessionSystemUpdates.state, ["pending", "deferred"])
+      eq5(sessionSystemUpdates.state, "pending")
     )
-  );
+  ).returning({ id: sessionSystemUpdates.id });
   const now = /* @__PURE__ */ new Date();
   const [update] = await db.insert(sessionSystemUpdates).values({
     accountId: input.accountId,
@@ -4252,6 +4245,22 @@ async function steerAgentSessionInTransaction(db, input) {
       },
       occurredAt: now
     },
+    ...supersededUpdates.length > 0 ? [
+      {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.targetSessionId,
+        sequence: ++sequence,
+        type: "system.update.superseded",
+        payload: {
+          updateIds: supersededUpdates.map((entry) => entry.id),
+          count: supersededUpdates.length,
+          replacementUpdateId: update.id,
+          reason: "newer_agent_steer"
+        },
+        occurredAt: now
+      }
+    ] : [],
     {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -13747,6 +13756,7 @@ async function createSessionInTransaction(tx, input, id) {
     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,
@@ -22213,7 +22223,7 @@ async function materializeGoalContinuation(db, input) {
           eq7(sessionSystemUpdates.workspaceId, input.workspaceId),
           eq7(sessionSystemUpdates.sessionId, input.sessionId),
           eq7(sessionSystemUpdates.kind, "agent_steer_instruction"),
-          inArray3(sessionSystemUpdates.state, ["pending", "deferred"])
+          eq7(sessionSystemUpdates.state, "pending")
         )
       ).limit(1);
       if (pendingSteer) {
@@ -22336,6 +22346,7 @@ async function materializeGoalContinuation(db, input) {
         idempotencyKey: `agent_run.created:goal:${input.workspaceId}:${decision.goal.id}:${goalWakeRevision}`,
         occurredAt: now
       }).onConflictDoNothing({ target: usageEvents.idempotencyKey });
+      const eventPreview = internalUpdateEventMember(update);
       const insertedEvents = await tx.insert(sessionEvents).values([
         {
           accountId: session.accountId,
@@ -22344,11 +22355,13 @@ async function materializeGoalContinuation(db, input) {
           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
         },
@@ -22729,6 +22742,62 @@ async function enqueueSessionTurn(db, input) {
 var MAX_INTERNAL_UPDATE_BYTES = 64 * 1024;
 var MAX_INTERNAL_UPDATE_BATCH_MEMBERS = 100;
 var MAX_INTERNAL_UPDATE_BATCH_BYTES = 256 * 1024;
+var MAX_INTERNAL_UPDATE_EVENT_SUMMARY_BYTES = 512;
+var MAX_INTERNAL_UPDATE_EVENT_SOURCE_BYTES = 256;
+function boundedInternalUpdateEventText(value, maxBytes) {
+  if (Buffer.byteLength(value) <= maxBytes) return { text: value, truncated: false };
+  const suffix = "\u2026";
+  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) {
+  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(updates) {
+  const selected = [];
+  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;
+}
 async function claimSessionWorkForAttempt(db, workspaceId, input) {
   const { sessionId, workflowId } = input;
   return await withWorkspaceRls(
@@ -22740,29 +22809,18 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           and7(
             eq7(sessionSystemUpdates.workspaceId, workspaceId),
             eq7(sessionSystemUpdates.sessionId, sessionId),
-            inArray3(sessionSystemUpdates.state, ["pending", "deferred"]),
+            eq7(sessionSystemUpdates.state, "pending"),
             eq7(sessionSystemUpdates.kind, "agent_steer_instruction")
           )
         ).orderBy(
           desc2(sessionSystemUpdates.createdAt),
           desc2(sessionSystemUpdates.id)
         ).limit(1).for("update");
-        if (agentSteer) {
-          await tx.update(sessionSystemUpdates).set({ state: "superseded" }).where(
-            and7(
-              eq7(sessionSystemUpdates.workspaceId, workspaceId),
-              eq7(sessionSystemUpdates.sessionId, sessionId),
-              eq7(sessionSystemUpdates.kind, "agent_steer_instruction"),
-              inArray3(sessionSystemUpdates.state, ["pending", "deferred"]),
-              ne(sessionSystemUpdates.id, agentSteer.id)
-            )
-          );
-        }
         const ordinary = await tx.select().from(sessionSystemUpdates).where(
           and7(
             eq7(sessionSystemUpdates.workspaceId, workspaceId),
             eq7(sessionSystemUpdates.sessionId, sessionId),
-            inArray3(sessionSystemUpdates.state, ["pending", "deferred"]),
+            eq7(sessionSystemUpdates.state, "pending"),
             ne(sessionSystemUpdates.kind, "agent_steer_instruction")
           )
         ).orderBy(
@@ -22775,12 +22833,15 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
             count: 0,
             lastSequence: nextSequence - 1,
             triggerEventId: null,
+            historyItemId: null,
+            historyItem: null,
             updates: [],
+            events: [],
             event: null
           };
         }
-        const deliverable = [];
-        let deliveredBytes = 0;
+        const validUpdates = [];
+        const cancelledUpdateIds = [];
         for (const update of updates) {
           const payload = update.payload;
           if (payload.type === "goal_continuation") {
@@ -22798,38 +22859,56 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
             ).for("update").limit(1) : [];
             if (!goal || goal.status !== "active" || goal.version !== goalVersion) {
               await tx.update(sessionSystemUpdates).set({ state: "cancelled" }).where(eq7(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",
+            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
           };
         }
+        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))
+        );
         await tx.update(sessionSystemUpdates).set({
           state: "delivered",
           deliveredTurnId: turnId,
+          deliveredHistoryItemId: historyItemId,
           deliveredAt: occurredAt
         }).where(
           and7(
@@ -22842,6 +22921,27 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           )
         );
         const eventId = triggerEventId ?? crypto.randomUUID();
+        let sequence = nextSequence - 1;
+        const events = [];
+        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 = {
           id: eventId,
           accountId,
@@ -22851,23 +22951,55 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           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))]
+            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 (delivered2, accountId, turnId) => {
+        if (!delivered2.historyItemId || !delivered2.historyItem) {
+          if (delivered2.count !== 0) {
+            throw new Error("Delivered machine-input batch has no model-memory item");
+          }
+          return;
+        }
+        const [{ position } = { position: 0 }] = await tx.select({
+          position: sql4`coalesce(max(${sessionHistoryItems.position}), -1) + 1`
+        }).from(sessionHistoryItems).where(
+          and7(
+            eq7(sessionHistoryItems.workspaceId, workspaceId),
+            eq7(sessionHistoryItems.sessionId, sessionId)
+          )
+        );
+        await tx.insert(sessionHistoryItems).values({
+          id: delivered2.historyItemId,
+          accountId,
+          workspaceId,
+          sessionId,
+          turnId,
+          position: Number(position),
+          item: sanitizeModelPayload(delivered2.historyItem),
+          producerCodexCredentialId: null
+        });
+      };
       const workspaceControl = await lockWorkspaceInferenceControl(
         tx,
         workspaceId,
@@ -23113,7 +23245,7 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           eq7(sessionSystemUpdates.workspaceId, workspaceId),
           eq7(sessionSystemUpdates.sessionId, sessionId),
           eq7(sessionSystemUpdates.kind, "agent_steer_instruction"),
-          inArray3(sessionSystemUpdates.state, ["pending", "deferred"])
+          eq7(sessionSystemUpdates.state, "pending")
         )
       ).orderBy(
         desc2(sessionSystemUpdates.createdAt),
@@ -23291,6 +23423,19 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           triggerEventId
         );
         if (delivered2.count === 0) {
+          if (delivered2.events.length > 0) {
+            await tx.insert(sessionEvents).values(delivered2.events);
+            await tx.update(sessions).set({
+              status: "idle",
+              lastSequence: delivered2.lastSequence,
+              updatedAt: now2
+            }).where(
+              and7(
+                eq7(sessions.workspaceId, workspaceId),
+                eq7(sessions.id, sessionId)
+              )
+            );
+          }
           return { action: "unclaimed", reason: "no-work" };
         }
         const goalUpdate = delivered2.updates.find(
@@ -23429,9 +23574,10 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
           startedAt: now2
         }).returning();
         if (!internalTurn) throw new Error("Failed to create internal update inference");
+        await persistDeliveredUpdateBatch(delivered2, session.accountId, internalTurn.id);
         await registerAttempt(internalTurn);
         if (!delivered2.event) throw new Error("Delivered update batch has no durable event");
-        await tx.insert(sessionEvents).values(delivered2.event);
+        await tx.insert(sessionEvents).values(delivered2.events);
         if (goalUpdate && typeof goalUpdate.payload.goalId === "string") {
           await tx.update(sessionGoals).set({ lastContinuationTurnId: internalTurn.id, updatedAt: now2 }).where(
             and7(
@@ -23528,8 +23674,9 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
         session.lastSequence + 1,
         now
       );
-      if (delivered.event) {
-        await tx.insert(sessionEvents).values(delivered.event);
+      await persistDeliveredUpdateBatch(delivered, session.accountId, row.id);
+      if (delivered.events.length > 0) {
+        await tx.insert(sessionEvents).values(delivered.events);
       }
       await tx.update(sessions).set({
         status: "running",
@@ -23673,6 +23820,127 @@ async function markSessionAttemptQuiesced(db, input) {
     return [mapEvent2(event)];
   });
 }
+async function getSessionAttemptActivityRef(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [attempt] = await scopedDb.select({
+        workflowId: sessionTurnAttempts.temporalWorkflowId,
+        workflowRunId: sessionTurnAttempts.temporalWorkflowRunId,
+        activityId: sessionTurnAttempts.temporalActivityId,
+        quiescedAt: sessionTurnAttempts.quiescedAt
+      }).from(sessionTurnAttempts).where(
+        and7(
+          eq7(sessionTurnAttempts.accountId, input.accountId),
+          eq7(sessionTurnAttempts.workspaceId, input.workspaceId),
+          eq7(sessionTurnAttempts.sessionId, input.sessionId),
+          eq7(sessionTurnAttempts.id, input.attemptId),
+          eq7(sessionTurnAttempts.temporalWorkflowId, input.temporalWorkflowId)
+        )
+      ).limit(1);
+      return attempt ? {
+        workflowId: attempt.workflowId,
+        workflowRunId: attempt.workflowRunId,
+        activityId: attempt.activityId,
+        quiesced: attempt.quiescedAt !== null
+      } : null;
+    }
+  );
+}
+async function reconcileSessionAttemptQuiescence(db, input) {
+  const eligibility = await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.execute(sql4`
+        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 };
+}
 async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, attemptId) {
   return await withWorkspaceRls(
     db,
@@ -23801,12 +24069,6 @@ async function settleSessionAttemptInterruptions(db, workspaceId, sessionId, att
         outcome,
         closedAt: now
       });
-      await requeueInterruptedSessionSystemUpdatesForTurnTx(
-        tx,
-        workspaceId,
-        sessionId,
-        turn.id
-      );
       const eventValues = steer ? [
         {
           accountId: session.accountId,
@@ -24676,10 +24938,36 @@ async function applySessionTurnSettlement(db, workspaceId, input) {
           }
         })
       );
+      const settledMachineInputs = ["completed", "failed", "cancelled", "superseded"].includes(
+        input.turnStatus
+      ) ? await tx.select({
+        id: sessionSystemUpdates.id,
+        historyItemId: sessionSystemUpdates.deliveredHistoryItemId
+      }).from(sessionSystemUpdates).where(
+        and7(
+          eq7(sessionSystemUpdates.workspaceId, workspaceId),
+          eq7(sessionSystemUpdates.sessionId, input.sessionId),
+          eq7(sessionSystemUpdates.deliveredTurnId, input.turnId),
+          eq7(sessionSystemUpdates.state, "delivered")
+        )
+      ).orderBy(
+        asc4(sessionSystemUpdates.createdAt),
+        asc4(sessionSystemUpdates.id)
+      ) : [];
+      const machineInputSettlementEvent = 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) => {
@@ -24735,21 +25023,6 @@ async function applySessionTurnSettlement(db, workspaceId, input) {
           turn
         );
       }
-      if (input.turnStatus === "failed") {
-        await deferFailedSessionSystemUpdatesForTurnTx(
-          tx,
-          workspaceId,
-          input.sessionId,
-          input.turnId
-        );
-      } else if (["cancelled", "superseded"].includes(input.turnStatus)) {
-        await requeueInterruptedSessionSystemUpdatesForTurnTx(
-          tx,
-          workspaceId,
-          input.sessionId,
-          input.turnId
-        );
-      }
       await tx.update(sessions).set({
         status: effectiveSessionStatus,
         activeTurnId: input.activeTurnId,
@@ -24947,14 +25220,6 @@ async function settleCodexCredentialLeaseLoss(db, input) {
           eq7(sessions.activeTurnId, input.turnId)
         )
       );
-      if (!input.checkpointDurable) {
-        await deferFailedSessionSystemUpdatesForTurnTx(
-          tx,
-          input.workspaceId,
-          input.sessionId,
-          input.turnId
-        );
-      }
       await tx.execute(sql4`
           delete from codex_credential_leases
           where account_id = ${input.accountId}
@@ -25625,16 +25890,49 @@ async function getSessionQueueSnapshot(db, workspaceId, sessionId) {
         inArray3(sessionTurns.source, ["user", "api"])
       )
     ).orderBy(asc4(sessionTurns.position), asc4(sessionTurns.createdAt));
+    const pendingInputs = await scopedDb.select().from(sessionSystemUpdates).where(
+      and7(
+        eq7(sessionSystemUpdates.workspaceId, workspaceId),
+        eq7(sessionSystemUpdates.sessionId, sessionId),
+        eq7(sessionSystemUpdates.state, "pending")
+      )
+    ).orderBy(
+      sql4`case when ${sessionSystemUpdates.kind} = 'agent_steer_instruction' then 0 else 1 end`,
+      asc4(sessionSystemUpdates.createdAt),
+      asc4(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),
       stoppingPreviousAttempt: 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
     };
   });
 }
@@ -25843,6 +26141,30 @@ async function markSessionWorkflowWakeDelivered(db, input) {
         if (pendingAgentSteer) {
           return { action: "pending_admission", blocker: "pending_agent_steer" };
         }
+        const [pendingQuiescence] = await tx.select({ id: sessionTurnAttempts.id }).from(sessionTurnAttempts).innerJoin(
+          sessionAttemptInterruptions,
+          and7(
+            eq7(
+              sessionAttemptInterruptions.workspaceId,
+              sessionTurnAttempts.workspaceId
+            ),
+            eq7(
+              sessionAttemptInterruptions.sessionId,
+              sessionTurnAttempts.sessionId
+            ),
+            eq7(sessionAttemptInterruptions.attemptId, sessionTurnAttempts.id)
+          )
+        ).where(
+          and7(
+            eq7(sessionTurnAttempts.workspaceId, input.workspaceId),
+            eq7(sessionTurnAttempts.sessionId, input.sessionId),
+            isNull2(sessionTurnAttempts.quiescedAt),
+            inArray3(sessionAttemptInterruptions.state, ["settled", "rejected_stale"])
+          )
+        ).limit(1);
+        if (pendingQuiescence) {
+          return { action: "pending_admission", blocker: "pending_quiescence" };
+        }
       }
       const [row] = await tx.update(sessionWorkflowWakeOutbox).set({
         deliveredRevision: sql4`greatest(${sessionWorkflowWakeOutbox.deliveredRevision}, ${input.wakeRevision})`,
@@ -25998,30 +26320,6 @@ async function addSessionSystemUpdate(db, input) {
   }
   return await addSessionSystemUpdateWithSourceMutation(db, input, async () => void 0);
 }
-async function requeueInterruptedSessionSystemUpdatesForTurnTx(tx, workspaceId, sessionId, turnId) {
-  await tx.update(sessionSystemUpdates).set({ state: "pending", deliveredTurnId: null, deliveredAt: null }).where(
-    and7(
-      eq7(sessionSystemUpdates.workspaceId, workspaceId),
-      eq7(sessionSystemUpdates.sessionId, sessionId),
-      eq7(sessionSystemUpdates.deliveredTurnId, turnId),
-      eq7(sessionSystemUpdates.state, "delivered")
-    )
-  );
-}
-async function deferFailedSessionSystemUpdatesForTurnTx(tx, workspaceId, sessionId, turnId) {
-  await tx.update(sessionSystemUpdates).set({
-    state: sql4`case when ${sessionSystemUpdates.payload} ->> 'type' = 'goal_continuation' then 'failed' else 'deferred' end`,
-    deliveredTurnId: null,
-    deliveredAt: null
-  }).where(
-    and7(
-      eq7(sessionSystemUpdates.workspaceId, workspaceId),
-      eq7(sessionSystemUpdates.sessionId, sessionId),
-      eq7(sessionSystemUpdates.deliveredTurnId, turnId),
-      eq7(sessionSystemUpdates.state, "delivered")
-    )
-  );
-}
 async function addSessionSystemUpdateWithSourceMutation(db, input, mutateSource) {
   if (Buffer.byteLength(JSON.stringify(input.payload)) > MAX_INTERNAL_UPDATE_BYTES) {
     throw new Error(`Internal update payload exceeds ${MAX_INTERNAL_UPDATE_BYTES} bytes`);
@@ -26100,6 +26398,7 @@ async function addSessionSystemUpdateWithSourceMutation(db, input, mutateSource)
         };
       }
       const now = /* @__PURE__ */ new Date();
+      const eventPreview = internalUpdateEventMember(inserted);
       const [event] = await tx.insert(sessionEvents).values({
         accountId: session.accountId,
         workspaceId: input.workspaceId,
@@ -26107,11 +26406,13 @@ async function addSessionSystemUpdateWithSourceMutation(db, input, mutateSource)
         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
       }).returning();
@@ -26148,7 +26449,7 @@ async function listOutstandingSessionSystemUpdates(db, workspaceId, sessionId) {
       and7(
         eq7(sessionSystemUpdates.workspaceId, workspaceId),
         eq7(sessionSystemUpdates.sessionId, sessionId),
-        inArray3(sessionSystemUpdates.state, ["pending", "deferred"])
+        eq7(sessionSystemUpdates.state, "pending")
       )
     ).orderBy(asc4(sessionSystemUpdates.createdAt), asc4(sessionSystemUpdates.id));
     return rows.map(mapSessionSystemUpdate);
@@ -26189,6 +26490,7 @@ function mapSessionSystemUpdate(row) {
     lineage: row.lineage,
     state: row.state,
     deliveredTurnId: row.deliveredTurnId,
+    deliveredHistoryItemId: row.deliveredHistoryItemId,
     deliveredAt: row.deliveredAt?.toISOString() ?? null,
     createdAt: row.createdAt.toISOString()
   };
@@ -26819,6 +27121,7 @@ function mapSession(row, effectiveControl, mcpServers = [], pin = mapSessionPin(
     rigId: row.rigId ?? null,
     rigVersionId: row.rigVersionId ?? null,
     firstPartyMcpPermissions: row.firstPartyMcpPermissions ?? null,
+    firstPartyMcpTools: row.firstPartyMcpTools ?? null,
     mcpServers,
     parentSessionId: row.parentSessionId ?? null,
     rootSessionId: row.rootSessionId,
@@ -27764,6 +28067,7 @@ export {
   getSandboxSessionEnvelope,
   getScheduledTask,
   getSession,
+  getSessionAttemptActivityRef,
   getSessionByCreateIdempotencyKey,
   getSessionCodexState,
   getSessionEvent,
@@ -27935,6 +28239,7 @@ export {
   reapStaleLeaseHoldersGlobal,
   reconcileCodexCapacityWait,
   reconcileColdLostLeaseInstanceBlockers,
+  reconcileSessionAttemptQuiescence,
   recordAuditEvent,
   recordCodexAccountConnectors,
   recordCodexAccountUsage,