@opengeni/db 3.6.0 → 3.7.4-canary.0

package/src/session-queue-commands.ts

@@ -29,7 +29,7 @@ import {
   type TimelineAnnotation,
   type PersonalResourceAttachmentIntent,
 } from "@opengeni/contracts";
-import { and, asc, eq, inArray, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
 import { setSubjectRlsContext, type Database, type SessionActivityDatabase } from "./database";
 import {
   fromPostgresLosslessJson,
@@ -44,10 +44,13 @@ import {
   canonicalSessionCommandHash,
   evaluateSessionControl,
   lockSessionEventWriteRows,
+  lockSessionPromptCommandOperation,
   lockWorkspaceInferenceControl,
   lockWorkspaceInferenceControlForAdmission,
+  getCompletedSessionPromptCommandReceipt,
   registerInternalUpdateWakeInTransaction,
   reserveSessionCommandReceipt,
+  reserveSessionPromptCommandReceipt,
   registerSessionWorkflowWakeInTransaction,
   type SessionCommandActor,
   type SessionCommandReceiptRow,
@@ -210,6 +213,122 @@ function mapSubmittedPromptTurn(row: typeof schema.sessionTurns.$inferSelect): S
   };
 }
 
+async function loadSubmittedHumanPromptReplay(
+  db: Database,
+  input: {
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    delivery: "send" | "steer";
+    expectedDraftRevision?: number | null;
+    receipt: SessionCommandReceiptRow;
+  },
+): Promise<SubmitHumanPromptResult> {
+  const turnId = String(input.receipt.result.turnId ?? "");
+  const acceptedEventId = String(input.receipt.result.acceptedEventId ?? "");
+  const eventIds = Array.isArray(input.receipt.result.eventIds)
+    ? input.receipt.result.eventIds.filter((id): id is string => typeof id === "string")
+    : [];
+  const wakeRevision = Number(input.receipt.result.wakeRevision ?? 0);
+  if (!turnId || !acceptedEventId || wakeRevision < 1) {
+    throw new SessionControlInvariantError("Replayed prompt receipt is incomplete");
+  }
+  const replayEvents = await db
+    .select()
+    .from(schema.sessionEvents)
+    .where(
+      and(
+        eq(schema.sessionEvents.workspaceId, input.workspaceId),
+        eq(schema.sessionEvents.sessionId, input.sessionId),
+        inArray(schema.sessionEvents.id, eventIds),
+      ),
+    )
+    .orderBy(asc(schema.sessionEvents.sequence));
+  const [replayTurn] = await db
+    .select()
+    .from(schema.sessionTurns)
+    .where(
+      and(
+        eq(schema.sessionTurns.workspaceId, input.workspaceId),
+        eq(schema.sessionTurns.sessionId, input.sessionId),
+        eq(schema.sessionTurns.id, turnId),
+      ),
+    )
+    .limit(1);
+  const events = replayEvents.map(mapSubmittedPromptEvent);
+  const accepted = events.find((event) => event.id === acceptedEventId);
+  if (!accepted || !replayTurn || events.length !== eventIds.length) {
+    throw new SessionControlInvariantError("Replayed prompt rows are incomplete");
+  }
+  const replayDraft =
+    input.expectedDraftRevision === null || input.expectedDraftRevision === undefined
+      ? null
+      : await getComposerDraftInTransaction(db, {
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          subjectId: input.subjectId,
+        });
+  return {
+    receipt: input.receipt,
+    routing:
+      input.receipt.result.routing === "accepted_for_execution" ||
+      input.receipt.result.routing === "queued_for_execution" ||
+      input.receipt.result.routing === "accepted_for_steering"
+        ? input.receipt.result.routing
+        : input.delivery === "steer"
+          ? "accepted_for_steering"
+          : // Pre-routing receipts cannot reconstruct admission-time activity
+            // or Pause truth. Queue is the only conservative placement; a
+            // later turn.started event moves it into chat without duplication.
+            "queued_for_execution",
+    queueVersion: Number(input.receipt.appliedQueueVersion),
+    accepted,
+    events,
+    turn: mapSubmittedPromptTurn(replayTurn),
+    draft: replayDraft,
+    acceptedEventId,
+    eventIds,
+    turnId,
+    wakeRevision,
+    interruptionCount: Number(input.receipt.result.interruptionCount ?? 0),
+    workspaceControlEventId:
+      typeof input.receipt.result.workspaceControlEventId === "string"
+        ? input.receipt.result.workspaceControlEventId
+        : null,
+    replay: true,
+  };
+}
+
+export async function replaySubmittedHumanPromptFromBoundaryReceipt(
+  db: Database,
+  input: {
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    actor: SessionCommandActor;
+    operationKey: string;
+    delivery: "send" | "steer";
+    boundaryRequestHash: string;
+    expectedDraftRevision?: number | null;
+    /** Wait for an overlapping same-key transaction before checking committed replay truth. */
+    serializeOperation?: boolean;
+  },
+): Promise<SubmitHumanPromptResult | null> {
+  if (input.serializeOperation) {
+    await lockSessionPromptCommandOperation(db, input);
+  }
+  const receipt = await getCompletedSessionPromptCommandReceipt(db, {
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    action: input.delivery === "steer" ? "prompt.steer" : "prompt.send",
+    targetSessionId: input.sessionId,
+    operationKey: input.operationKey,
+    boundaryRequestHash: input.boundaryRequestHash,
+  });
+  if (!receipt) return null;
+  return await loadSubmittedHumanPromptReplay(db, { ...input, receipt });
+}
+
 export type AgentInternalUpdateCommandResult = {
   receipt: SessionCommandReceiptRow;
   updateId: string;
@@ -345,11 +464,55 @@ async function lockSession(
 
 type SteerSupersessionResult = {
   interruptionCount: number;
+  steerTargetTurn: typeof schema.sessionTurns.$inferSelect | null;
   replacedTurn: typeof schema.sessionTurns.$inferSelect | null;
   liveCurrentTurnId: string | null;
+  deferredUntilCompaction: boolean;
   lastSequence: number;
 };
 
+async function turnAttemptIsCompacting(
+  db: Database,
+  input: {
+    workspaceId: string;
+    sessionId: string;
+    turn: typeof schema.sessionTurns.$inferSelect;
+  },
+): Promise<boolean> {
+  // A standalone operator compaction is maintenance rather than replaceable
+  // direction. Once claimed, let it finish even before its provider-visible
+  // started landmark is appended.
+  if (input.turn.source === "compaction") return true;
+  if (!input.turn.activeAttemptId) return false;
+
+  // Automatic/proactive/overflow compaction happens inside an ordinary turn.
+  // The latest exact-attempt landmark is durable state: `started` means the
+  // checkpoint provider call is still in flight, while compacted/skipped opens
+  // ordinary Steer interruption again. Multiple compactions in one attempt are
+  // therefore handled by the newest lifecycle event rather than a historical
+  // existence test.
+  const [latest] = await db
+    .select({ type: schema.sessionEvents.type })
+    .from(schema.sessionEvents)
+    .where(
+      and(
+        eq(schema.sessionEvents.workspaceId, input.workspaceId),
+        eq(schema.sessionEvents.sessionId, input.sessionId),
+        eq(schema.sessionEvents.turnId, input.turn.id),
+        eq(schema.sessionEvents.turnGeneration, input.turn.executionGeneration),
+        eq(schema.sessionEvents.turnAttemptId, input.turn.activeAttemptId),
+        inArray(schema.sessionEvents.type, [
+          "session.context.compaction.started",
+          "session.context.compacted",
+          "session.context.compaction.skipped",
+        ]),
+      ),
+    )
+    .orderBy(desc(schema.sessionEvents.sequence), desc(schema.sessionEvents.id))
+    .limit(1);
+  return latest?.type === "session.context.compaction.started";
+}
+
 /**
  * One canonical replacement transition shared by human row/new-prompt Steer
  * and Agent Steer. A live owner is interrupted and remains current until exact
@@ -371,8 +534,10 @@ export async function supersedeSessionCurrentDirectionInTransaction(
   if (!input.activeTurnId) {
     return {
       interruptionCount: 0,
+      steerTargetTurn: null,
       replacedTurn: null,
       liveCurrentTurnId: null,
+      deferredUntilCompaction: false,
       lastSequence: input.lastSequence,
     };
   }
@@ -391,6 +556,7 @@ export async function supersedeSessionCurrentDirectionInTransaction(
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
     workspaceLock: "already_locked",
+    sessionIds: [input.sessionId],
     turnIds: [input.activeTurnId],
     attemptIds: preview?.activeAttemptId ? [preview.activeAttemptId] : [],
   });
@@ -410,6 +576,26 @@ export async function supersedeSessionCurrentDirectionInTransaction(
       `Running turn ${current.id} has no first-class attempt owner`,
     );
   }
+  if (
+    current.activeAttemptId &&
+    (await turnAttemptIsCompacting(db, {
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turn: current,
+    }))
+  ) {
+    return {
+      interruptionCount: 0,
+      steerTargetTurn: current,
+      // An ordinary turn is superseded cooperatively as soon as its checkpoint
+      // settles. Standalone maintenance completes normally, then the Steer is
+      // already first in line.
+      replacedTurn: current.source === "compaction" ? null : current,
+      liveCurrentTurnId: current.id,
+      deferredUntilCompaction: true,
+      lastSequence: input.lastSequence,
+    };
+  }
   if (current.activeAttemptId) {
     if (current.status !== "running") {
       throw new SessionControlInvariantError(
@@ -431,8 +617,10 @@ export async function supersedeSessionCurrentDirectionInTransaction(
       .returning({ id: schema.sessionAttemptInterruptions.id });
     return {
       interruptionCount: interruption ? 1 : 0,
+      steerTargetTurn: current,
       replacedTurn: current,
       liveCurrentTurnId: current.id,
+      deferredUntilCompaction: false,
       lastSequence: input.lastSequence,
     };
   }
@@ -571,8 +759,10 @@ export async function supersedeSessionCurrentDirectionInTransaction(
   }
   return {
     interruptionCount: 0,
+    steerTargetTurn: current,
     replacedTurn: current,
     liveCurrentTurnId: null,
+    deferredUntilCompaction: false,
     lastSequence,
   };
 }
@@ -1388,9 +1578,11 @@ export async function steerQueuedTurnInTransaction(
     lastSequence: session.lastSequence,
   });
   const interruptionCount = supersession.interruptionCount;
+  const steerTargetTurn = supersession.steerTargetTurn;
   const supersededTurnId = supersession.replacedTurn?.id ?? null;
   const supersededAttemptId = supersession.replacedTurn?.activeAttemptId ?? null;
   const liveCurrentTurnId = supersession.liveCurrentTurnId;
+  const deferredUntilCompaction = supersession.deferredUntilCompaction;
 
   const withoutTarget = rows.filter((row) => row.id !== target.id);
   const ordered = [target, ...withoutTarget];
@@ -1412,6 +1604,7 @@ export async function steerQueuedTurnInTransaction(
         replacedTurnId: supersededTurnId,
         replacedAttemptId: supersededAttemptId,
         interruptionCount,
+        ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
       },
       updatedAt: now,
     })
@@ -1440,12 +1633,16 @@ export async function steerQueuedTurnInTransaction(
     sessionId: input.sessionId,
     sequence: ++sequence,
     type: "session.control.steer_requested",
-    turnId: supersededTurnId ?? target.id,
+    turnId: steerTargetTurn?.id ?? target.id,
+    turnGeneration: steerTargetTurn?.executionGeneration ?? null,
+    turnAttemptId: steerTargetTurn?.activeAttemptId ?? null,
+    turnAssociation: steerTargetTurn ? "current" : null,
     payload: {
       operationId: reserved.receipt.id,
       targetTurnId: target.id,
       replacedTurnId: supersededTurnId,
-      stopping: liveCurrentTurnId !== null,
+      stopping: liveCurrentTurnId !== null && !deferredUntilCompaction,
+      ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
     },
     occurredAt: now,
   });
@@ -1480,6 +1677,7 @@ export async function steerQueuedTurnInTransaction(
           operationId: reserved.receipt.id,
           replacedTurnId: supersededTurnId,
           interruptionCount,
+          deferredUntilCompaction,
         },
       },
       "metadata",
@@ -1501,6 +1699,7 @@ export async function steerQueuedTurnInTransaction(
     result: {
       interruptionCount,
       supersededTurnId,
+      deferredUntilCompaction,
       wakeRevision,
       workspaceControlEventId: resumed.workspaceControlEventId,
     },
@@ -1528,6 +1727,8 @@ export async function submitHumanPromptInTransaction(
     subjectLabel?: string;
     actor: SessionCommandActor;
     operationKey: string;
+    /** Stable parsed boundary-request identity used before mutable enrichment. */
+    boundaryRequestHash?: string;
     delivery: "send" | "steer";
     controlEtag?: string | null;
     expectedDraftRevision?: number | null;
@@ -1562,6 +1763,9 @@ export async function submitHumanPromptInTransaction(
       id: string;
       headersEncrypted: Record<string, string>;
     }>;
+    /** Trusted database-only admission seam. It runs only after a completed
+     * operation replay has been ruled out; throwing rolls the prompt back. */
+    beforeFreshPromptCommit?: (tx: Database) => Promise<void>;
     /** Request-scoped callers bound the control prefix wait; lifecycle callers omit it. */
     controlLockTimeoutMs?: number;
   },
@@ -1628,91 +1832,41 @@ export async function submitHumanPromptInTransaction(
         }
       : {}),
   });
-  const reserved = await reserveSessionCommandReceipt(db, {
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    actor: input.actor,
-    action: input.delivery === "steer" ? "prompt.steer" : "prompt.send",
-    targetSessionId: input.sessionId,
-    targetTurnId: null,
-    operationKey: input.operationKey,
-    canonicalRequestHash: requestHash,
-  });
+  const action = input.delivery === "steer" ? "prompt.steer" : "prompt.send";
+  const reserved = input.boundaryRequestHash
+    ? await reserveSessionPromptCommandReceipt(db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        actor: input.actor,
+        action,
+        targetSessionId: input.sessionId,
+        operationKey: input.operationKey,
+        canonicalRequestHash: requestHash,
+        boundaryRequestHash: input.boundaryRequestHash,
+      })
+    : await reserveSessionCommandReceipt(db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        actor: input.actor,
+        action,
+        targetSessionId: input.sessionId,
+        targetTurnId: null,
+        operationKey: input.operationKey,
+        canonicalRequestHash: requestHash,
+      });
   if (reserved.replay && reserved.receipt.appliedQueueVersion !== null) {
-    const turnId = String(reserved.receipt.result.turnId ?? "");
-    const acceptedEventId = String(reserved.receipt.result.acceptedEventId ?? "");
-    const eventIds = Array.isArray(reserved.receipt.result.eventIds)
-      ? reserved.receipt.result.eventIds.filter((id): id is string => typeof id === "string")
-      : [];
-    const wakeRevision = Number(reserved.receipt.result.wakeRevision ?? 0);
-    if (!turnId || !acceptedEventId || wakeRevision < 1) {
-      throw new SessionControlInvariantError("Replayed prompt receipt is incomplete");
-    }
-    const replayEvents = await db
-      .select()
-      .from(schema.sessionEvents)
-      .where(
-        and(
-          eq(schema.sessionEvents.workspaceId, input.workspaceId),
-          eq(schema.sessionEvents.sessionId, input.sessionId),
-          inArray(schema.sessionEvents.id, eventIds),
-        ),
-      )
-      .orderBy(asc(schema.sessionEvents.sequence));
-    const [replayTurn] = await db
-      .select()
-      .from(schema.sessionTurns)
-      .where(
-        and(
-          eq(schema.sessionTurns.workspaceId, input.workspaceId),
-          eq(schema.sessionTurns.sessionId, input.sessionId),
-          eq(schema.sessionTurns.id, turnId),
-        ),
-      )
-      .limit(1);
-    const events = replayEvents.map(mapSubmittedPromptEvent);
-    const accepted = events.find((event) => event.id === acceptedEventId);
-    if (!accepted || !replayTurn || events.length !== eventIds.length) {
-      throw new SessionControlInvariantError("Replayed prompt rows are incomplete");
-    }
-    const replayDraft =
-      input.expectedDraftRevision === null || input.expectedDraftRevision === undefined
-        ? null
-        : await getComposerDraftInTransaction(db, {
-            workspaceId: input.workspaceId,
-            sessionId: input.sessionId,
-            subjectId: input.subjectId,
-          });
-    return {
+    return await loadSubmittedHumanPromptReplay(db, {
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      subjectId: input.subjectId,
+      delivery: input.delivery,
+      ...(input.expectedDraftRevision !== undefined
+        ? { expectedDraftRevision: input.expectedDraftRevision }
+        : {}),
       receipt: reserved.receipt,
-      routing:
-        reserved.receipt.result.routing === "accepted_for_execution" ||
-        reserved.receipt.result.routing === "queued_for_execution" ||
-        reserved.receipt.result.routing === "accepted_for_steering"
-          ? reserved.receipt.result.routing
-          : input.delivery === "steer"
-            ? "accepted_for_steering"
-            : // Pre-routing receipts cannot reconstruct admission-time activity
-              // or Pause truth. Queue is the only conservative placement; a
-              // later turn.started event moves it into chat without duplication.
-              "queued_for_execution",
-      queueVersion: Number(reserved.receipt.appliedQueueVersion),
-      accepted,
-      events,
-      turn: mapSubmittedPromptTurn(replayTurn),
-      draft: replayDraft,
-      acceptedEventId,
-      eventIds,
-      turnId,
-      wakeRevision,
-      interruptionCount: Number(reserved.receipt.result.interruptionCount ?? 0),
-      workspaceControlEventId:
-        typeof reserved.receipt.result.workspaceControlEventId === "string"
-          ? reserved.receipt.result.workspaceControlEventId
-          : null,
-      replay: true,
-    };
+    });
   }
+  await input.beforeFreshPromptCommit?.(db);
 
   const before = await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
     workspaceControl,
@@ -1730,12 +1884,37 @@ export async function submitHumanPromptInTransaction(
     );
   }
 
-  // Send is queue admission, never a hidden control mutation. A paused Send
-  // remains inert behind the existing gate until the user explicitly resumes.
-  // Steer is the intentional exception: it replaces the current direction and
-  // therefore activates the selected branch atomically.
+  const draft =
+    input.expectedDraftRevision === null || input.expectedDraftRevision === undefined
+      ? null
+      : await getComposerDraftInTransaction(db, {
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          subjectId: input.subjectId,
+          lock: true,
+        });
+  const isQueueEditSubmission = draft?.sourceTurnId !== null && draft?.sourceTurnId !== undefined;
+
+  // A normal Send received while the active branch is waiting in
+  // `requires_action` is the human choosing to continue conversationally
+  // instead of through the pending decision surface. Promote only that active
+  // wait to Steer semantics so the frozen wait is cancelled and the new prompt
+  // runs next. A queue-edit submission preserves the identity and placement of
+  // already accepted queued work, so it must never cancel an unrelated active
+  // wait. An explicitly paused branch remains inert until Resume or an explicit
+  // Steer; running, recovering, and capacity-waiting work also retain ordinary
+  // queue semantics.
+  const effectiveDelivery =
+    input.delivery === "send" &&
+    (input.actor.type === "human" || input.actor.type === "operator") &&
+    !isQueueEditSubmission &&
+    before.state === "active" &&
+    session.status === "requires_action" &&
+    session.activeTurnId !== null
+      ? "steer"
+      : input.delivery;
   const resumed =
-    input.delivery === "send"
+    effectiveDelivery === "send"
       ? {
           revision: before.controlVersion,
           control: before,
@@ -1753,16 +1932,6 @@ export async function submitHumanPromptInTransaction(
           observedControlEtag: input.controlEtag ?? null,
           admission,
         });
-
-  const draft =
-    input.expectedDraftRevision === null || input.expectedDraftRevision === undefined
-      ? null
-      : await getComposerDraftInTransaction(db, {
-          workspaceId: input.workspaceId,
-          sessionId: input.sessionId,
-          subjectId: input.subjectId,
-          lock: true,
-        });
   if (input.expectedDraftRevision !== null && input.expectedDraftRevision !== undefined) {
     const actualRevision = draft?.revision ?? 0;
     if (actualRevision !== input.expectedDraftRevision) {
@@ -1928,7 +2097,7 @@ export async function submitHumanPromptInTransaction(
       : (input.modelContext ?? null);
   const existingQueued = await loadQueuedTurns(db, input.workspaceId, input.sessionId, true);
   const routing: SessionPromptRouting =
-    input.delivery === "steer"
+    effectiveDelivery === "steer"
       ? "accepted_for_steering"
       : before.state === "paused" || session.activeTurnId || existingQueued.length > 0
         ? "queued_for_execution"
@@ -1959,7 +2128,7 @@ export async function submitHumanPromptInTransaction(
         ...(input.model ? { model: input.model } : {}),
         ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
         ...(input.latencyMode ? { latencyMode: input.latencyMode } : {}),
-        delivery: input.delivery,
+        delivery: effectiveDelivery,
         routing,
         initiator: frozenInitiator.initiator,
       },
@@ -1980,7 +2149,7 @@ export async function submitHumanPromptInTransaction(
           status: "queued",
           source: input.source,
           promptRouting: routing,
-          position: input.delivery === "steer" ? 0 : existingQueued.length + 1,
+          position: effectiveDelivery === "steer" ? 0 : existingQueued.length + 1,
           prompt: input.text,
           annotations,
           modelContext: effectiveModelContext,
@@ -2072,7 +2241,7 @@ export async function submitHumanPromptInTransaction(
   });
 
   const supersession =
-    input.delivery === "steer"
+    effectiveDelivery === "steer"
       ? await supersedeSessionCurrentDirectionInTransaction(db, {
           accountId: input.accountId,
           workspaceId: input.workspaceId,
@@ -2085,8 +2254,10 @@ export async function submitHumanPromptInTransaction(
         })
       : {
           interruptionCount: 0,
+          steerTargetTurn: null,
           replacedTurn: null,
           liveCurrentTurnId: null,
+          deferredUntilCompaction: false,
           lastSequence: session.lastSequence,
         };
   // Ownerless Steer settlement may have appended interrupted tool results.
@@ -2094,9 +2265,11 @@ export async function submitHumanPromptInTransaction(
   sequence = supersession.lastSequence;
   for (const event of eventValues) event.sequence = ++sequence;
   const interruptionCount = supersession.interruptionCount;
+  const steerTargetTurn = supersession.steerTargetTurn;
   const replacedTurnId = supersession.replacedTurn?.id ?? null;
   const replacedAttemptId = supersession.replacedTurn?.activeAttemptId ?? null;
   const liveCurrentTurnId = supersession.liveCurrentTurnId;
+  const deferredUntilCompaction = supersession.deferredUntilCompaction;
   // Durable provenance for the queue projection. Until the superseded attempt
   // loses inference, user-visible output, and workspace-persistence authority,
   // its exact first-class attempt has no quiescence receipt. Pairing that
@@ -2104,7 +2277,7 @@ export async function submitHumanPromptInTransaction(
   // attempt…" truthfully across refresh/reconnect, even though logical
   // settlement has already cleared sessions.active_turn_id. Do not infer this
   // state from a local request spinner or queue position.
-  if (input.delivery === "steer") {
+  if (effectiveDelivery === "steer") {
     const [updatedTurn] = await db
       .update(schema.sessionTurns)
       .set({
@@ -2114,6 +2287,7 @@ export async function submitHumanPromptInTransaction(
           replacedTurnId,
           replacedAttemptId,
           interruptionCount,
+          ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
         },
         updatedAt: now,
       })
@@ -2130,8 +2304,8 @@ export async function submitHumanPromptInTransaction(
     }
     committedTurn = updatedTurn;
   }
-  if (supersession.replacedTurn) {
-    const current = supersession.replacedTurn;
+  if (steerTargetTurn) {
+    const current = steerTargetTurn;
     if (!liveCurrentTurnId) {
       eventValues.push({
         accountId: input.accountId,
@@ -2157,8 +2331,9 @@ export async function submitHumanPromptInTransaction(
       payload: {
         operationId: reserved.receipt.id,
         targetTurnId: turnId,
-        replacedTurnId: current.id,
-        stopping: liveCurrentTurnId !== null,
+        replacedTurnId,
+        stopping: liveCurrentTurnId !== null && !deferredUntilCompaction,
+        ...(deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
       },
       occurredAt: now,
     });
@@ -2188,7 +2363,7 @@ export async function submitHumanPromptInTransaction(
   }
 
   const ordered =
-    input.delivery === "steer" ? [turn, ...existingQueued] : [...existingQueued, turn];
+    effectiveDelivery === "steer" ? [turn, ...existingQueued] : [...existingQueued, turn];
   await normalizeQueuePositions(
     db,
     input.workspaceId,
@@ -2196,7 +2371,7 @@ export async function submitHumanPromptInTransaction(
     ordered.map((row) => row.id),
   );
   const noCurrentAfter =
-    input.delivery === "steer" ? liveCurrentTurnId === null : !session.activeTurnId;
+    effectiveDelivery === "steer" ? liveCurrentTurnId === null : !session.activeTurnId;
   const nextStatus = noCurrentAfter ? "queued" : session.status;
   if (nextStatus !== session.status) {
     eventValues.push({
@@ -2223,12 +2398,12 @@ export async function submitHumanPromptInTransaction(
       turnId,
       channel: null,
       text: renderRealtimeHumanInputContext({
-        delivery: input.delivery,
+        delivery: effectiveDelivery,
         routing,
         text: renderTimelineAnnotationsForModel(input.text, annotations),
       }),
       payload: {
-        delivery: input.delivery,
+        delivery: effectiveDelivery,
         routing,
         acceptedEventId,
         instruction: "OpenGeni accepted and routed this user input; do not delegate it again.",
@@ -2242,7 +2417,7 @@ export async function submitHumanPromptInTransaction(
     .set({
       resources: mergeResourceRefs(session.resources as ResourceRef[], input.resources),
       tools: session.tools,
-      activeTurnId: input.delivery === "steer" ? liveCurrentTurnId : session.activeTurnId,
+      activeTurnId: effectiveDelivery === "steer" ? liveCurrentTurnId : session.activeTurnId,
       status: nextStatus,
       queueVersion,
       queueHeadPosition: 0,
@@ -2276,8 +2451,8 @@ export async function submitHumanPromptInTransaction(
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
     temporalWorkflowId: workflowId,
-    reason: input.delivery === "steer" ? "prompt_steer" : "prompt_send",
-    controlRequested: input.delivery === "steer",
+    reason: effectiveDelivery === "steer" ? "prompt_steer" : "prompt_send",
+    controlRequested: effectiveDelivery === "steer",
   });
   await db.insert(schema.auditEvents).values(
     withLosslessContentWriteVersion(
@@ -2288,13 +2463,14 @@ export async function submitHumanPromptInTransaction(
           input.actor.type === "agent_attempt"
             ? `attempt:${input.actor.attemptId}`
             : input.actor.subjectId,
-        action: input.delivery === "steer" ? "session.prompt.steer" : "session.prompt.send",
+        action: effectiveDelivery === "steer" ? "session.prompt.steer" : "session.prompt.send",
         targetType: "session_turn",
         targetId: turnId,
         metadata: {
           operationId: reserved.receipt.id,
           replacedTurnId,
           interruptionCount,
+          deferredUntilCompaction,
           ...(input.turnExecutionPolicy
             ? turnExecutionPolicyAuditMetadata(input.turnExecutionPolicy, turnId)
             : {}),
@@ -2332,12 +2508,14 @@ export async function submitHumanPromptInTransaction(
     turnVersion: turn.version,
     ...(nextDraft ? { draftRevision: nextDraft.revision } : {}),
     result: {
+      ...(input.boundaryRequestHash ? { boundaryRequestHash: input.boundaryRequestHash } : {}),
       turnId,
       acceptedEventId,
       eventIds,
       wakeRevision,
       interruptionCount,
       replacedTurnId,
+      deferredUntilCompaction,
       workspaceControlEventId: resumed.workspaceControlEventId,
       routing,
       ...(input.turnExecutionPolicy
@@ -2815,16 +2993,17 @@ export async function steerAgentSessionInTransaction(
       sessionId: input.targetSessionId,
       sequence: ++sequence,
       type: "session.control.steer_requested",
-      turnId: supersession.replacedTurn?.id ?? null,
-      turnGeneration: supersession.replacedTurn?.executionGeneration ?? null,
-      turnAttemptId: supersession.replacedTurn?.activeAttemptId ?? null,
-      turnAssociation: supersession.replacedTurn ? "current" : null,
+      turnId: supersession.steerTargetTurn?.id ?? null,
+      turnGeneration: supersession.steerTargetTurn?.executionGeneration ?? null,
+      turnAttemptId: supersession.steerTargetTurn?.activeAttemptId ?? null,
+      turnAssociation: supersession.steerTargetTurn ? "current" : null,
       payload: {
         operationId: reserved.receipt.id,
         targetUpdateId: update.id,
         replacedTurnId: supersession.replacedTurn?.id ?? null,
         actorSessionId: input.actor.sessionId,
-        stopping: supersession.liveCurrentTurnId !== null,
+        stopping: supersession.liveCurrentTurnId !== null && !supersession.deferredUntilCompaction,
+        ...(supersession.deferredUntilCompaction ? { deferredUntilCompaction: true } : {}),
       },
       occurredAt: now,
     },
@@ -2912,6 +3091,7 @@ export async function steerAgentSessionInTransaction(
           callerExecutionGeneration: input.actor.executionGeneration,
           controlRevision: resumed.revision,
           interruptionCount: supersession.interruptionCount,
+          deferredUntilCompaction: supersession.deferredUntilCompaction,
           workspaceControlEventId: resumed.workspaceControlEventId,
         },
       },
@@ -2928,6 +3108,7 @@ export async function steerAgentSessionInTransaction(
       wakeRevision,
       workflowId,
       interruptionCount: supersession.interruptionCount,
+      deferredUntilCompaction: supersession.deferredUntilCompaction,
     },
   });
   return {