@opengeni/db 0.13.4 → 0.14.3

package/dist/index.js

@@ -76,7 +76,7 @@ import {
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces
-} from "./chunk-IQOXTFKA.js";
+} from "./chunk-DW24CKCT.js";
 import {
   migrate,
   runMigrations
@@ -100,7 +100,10 @@ import {
 import "./chunk-PZ5AY32C.js";
 
 // src/index.ts
-import { SESSION_AUTHORIZATION_LIST_SCOPE_MAX_IDS } from "@opengeni/contracts";
+import {
+  DEFAULT_FIRST_PARTY_MCP_TOOLS,
+  SESSION_AUTHORIZATION_LIST_SCOPE_MAX_IDS
+} from "@opengeni/contracts";
 import {
   approvalIdentifier,
   boundWorkspaceControlEvent as boundWorkspaceControlEvent2,
@@ -119,6 +122,7 @@ import {
   RigChange as RigChangeContract,
   SessionGoal as SessionGoalContract,
   SessionSystemUpdatePayload,
+  sessionSystemUpdateBatchHistoryItem,
   HostEventExport as HostEventExportContract,
   HostEventExportBatch as HostEventExportBatchContract,
   HostExportConsumerId,
@@ -2759,7 +2763,6 @@ import { sql as sql5 } from "drizzle-orm";
 import {
   metadataWithTurnExecutionPolicyV1,
   mergeResourceRefs,
-  mergeToolRefs,
   turnExecutionPolicyAuditMetadata
 } from "@opengeni/contracts";
 import { and as and5, asc as asc2, eq as eq5, inArray as inArray2, sql as sql3 } from "drizzle-orm";
@@ -2892,14 +2895,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(
@@ -2965,7 +2960,7 @@ async function normalizeQueuePositions(db, workspaceId, sessionId, orderedIds) {
   }).where(and5(eq5(sessions.workspaceId, workspaceId), eq5(sessions.id, sessionId)));
 }
 function draftIsNonEmpty(draft) {
-  return draft.text.length > 0 || draft.resources.length > 0 || draft.tools.length > 0 || draft.toolsProvided || draft.sourceTurnId !== null;
+  return draft.text.length > 0 || draft.resources.length > 0 || draft.sourceTurnId !== null;
 }
 async function getComposerDraftInTransaction(db, input) {
   const query = db.select().from(composerDrafts).where(
@@ -3005,8 +3000,8 @@ async function saveComposerDraftInTransaction(db, input) {
     revision,
     text: input.text,
     resources: input.resources,
-    tools: input.tools,
-    toolsProvided: input.toolsProvided,
+    tools: [],
+    toolsProvided: false,
     model: input.model,
     reasoningEffort: input.reasoningEffort,
     // A queue edit is still the same accepted work item. Preserve its frozen
@@ -3305,8 +3300,8 @@ async function editQueuedTurnInTransaction(db, input) {
     revision: nextDraftRevision,
     text: turn.prompt,
     resources: turn.resources,
-    tools: turn.tools,
-    toolsProvided: turn.toolsProvided,
+    tools: [],
+    toolsProvided: false,
     model: turn.model,
     reasoningEffort: turn.reasoningEffort,
     sourceTurnId: turn.id,
@@ -3572,8 +3567,6 @@ async function submitHumanPromptInTransaction(db, input) {
     text: input.text,
     turnInstructions: input.turnInstructions ?? null,
     resources: input.resources,
-    tools: input.tools,
-    toolsProvided: input.toolsProvided === true,
     model: input.model ?? null,
     reasoningEffort: input.reasoningEffort ?? null,
     source: input.source,
@@ -3656,15 +3649,11 @@ async function submitHumanPromptInTransaction(db, input) {
     if (draft && canonicalSessionCommandHash({
       text: draft.text,
       resources: draft.resources,
-      tools: draft.tools,
-      toolsProvided: draft.toolsProvided,
       model: draft.model,
       reasoningEffort: draft.reasoningEffort
     }) !== canonicalSessionCommandHash({
       text: input.text,
       resources: input.resources,
-      tools: input.tools,
-      toolsProvided: input.toolsProvided === true,
       model: input.model ?? session.model,
       reasoningEffort: input.reasoningEffort ?? input.reasoningEffortFallback
     })) {
@@ -3758,7 +3747,6 @@ async function submitHumanPromptInTransaction(db, input) {
       payload: sanitizeEventPayload({
         text: input.text,
         ...input.resources.length ? { resources: input.resources } : {},
-        ...input.toolsProvided === true ? { tools: input.tools } : input.tools.length ? { tools: input.tools } : {},
         ...input.model ? { model: input.model } : {},
         ...input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {},
         delivery: input.delivery,
@@ -3781,8 +3769,8 @@ async function submitHumanPromptInTransaction(db, input) {
     prompt: input.text,
     turnInstructions: editedSourceTurnInstructions !== void 0 ? editedSourceTurnInstructions : input.turnInstructions ?? null,
     resources: input.resources,
-    tools: input.tools,
-    toolsProvided: input.toolsProvided === true,
+    tools: [],
+    toolsProvided: false,
     model: input.model ?? session.model,
     reasoningEffort: input.reasoningEffort ?? input.reasoningEffortFallback,
     sandboxBackend: session.sandboxBackend,
@@ -3902,7 +3890,7 @@ async function submitHumanPromptInTransaction(db, input) {
   const queueVersion = session.queueVersion + 1;
   await db.update(sessions).set({
     resources: mergeResourceRefs(session.resources, input.resources),
-    tools: sessionToolPolicyIsFixed(session.toolPolicy) ? session.tools : mergeToolRefs(session.tools, input.tools),
+    tools: session.tools,
     activeTurnId: input.delivery === "steer" ? liveCurrentTurnId : session.activeTurnId,
     status: nextStatus,
     queueVersion,
@@ -3966,11 +3954,6 @@ async function submitHumanPromptInTransaction(db, input) {
     replay: false
   };
 }
-function sessionToolPolicyIsFixed(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const mode = value.mode;
-  return mode === "workspace_default" || mode === "explicit" || mode === "inherited";
-}
 async function sendAgentMessageInTransaction(db, input) {
   const workspaceControl = await lockWorkspaceInferenceControl(db, input.workspaceId, "share");
   await lockSessionEventWriteRows(db, {
@@ -4186,14 +4169,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 +4235,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,
@@ -13736,7 +13735,10 @@ async function createSessionInTransaction(tx, input, id) {
     resources: input.resources,
     skills: input.skills ?? [],
     tools: input.tools ?? [],
-    toolPolicy: input.toolPolicy ?? null,
+    toolPolicy: input.toolPolicy ?? {
+      mode: "explicit",
+      inheritedFromSessionId: input.parentSessionId ?? null
+    },
     metadata: input.metadata,
     ...creatorColumns(frozenCreator),
     model: input.model,
@@ -13747,6 +13749,7 @@ async function createSessionInTransaction(tx, input, id) {
     rigId: input.rigId ?? null,
     rigVersionId: input.rigVersionId ?? null,
     firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
+    firstPartyMcpTools: input.firstPartyMcpTools ?? [...DEFAULT_FIRST_PARTY_MCP_TOOLS],
     instructions: input.instructions ?? null,
     parentSessionId: input.parentSessionId ?? null,
     createIdempotencyKey,
@@ -20246,6 +20249,56 @@ async function latestWorkspaceCapture(db, workspaceId, sessionId) {
     return rows.length ? mapWorkspaceCaptureRow(rows[0]) : null;
   });
 }
+async function sessionLatestWorkspaceCapture(db, workspaceId, sessionId) {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const rows = await scopedDb.execute(sql4`
+      select
+        sessions.id as found_session_id,
+        capture.id as capture_id,
+        capture.session_id as capture_session_id,
+        capture.turn_id as capture_turn_id,
+        capture.revision as capture_revision,
+        capture.lease_epoch as capture_lease_epoch,
+        capture.state as capture_state,
+        capture.manifest_key as capture_manifest_key,
+        capture.tree_index_key as capture_tree_index_key,
+        capture.blob_keys as capture_blob_keys,
+        capture.size_bytes as capture_size_bytes,
+        capture.stats as capture_stats,
+        capture.captured_at as capture_captured_at
+      from sessions
+      left join lateral (
+        select ${WORKSPACE_CAPTURE_COLUMNS}
+        from workspace_captures
+        where workspace_captures.session_id = sessions.id
+        order by workspace_captures.revision desc
+        limit 1
+      ) capture on true
+      where sessions.workspace_id = ${workspaceId} and sessions.id = ${sessionId}
+      limit 1
+    `);
+    const row = rows[0];
+    if (!row) return { sessionExists: false, capture: null };
+    if (!row.capture_id) return { sessionExists: true, capture: null };
+    return {
+      sessionExists: true,
+      capture: mapWorkspaceCaptureRow({
+        id: row.capture_id,
+        session_id: row.capture_session_id,
+        turn_id: row.capture_turn_id,
+        revision: row.capture_revision,
+        lease_epoch: row.capture_lease_epoch,
+        state: row.capture_state,
+        manifest_key: row.capture_manifest_key,
+        tree_index_key: row.capture_tree_index_key,
+        blob_keys: row.capture_blob_keys,
+        size_bytes: row.capture_size_bytes,
+        stats: row.capture_stats,
+        captured_at: row.capture_captured_at
+      })
+    };
+  });
+}
 async function workspaceCaptureAtRevision(db, workspaceId, sessionId, revision) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const rows = await scopedDb.execute(sql4`
@@ -22213,7 +22266,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 +22389,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 +22398,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 +22785,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 +22852,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 +22876,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 +22902,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 +22964,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 +22994,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 +23288,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 +23466,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 +23617,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 +23717,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 +23863,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 +24112,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 +24981,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 +25066,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 +25263,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 +25933,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 +26184,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 +26363,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 +26441,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 +26449,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 +26492,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 +26533,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()
   };
@@ -26732,6 +27077,7 @@ async function appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessi
         lastSequence: sequence,
         ...update.resources !== void 0 ? { resources: update.resources } : {},
         ...update.tools !== void 0 ? { tools: update.tools } : {},
+        ...update.firstPartyMcpTools !== void 0 ? { firstPartyMcpTools: update.firstPartyMcpTools } : {},
         ...update.toolPolicy !== void 0 ? { toolPolicy: update.toolPolicy } : {},
         ...update.toolPolicyVersion !== void 0 ? { toolPolicyVersion: update.toolPolicyVersion } : {},
         ...update.model !== void 0 ? { model: update.model } : {},
@@ -26791,11 +27137,8 @@ function mapSession(row, effectiveControl, mcpServers = [], pin = mapSessionPin(
     resources: row.resources,
     skills: row.skills ?? [],
     tools: row.tools,
-    toolPolicy: row.toolPolicy ?? {
-      mode: "legacy",
-      inheritedFromSessionId: null
-    },
-    toolPolicyVersion: Number(row.toolPolicyVersion ?? 1),
+    toolPolicy: row.toolPolicy,
+    toolPolicyVersion: Number(row.toolPolicyVersion),
     metadata: row.metadata,
     createdBy: initiatorFromStorage(
       row.createdByKind,
@@ -26819,6 +27162,7 @@ function mapSession(row, effectiveControl, mcpServers = [], pin = mapSessionPin(
     rigId: row.rigId ?? null,
     rigVersionId: row.rigVersionId ?? null,
     firstPartyMcpPermissions: row.firstPartyMcpPermissions ?? null,
+    firstPartyMcpTools: row.firstPartyMcpTools,
     mcpServers,
     parentSessionId: row.parentSessionId ?? null,
     rootSessionId: row.rootSessionId,
@@ -27764,6 +28108,7 @@ export {
   getSandboxSessionEnvelope,
   getScheduledTask,
   getSession,
+  getSessionAttemptActivityRef,
   getSessionByCreateIdempotencyKey,
   getSessionCodexState,
   getSessionEvent,
@@ -27935,6 +28280,7 @@ export {
   reapStaleLeaseHoldersGlobal,
   reconcileCodexCapacityWait,
   reconcileColdLostLeaseInstanceBlockers,
+  reconcileSessionAttemptQuiescence,
   recordAuditEvent,
   recordCodexAccountConnectors,
   recordCodexAccountUsage,
@@ -28012,6 +28358,7 @@ export {
   sendAgentMessageInTransaction,
   serializeEffectiveSessionControl,
   sessionAuthorizationScopeFilter,
+  sessionLatestWorkspaceCapture,
   sessionSubject,
   sessionTreeStatsForSessions,
   sessionsWithActiveOpOnEnrollment,