@opengeni/db 1.0.1 → 3.2.0-canary.0

package/src/session-queue-commands.ts

@@ -3,6 +3,7 @@ import {
   XaiProviderAccountAuthoritySnapshotV1,
   DraftTimelineAnnotations,
   McpPersonalConnectionDelegations,
+  PersonalResourceAttachmentSummary,
   TimelineAnnotations,
   metadataWithTurnExecutionPolicyV1,
   mergeResourceRefs,
@@ -19,15 +20,17 @@ import {
   type SandboxOs,
   type SessionEvent,
   type SessionEventType,
+  type SessionPromptRouting,
   type SessionTurn,
   type SessionTurnSource,
   type SessionTurnStatus,
   type ToolRef,
   type TurnExecutionPolicyV1,
   type TimelineAnnotation,
+  type PersonalResourceAttachmentIntent,
 } from "@opengeni/contracts";
 import { and, asc, eq, inArray, sql } from "drizzle-orm";
-import type { Database, SessionActivityDatabase } from "./database";
+import { setSubjectRlsContext, type Database, type SessionActivityDatabase } from "./database";
 import {
   fromPostgresLosslessJson,
   fromPostgresLosslessText,
@@ -42,6 +45,7 @@ import {
   evaluateSessionControl,
   lockSessionEventWriteRows,
   lockWorkspaceInferenceControl,
+  lockWorkspaceInferenceControlForAdmission,
   registerInternalUpdateWakeInTransaction,
   reserveSessionCommandReceipt,
   registerSessionWorkflowWakeInTransaction,
@@ -52,6 +56,7 @@ import {
   updateSessionCommandReceiptResult,
 } from "./session-control";
 import { sessionRealtimeIsActiveInTransaction } from "./session-realtime-state";
+import { autoResumeGoalPausedByCapInTransaction } from "./session-goal-pacing";
 import {
   mirrorSessionRealtimeContextInTransaction,
   renderRealtimeHumanInputContext,
@@ -65,6 +70,8 @@ import {
   type FrozenTurnInitiator,
 } from "./turn-initiator";
 import { resolveXaiProviderAccountAuthoritySnapshotForAcceptanceInTransaction } from "./xai-subscription";
+import { assertActiveManagedHumanOrganizationMembership } from "./organization-membership-lifecycle";
+import { acceptTurnPersonalResourceAttachmentInTransaction } from "./user-resource-authority";
 
 type SessionEventInsertWithPayload = typeof schema.sessionEvents.$inferInsert & {
   payload: unknown;
@@ -77,7 +84,8 @@ export type QueueCommandConflictCode =
   | "PROMPT_CHANGED"
   | "DRAFT_CHANGED"
   | "DRAFT_NOT_EMPTY"
-  | "EDIT_SOURCE_CHANGED";
+  | "EDIT_SOURCE_CHANGED"
+  | "ONCE_ATTACHMENT_IMMUTABLE";
 
 export class QueueCommandConflictError extends Error {
   readonly name = "QueueCommandConflictError";
@@ -113,14 +121,19 @@ export type EditQueueCommandResult = QueueCommandResult & {
 export type SteerQueueCommandResult = QueueCommandResult & {
   interruptionCount: number;
   workspaceControlEventId: string | null;
+  workflowId: string;
+  wakeRevision: number;
 };
 
 export type SubmitHumanPromptResult = {
   receipt: SessionCommandReceiptRow;
+  routing: SessionPromptRouting;
   queueVersion: number;
   accepted: SessionEvent;
   events: SessionEvent[];
   turn: SessionTurn;
+  /** Current actor/session composer after an exact draft-bound submission. */
+  draft: ComposerDraftRow | null;
   /** Backward-compatible row identities for lower-level callers. */
   acceptedEventId: string;
   eventIds: string[];
@@ -170,7 +183,7 @@ function mapSubmittedPromptTurn(row: typeof schema.sessionTurns.$inferSelect): S
     toolsProvided: row.toolsProvided,
     model: row.model,
     reasoningEffort: row.reasoningEffort as ReasoningEffort,
-    latencyMode: (row.latencyMode as LatencyMode | null | undefined) ?? "standard",
+    latencyMode: row.latencyMode as LatencyMode,
     sandboxBackend: row.sandboxBackend as SandboxBackend,
     sandboxOs: (row.sandboxOs as SandboxOs | null) ?? null,
     metadata: row.metadata,
@@ -185,6 +198,9 @@ function mapSubmittedPromptTurn(row: typeof schema.sessionTurns.$inferSelect): S
     ),
     initiatorContext: row.initiatorContext ?? {},
     personalConnections,
+    personalResources: row.personalResourceAttachmentSummary
+      ? PersonalResourceAttachmentSummary.parse(row.personalResourceAttachmentSummary)
+      : null,
     cancelledBy: row.cancelledBy,
     cancelReason: row.cancelReason,
     startedAt: row.startedAt ? row.startedAt.toISOString() : null,
@@ -211,9 +227,16 @@ async function personalConnectionDelegationsForAgentActor(
   db: Database,
   workspaceId: string,
   actor: Extract<SessionCommandActor, { type: "agent_attempt" }>,
-): Promise<McpPersonalConnectionDelegation[]> {
+  targetSessionId: string,
+): Promise<{
+  delegations: McpPersonalConnectionDelegation[];
+  connectionAuthoritySubjectId: string | null;
+}> {
   const [row] = await db
-    .select({ delegations: schema.sessionTurns.personalConnectionDelegations })
+    .select({
+      delegations: schema.sessionTurns.personalConnectionDelegations,
+      initiatingHumanSubjectId: schema.sessionTurns.initiatingHumanSubjectId,
+    })
     .from(schema.sessionTurns)
     .where(
       and(
@@ -234,7 +257,37 @@ async function personalConnectionDelegationsForAgentActor(
       `Agent authority turn has malformed personal MCP delegation state: ${actor.sessionId}/${actor.turnId}`,
     );
   }
-  return parsed.data.map((delegation) => ({ ...delegation }));
+  // Agent messages and Agent Steer create new accepted work. A once grant is
+  // already bound to the caller turn, while a session grant may be projected
+  // only into another turn of that exact session. Always grants can cross the
+  // direct parent/child boundary subject to the live admission fences.
+  const delegations = parsed.data
+    .filter((delegation) => {
+      const authority = delegation.userDelegation;
+      if (!authority) return true;
+      if (authority.mode === "once") return false;
+      if (authority.mode === "session") return authority.sessionId === targetSessionId;
+      return true;
+    })
+    .map((delegation) => ({ ...delegation }));
+  const activated = delegations.filter((delegation) => delegation.userDelegation);
+  if (activated.length === 0) {
+    return { delegations, connectionAuthoritySubjectId: null };
+  }
+  const connectionAuthoritySubjectId = row.initiatingHumanSubjectId;
+  if (!connectionAuthoritySubjectId) {
+    throw new SessionControlInvariantError(
+      `Agent authority turn lost its causal human: ${actor.sessionId}/${actor.turnId}`,
+    );
+  }
+  for (const delegation of activated) {
+    if (delegation.ownerSubjectId !== connectionAuthoritySubjectId) {
+      throw new SessionControlInvariantError(
+        `Agent authority turn causal human does not own retained connection authority: ${actor.sessionId}/${actor.turnId}`,
+      );
+    }
+  }
+  return { delegations, connectionAuthoritySubjectId };
 }
 
 async function xaiAuthorityForAgentActor(
@@ -664,10 +717,19 @@ export async function saveComposerDraftInTransaction(
     resources: ResourceRef[];
     model: string;
     reasoningEffort: ReasoningEffort;
-    latencyMode?: LatencyMode;
+    latencyMode: LatencyMode;
+    /**
+     * Bound the workspace control prefix wait (request-scoped API callers pass
+     * `workspaceControlRequestLockTimeoutMs()`); omit for lifecycle callers.
+     */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<ComposerDraftRow> {
-  await lockWorkspaceInferenceControl(db, input.workspaceId, "share");
+  await lockWorkspaceInferenceControl(db, input.workspaceId, "share", {
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -698,7 +760,7 @@ export async function saveComposerDraftInTransaction(
     toolsProvided: false,
     model: input.model,
     reasoningEffort: input.reasoningEffort,
-    latencyMode: input.latencyMode ?? "standard",
+    latencyMode: input.latencyMode,
     // A queue edit is still the same accepted work item. Preserve its frozen
     // initiator through arbitrary draft saves; only a genuinely new compose or
     // Steer captures the submitting actor.
@@ -728,9 +790,18 @@ export async function moveQueuedTurnInTransaction(
     expectedQueueVersion: number;
     actor: SessionCommandActor;
     operationKey: string;
+    /**
+     * Bound the workspace control prefix wait (request-scoped API callers pass
+     * `workspaceControlRequestLockTimeoutMs()`); omit for lifecycle callers.
+     */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<QueueCommandResult> {
-  await lockWorkspaceInferenceControl(db, input.workspaceId, "share");
+  await lockWorkspaceInferenceControl(db, input.workspaceId, "share", {
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -864,9 +935,18 @@ export async function deleteSessionQueueItemInTransaction(
     actor: SessionCommandActor;
     operationKey: string;
     reason?: string | null;
+    /**
+     * Bound the workspace control prefix wait (request-scoped API callers pass
+     * `workspaceControlRequestLockTimeoutMs()`); omit for lifecycle callers.
+     */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<QueueCommandResult> {
-  await lockWorkspaceInferenceControl(db, input.workspaceId, "share");
+  await lockWorkspaceInferenceControl(db, input.workspaceId, "share", {
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -997,9 +1077,18 @@ export async function editQueuedTurnInTransaction(
     replaceDraft: boolean;
     actor: SessionCommandActor;
     operationKey: string;
+    /**
+     * Bound the workspace control prefix wait (request-scoped API callers pass
+     * `workspaceControlRequestLockTimeoutMs()`); omit for lifecycle callers.
+     */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<EditQueueCommandResult> {
-  await lockWorkspaceInferenceControl(db, input.workspaceId, "share");
+  await lockWorkspaceInferenceControl(db, input.workspaceId, "share", {
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -1070,6 +1159,17 @@ export async function editQueuedTurnInTransaction(
       draftRevision,
     });
   }
+  if (turn.personalResourceAttachmentSummary?.mode === "once") {
+    throw new QueueCommandConflictError(
+      "ONCE_ATTACHMENT_IMMUTABLE",
+      "A queued prompt with a once personal-resource attachment cannot be edited into new work",
+      {
+        queueVersion: session.queueVersion,
+        turnVersion: turn.version,
+        draftRevision,
+      },
+    );
+  }
   const nextDraftRevision = draftRevision + 1;
   const draftValues = {
     accountId: input.accountId,
@@ -1177,9 +1277,19 @@ export async function steerQueuedTurnInTransaction(
     controlEtag?: string | null;
     actor: SessionCommandActor;
     operationKey: string;
+    /** Request-scoped callers bound the control prefix wait; lifecycle callers omit it. */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<SteerQueueCommandResult> {
-  const workspaceControl = await lockWorkspaceInferenceControl(db, input.workspaceId, "update");
+  const admission = await lockWorkspaceInferenceControlForAdmission(db, {
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    resumePausedBranch: true,
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
+  const workspaceControl = admission.control;
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -1207,6 +1317,10 @@ export async function steerQueuedTurnInTransaction(
   });
   if (reserved.replay && reserved.receipt.appliedQueueVersion !== null) {
     const replaySession = await lockSession(db, input.workspaceId, input.sessionId);
+    const wakeRevision = Number(reserved.receipt.result.wakeRevision ?? 0);
+    if (wakeRevision < 1) {
+      throw new SessionControlInvariantError("Replayed queue Steer receipt has no wake revision");
+    }
     return {
       receipt: reserved.receipt,
       queueVersion: replaySession.queueVersion,
@@ -1217,6 +1331,8 @@ export async function steerQueuedTurnInTransaction(
         typeof reserved.receipt.result.workspaceControlEventId === "string"
           ? reserved.receipt.result.workspaceControlEventId
           : null,
+      workflowId: replaySession.temporalWorkflowId ?? `session-${input.sessionId}`,
+      wakeRevision,
       replay: true,
     };
   }
@@ -1244,6 +1360,7 @@ export async function steerQueuedTurnInTransaction(
         : input.actor.subjectId,
     reason: "human_steer",
     observedControlEtag: input.controlEtag ?? null,
+    admission,
   });
   const session = await lockSession(db, input.workspaceId, input.sessionId);
   const rows = await loadQueuedTurns(db, input.workspaceId, input.sessionId, true);
@@ -1395,6 +1512,8 @@ export async function steerQueuedTurnInTransaction(
     eventIds: eventRows.map((event) => event.id),
     interruptionCount,
     workspaceControlEventId: resumed.workspaceControlEventId,
+    workflowId: session.temporalWorkflowId ?? `session-${input.sessionId}`,
+    wakeRevision,
     replay: false,
   };
 }
@@ -1430,18 +1549,40 @@ export async function submitHumanPromptInTransaction(
       text: string;
       context: string;
     };
+    /** False when the human input originated inside the active realtime provider session. */
+    mirrorToRealtime?: boolean;
     source: "user" | "api";
     /** Record the admitted run's durable usage fact in this transaction. */
     recordAgentRunUsage?: boolean;
     personalConnectionDelegations?: McpPersonalConnectionDelegation[];
+    personalResourceAttachment?: PersonalResourceAttachmentIntent;
     mcpCredentialUpdates?: Array<{
       id: string;
       headersEncrypted: Record<string, string>;
     }>;
+    /** Request-scoped callers bound the control prefix wait; lifecycle callers omit it. */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<SubmitHumanPromptResult> {
   const annotations = TimelineAnnotations.parse(input.annotations ?? []);
-  const workspaceControl = await lockWorkspaceInferenceControl(db, input.workspaceId, "update");
+  // Send is inert queue admission while paused; Steer deliberately resumes.
+  // Tell the lock helper which path may need the exclusive control prefix.
+  const admission = await lockWorkspaceInferenceControlForAdmission(db, {
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    resumePausedBranch: input.delivery === "steer",
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
+  const workspaceControl = admission.control;
+  if (input.actor.type === "human") {
+    await setSubjectRlsContext(db, input.actor.subjectId);
+    await assertActiveManagedHumanOrganizationMembership(db, {
+      accountId: input.accountId,
+      subjectId: input.actor.subjectId,
+    });
+  }
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -1466,7 +1607,10 @@ export async function submitHumanPromptInTransaction(
     source: input.source,
     turnMetadata: input.turnMetadata ?? {},
     messagePresentation: input.messagePresentation ?? null,
+    mirrorToRealtime: input.mirrorToRealtime ?? true,
     mcpCredentialUpdates: input.mcpCredentialUpdates ?? [],
+    personalConnectionDelegations: input.personalConnectionDelegations ?? [],
+    personalResourceAttachment: input.personalResourceAttachment ?? null,
     ...(input.actor.type === "service"
       ? {
           serviceInitiator: {
@@ -1524,12 +1668,32 @@ export async function submitHumanPromptInTransaction(
     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: 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,
@@ -1550,34 +1714,39 @@ export async function submitHumanPromptInTransaction(
     throw new SessionControlConflictError();
   }
 
-  const resumed = await autoResumeSessionBranchInTransaction(db, {
-    workspaceId: input.workspaceId,
-    sessionId: input.sessionId,
-    actor:
-      input.actor.type === "agent_attempt"
-        ? `attempt:${input.actor.attemptId}`
-        : input.actor.subjectId,
-    reason:
-      input.actor.type === "service"
-        ? input.delivery === "steer"
-          ? "service_steer"
-          : "service_send"
-        : input.delivery === "steer"
-          ? "human_steer"
-          : "human_send",
-    observedControlEtag: input.controlEtag ?? null,
-  });
   const session = await lockSession(db, input.workspaceId, input.sessionId);
   if (session.status === "cancelled") {
     throw new QueueCommandConflictError(
       "QUEUE_PROMPT_STARTED",
-      "Cancelled session cannot accept work",
-      {
-        queueVersion: session.queueVersion,
-      },
+      "Cancelled session subtree cannot accept work",
+      { queueVersion: session.queueVersion },
     );
   }
 
+  // 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 resumed =
+    input.delivery === "send"
+      ? {
+          revision: before.controlVersion,
+          control: before,
+          changed: false,
+          workspaceControlEventId: null,
+        }
+      : await autoResumeSessionBranchInTransaction(db, {
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          actor:
+            input.actor.type === "agent_attempt"
+              ? `attempt:${input.actor.attemptId}`
+              : input.actor.subjectId,
+          reason: input.actor.type === "service" ? "service_steer" : "human_steer",
+          observedControlEtag: input.controlEtag ?? null,
+          admission,
+        });
+
   const draft =
     input.expectedDraftRevision === null || input.expectedDraftRevision === undefined
       ? null
@@ -1710,6 +1879,28 @@ export async function submitHumanPromptInTransaction(
       input.subjectLabel,
     );
   }
+  const acceptedInitiatingHumanSubjectId = editedSourceTurn
+    ? (editedSourceTurn.initiatingHumanSubjectId ??
+      (editedSourceTurn.initiatorKind === "subject" ? editedSourceTurn.initiatorSubjectId : null))
+    : (frozenInitiator.initiatingHumanSubjectId ??
+      (frozenInitiator.initiator.kind === "subject" ? frozenInitiator.initiator.subjectId : null));
+  if (
+    (input.personalConnectionDelegations ?? []).some(
+      (delegation) => delegation.userDelegation !== undefined,
+    ) ||
+    input.personalResourceAttachment !== undefined
+  ) {
+    if (!acceptedInitiatingHumanSubjectId) {
+      throw new SessionControlInvariantError("Personal authority requires an exact causal human");
+    }
+    await db.execute(
+      sql`select set_config(
+        'opengeni.initiating_human_subject_id',
+        ${acceptedInitiatingHumanSubjectId},
+        true
+      )`,
+    );
+  }
   const xaiProviderAccountAuthoritySnapshot = editedSourceTurn
     ? XaiProviderAccountAuthoritySnapshotV1.parse(
         editedSourceTurn.xaiProviderAccountAuthoritySnapshot,
@@ -1726,6 +1917,13 @@ export async function submitHumanPromptInTransaction(
     editedSourceModelContext !== undefined
       ? editedSourceModelContext
       : (input.modelContext ?? null);
+  const existingQueued = await loadQueuedTurns(db, input.workspaceId, input.sessionId, true);
+  const routing: SessionPromptRouting =
+    input.delivery === "steer"
+      ? "accepted_for_steering"
+      : before.state === "paused" || session.activeTurnId || existingQueued.length > 0
+        ? "queued_for_execution"
+        : "accepted_for_execution";
   let sequence = session.lastSequence;
   const eventValues: SessionEventInsertWithPayload[] = [
     {
@@ -1753,12 +1951,12 @@ export async function submitHumanPromptInTransaction(
         ...(input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}),
         ...(input.latencyMode ? { latencyMode: input.latencyMode } : {}),
         delivery: input.delivery,
+        routing,
         initiator: frozenInitiator.initiator,
       },
       occurredAt: now,
     },
   ];
-  const existingQueued = await loadQueuedTurns(db, input.workspaceId, input.sessionId, true);
   const [turn] = await db
     .insert(schema.sessionTurns)
     .values(
@@ -1772,6 +1970,7 @@ export async function submitHumanPromptInTransaction(
           temporalWorkflowId: workflowId,
           status: "queued",
           source: input.source,
+          promptRouting: routing,
           position: input.delivery === "steer" ? 0 : existingQueued.length + 1,
           prompt: input.text,
           annotations,
@@ -1788,14 +1987,7 @@ export async function submitHumanPromptInTransaction(
             : (input.turnMetadata ?? {}),
           lineage: { actor: input.actor.type },
           ...initiatorColumns(frozenInitiator),
-          initiatingHumanSubjectId: editedSourceTurn
-            ? (editedSourceTurn.initiatingHumanSubjectId ??
-              (editedSourceTurn.initiatorKind === "subject"
-                ? editedSourceTurn.initiatorSubjectId
-                : null))
-            : frozenInitiator.initiator.kind === "subject"
-              ? frozenInitiator.initiator.subjectId
-              : null,
+          initiatingHumanSubjectId: acceptedInitiatingHumanSubjectId,
           personalConnectionDelegations: editedSourceTurn
             ? editedSourceTurn.personalConnectionDelegations
             : (input.personalConnectionDelegations ?? []),
@@ -1810,6 +2002,49 @@ export async function submitHumanPromptInTransaction(
     .returning();
   if (!turn) throw new SessionControlInvariantError("Prompt turn was not inserted");
   let committedTurn = turn;
+  const personalResourceExpectedAuthorityEpoch =
+    input.personalResourceAttachment?.expectedAuthorityEpoch;
+  let acceptedPersonalResources: Awaited<
+    ReturnType<typeof acceptTurnPersonalResourceAttachmentInTransaction>
+  > | null = null;
+  if (input.personalResourceAttachment) {
+    if (personalResourceExpectedAuthorityEpoch === undefined) {
+      throw new SessionControlInvariantError(
+        "Personal-resource attachment requires an expected authority epoch",
+      );
+    }
+    acceptedPersonalResources = await acceptTurnPersonalResourceAttachmentInTransaction(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turnId,
+      subjectId: acceptedInitiatingHumanSubjectId!,
+      intent: {
+        ...input.personalResourceAttachment,
+        expectedAuthorityEpoch: personalResourceExpectedAuthorityEpoch,
+      },
+    });
+  }
+  if (acceptedPersonalResources) {
+    committedTurn = {
+      ...turn,
+      personalResourceAttachmentSummary: acceptedPersonalResources.summary,
+      personalResourceProtocolVersion: 1,
+    };
+    eventValues.push({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      turnId,
+      sequence: ++sequence,
+      type: "session.personal_resources.attached",
+      payload: {
+        turnId,
+        ...acceptedPersonalResources.summary,
+      },
+      occurredAt: now,
+    });
+  }
   eventValues.push({
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -1821,6 +2056,7 @@ export async function submitHumanPromptInTransaction(
       turnId,
       triggerEventId: acceptedEventId,
       source: input.source,
+      routing,
       initiator: frozenInitiator.initiator,
     },
     occurredAt: now,
@@ -1919,6 +2155,29 @@ export async function submitHumanPromptInTransaction(
     });
   }
 
+  // A human/API prompt is external input for the goal. A goal paused only by
+  // its continuation ceiling (`max_auto_continuations`, pacing rather than
+  // intent) resumes in this same commit; a user/API/agent/limits pause is never
+  // touched here. Goal row FOR UPDATE follows the session and turn locks above,
+  // the order the claim transaction uses.
+  const goalAutoResumed = await autoResumeGoalPausedByCapInTransaction(db, {
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    cause: { kind: "human_prompt", turnId },
+    now,
+  });
+  if (goalAutoResumed) {
+    eventValues.push({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      sequence: ++sequence,
+      type: "goal.resumed",
+      payload: goalAutoResumed.payload,
+      occurredAt: now,
+    });
+  }
+
   const ordered =
     input.delivery === "steer" ? [turn, ...existingQueued] : [...existingQueued, turn];
   await normalizeQueuePositions(
@@ -1945,13 +2204,7 @@ export async function submitHumanPromptInTransaction(
     .insert(schema.sessionEvents)
     .values(withLosslessContentWriteVersion(eventValues, "payload", "payloadCodecVersion"))
     .returning();
-  if (input.actor.type === "human") {
-    const realtimeRouting =
-      input.delivery === "steer"
-        ? "accepted_for_steering"
-        : session.activeTurnId || existingQueued.length > 0
-          ? "queued_for_execution"
-          : "accepted_for_execution";
+  if (input.actor.type === "human" && input.mirrorToRealtime !== false) {
     await mirrorSessionRealtimeContextInTransaction(db, {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -1962,12 +2215,12 @@ export async function submitHumanPromptInTransaction(
       channel: null,
       text: renderRealtimeHumanInputContext({
         delivery: input.delivery,
-        routing: realtimeRouting,
+        routing,
         text: renderTimelineAnnotationsForModel(input.text, annotations),
       }),
       payload: {
         delivery: input.delivery,
-        routing: realtimeRouting,
+        routing,
         acceptedEventId,
         instruction: "OpenGeni accepted and routed this user input; do not delegate it again.",
       },
@@ -1989,8 +2242,25 @@ export async function submitHumanPromptInTransaction(
       updatedAt: now,
     })
     .where(eq(schema.sessions.id, input.sessionId));
-  if (draft) {
-    await db.delete(schema.composerDrafts).where(eq(schema.composerDrafts.id, draft.id));
+  const [nextDraft] = draft
+    ? await db
+        .update(schema.composerDrafts)
+        .set({
+          revision: draft.revision + 1,
+          text: "",
+          annotations: [],
+          resources: [],
+          tools: [],
+          toolsProvided: false,
+          sourceTurnId: null,
+          sourceTurnVersion: null,
+          updatedAt: now,
+        })
+        .where(eq(schema.composerDrafts.id, draft.id))
+        .returning()
+    : [undefined];
+  if (draft && !nextDraft) {
+    throw new SessionControlInvariantError("Accepted composer draft did not rotate");
   }
   const wakeRevision = await registerSessionWorkflowWakeInTransaction(db, {
     accountId: input.accountId,
@@ -2051,7 +2321,7 @@ export async function submitHumanPromptInTransaction(
     controlRevision: resumed.revision,
     queueVersion,
     turnVersion: turn.version,
-    ...(draft ? { draftRevision: draft.revision } : {}),
+    ...(nextDraft ? { draftRevision: nextDraft.revision } : {}),
     result: {
       turnId,
       acceptedEventId,
@@ -2060,6 +2330,7 @@ export async function submitHumanPromptInTransaction(
       interruptionCount,
       replacedTurnId,
       workspaceControlEventId: resumed.workspaceControlEventId,
+      routing,
       ...(input.turnExecutionPolicy
         ? {
             executionPolicy: turnExecutionPolicyAuditMetadata(input.turnExecutionPolicy, turnId),
@@ -2074,10 +2345,12 @@ export async function submitHumanPromptInTransaction(
   }
   return {
     receipt,
+    routing,
     queueVersion,
     accepted,
     events,
     turn: mapSubmittedPromptTurn(committedTurn),
+    draft: nextDraft ?? null,
     acceptedEventId,
     eventIds,
     turnId,
@@ -2097,9 +2370,18 @@ export async function sendAgentMessageInTransaction(
     actor: Extract<SessionCommandActor, { type: "agent_attempt" }>;
     operationKey: string;
     text: string;
+    /**
+     * Bound the workspace control prefix wait (request-scoped API callers pass
+     * `workspaceControlRequestLockTimeoutMs()`); omit for lifecycle callers.
+     */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<AgentInternalUpdateCommandResult> {
-  const workspaceControl = await lockWorkspaceInferenceControl(db, input.workspaceId, "share");
+  const workspaceControl = await lockWorkspaceInferenceControl(db, input.workspaceId, "share", {
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -2148,11 +2430,13 @@ export async function sendAgentMessageInTransaction(
     targetSessionId: input.targetSessionId,
     action: "message",
   });
-  const personalConnectionDelegations = await personalConnectionDelegationsForAgentActor(
+  const inheritedConnectionAuthority = await personalConnectionDelegationsForAgentActor(
     db,
     input.workspaceId,
     input.actor,
+    input.targetSessionId,
   );
+  const personalConnectionDelegations = inheritedConnectionAuthority.delegations;
   const xaiAuthority = await xaiAuthorityForAgentActor(db, input.workspaceId, input.actor);
   const session = await lockSession(db, input.workspaceId, input.targetSessionId);
   if (session.status === "cancelled") {
@@ -2195,6 +2479,12 @@ export async function sendAgentMessageInTransaction(
               callerTurnId: input.actor.turnId,
               callerAttemptId: input.actor.attemptId,
               callerExecutionGeneration: input.actor.executionGeneration,
+              ...(inheritedConnectionAuthority.connectionAuthoritySubjectId
+                ? {
+                    connectionAuthoritySubjectId:
+                      inheritedConnectionAuthority.connectionAuthoritySubjectId,
+                  }
+                : {}),
               ...(xaiAuthority.subjectId ? { xaiAuthoritySubjectId: xaiAuthority.subjectId } : {}),
             },
             personalConnectionDelegations,
@@ -2210,29 +2500,52 @@ export async function sendAgentMessageInTransaction(
     )
     .returning({ id: schema.sessionSystemUpdates.id });
   if (!update) throw new SessionControlInvariantError("Agent message was not inserted");
-  const [event] = await db
-    .insert(schema.sessionEvents)
-    .values(
-      withLosslessContentWriteVersion(
-        {
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          sessionId: input.targetSessionId,
-          sequence: session.lastSequence + 1,
-          type: "system.update.pending",
-          payload: {
-            updateId: update.id,
-            kind: "agent_message",
-            sourceSessionId: input.actor.sessionId,
+  // An Agent message is external input for the target's goal. A goal paused
+  // only by its continuation ceiling (`max_auto_continuations`, pacing rather
+  // than intent) resumes in this same commit; any other pause stays. Goal row
+  // FOR UPDATE follows the session lock above, the goal tools' order.
+  const goalAutoResumed = await autoResumeGoalPausedByCapInTransaction(db, {
+    workspaceId: input.workspaceId,
+    sessionId: input.targetSessionId,
+    cause: { kind: "agent_message", updateId: update.id },
+    now,
+  });
+  const eventValues: SessionEventInsertWithPayload[] = [
+    {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.targetSessionId,
+      sequence: session.lastSequence + 1,
+      type: "system.update.pending",
+      payload: {
+        updateId: update.id,
+        kind: "agent_message",
+        sourceSessionId: input.actor.sessionId,
+      },
+      occurredAt: now,
+    },
+    ...(goalAutoResumed
+      ? [
+          {
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            sessionId: input.targetSessionId,
+            sequence: session.lastSequence + 2,
+            type: "goal.resumed" as const,
+            payload: goalAutoResumed.payload,
+            occurredAt: now,
           },
-          occurredAt: now,
-        },
-        "payload",
-        "payloadCodecVersion",
-      ),
-    )
+        ]
+      : []),
+  ];
+  const insertedEvents = await db
+    .insert(schema.sessionEvents)
+    .values(withLosslessContentWriteVersion(eventValues, "payload", "payloadCodecVersion"))
     .returning({ id: schema.sessionEvents.id });
-  if (!event) throw new SessionControlInvariantError("Agent message event was not inserted");
+  if (insertedEvents.length !== eventValues.length) {
+    throw new SessionControlInvariantError("Agent message event was not inserted");
+  }
+  const eventIds = insertedEvents.map((event) => event.id);
   const workflowId = session.temporalWorkflowId ?? `session-${session.id}`;
   const runnable = !realtimeActive && session.activeTurnId === null && effective.state === "active";
   const wake = runnable
@@ -2246,7 +2559,7 @@ export async function sendAgentMessageInTransaction(
   await db
     .update(schema.sessions)
     .set({
-      lastSequence: session.lastSequence + 1,
+      lastSequence: session.lastSequence + eventValues.length,
       ...(runnable ? { status: "queued" as const } : {}),
       updatedAt: now,
     })
@@ -2275,7 +2588,7 @@ export async function sendAgentMessageInTransaction(
   const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
     result: {
       updateId: update.id,
-      eventIds: [event.id],
+      eventIds,
       wakeRevision: wake?.wakeRevision ?? null,
       workflowId,
       effectiveState: effective.state,
@@ -2284,7 +2597,7 @@ export async function sendAgentMessageInTransaction(
   return {
     receipt,
     updateId: update.id,
-    eventIds: [event.id],
+    eventIds,
     wakeRevision: wake?.wakeRevision ?? null,
     shouldSignal: wake?.shouldSignal ?? false,
     workflowId,
@@ -2304,9 +2617,18 @@ export async function steerAgentSessionInTransaction(
     actor: Extract<SessionCommandActor, { type: "agent_attempt" }>;
     operationKey: string;
     instruction: string;
+    /** Request-scoped callers bound the control prefix wait; lifecycle callers omit it. */
+    controlLockTimeoutMs?: number;
   },
 ): Promise<AgentInternalUpdateCommandResult> {
-  await lockWorkspaceInferenceControl(db, input.workspaceId, "update");
+  const admission = await lockWorkspaceInferenceControlForAdmission(db, {
+    workspaceId: input.workspaceId,
+    sessionId: input.targetSessionId,
+    resumePausedBranch: true,
+    ...(input.controlLockTimeoutMs !== undefined
+      ? { lockTimeoutMs: input.controlLockTimeoutMs }
+      : {}),
+  });
   await lockSessionEventWriteRows(db, {
     workspaceId: input.workspaceId,
     controlLock: "already_locked",
@@ -2358,17 +2680,20 @@ export async function steerAgentSessionInTransaction(
     targetSessionId: input.targetSessionId,
     action: "steer",
   });
-  const personalConnectionDelegations = await personalConnectionDelegationsForAgentActor(
+  const inheritedConnectionAuthority = await personalConnectionDelegationsForAgentActor(
     db,
     input.workspaceId,
     input.actor,
+    input.targetSessionId,
   );
+  const personalConnectionDelegations = inheritedConnectionAuthority.delegations;
   const xaiAuthority = await xaiAuthorityForAgentActor(db, input.workspaceId, input.actor);
   const resumed = await autoResumeSessionBranchInTransaction(db, {
     workspaceId: input.workspaceId,
     sessionId: input.targetSessionId,
     actor: `attempt:${input.actor.attemptId}`,
     reason: "agent_steer",
+    admission,
   });
   const session = await lockSession(db, input.workspaceId, input.targetSessionId);
   if (session.status === "cancelled") {
@@ -2378,6 +2703,20 @@ export async function steerAgentSessionInTransaction(
       { queueVersion: session.queueVersion },
     );
   }
+  const now = new Date();
+  const updateId = crypto.randomUUID();
+  // An Agent Steer is external input for the target's goal. A goal paused only
+  // by its continuation ceiling (`max_auto_continuations`, pacing rather than
+  // intent) resumes here, before the supersession, so the Steer starts a fresh
+  // continuation epoch; any other pause stays. Goal row FOR UPDATE follows the
+  // session lock above; the `goal.resumed` fact is appended below at the next
+  // sequence of this same commit.
+  const goalAutoResumed = await autoResumeGoalPausedByCapInTransaction(db, {
+    workspaceId: input.workspaceId,
+    sessionId: input.targetSessionId,
+    cause: { kind: "agent_steer_instruction", updateId },
+    now,
+  });
   const supersession = await supersedeSessionCurrentDirectionInTransaction(db, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -2400,13 +2739,13 @@ export async function steerAgentSessionInTransaction(
       ),
     )
     .returning({ id: schema.sessionSystemUpdates.id });
-  const now = new Date();
   const [update] = await db
     .insert(schema.sessionSystemUpdates)
     .values(
       withLosslessContentWriteVersion(
         withLosslessContentWriteVersion(
           {
+            id: updateId,
             accountId: input.accountId,
             workspaceId: input.workspaceId,
             sessionId: input.targetSessionId,
@@ -2425,6 +2764,12 @@ export async function steerAgentSessionInTransaction(
               callerTurnId: input.actor.turnId,
               callerAttemptId: input.actor.attemptId,
               callerExecutionGeneration: input.actor.executionGeneration,
+              ...(inheritedConnectionAuthority.connectionAuthoritySubjectId
+                ? {
+                    connectionAuthoritySubjectId:
+                      inheritedConnectionAuthority.connectionAuthoritySubjectId,
+                  }
+                : {}),
               ...(xaiAuthority.subjectId ? { xaiAuthoritySubjectId: xaiAuthority.subjectId } : {}),
             },
             personalConnectionDelegations,
@@ -2506,6 +2851,17 @@ export async function steerAgentSessionInTransaction(
       occurredAt: now,
     },
   );
+  if (goalAutoResumed) {
+    events.push({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.targetSessionId,
+      sequence: ++sequence,
+      type: "goal.resumed",
+      payload: goalAutoResumed.payload,
+      occurredAt: now,
+    });
+  }
   const insertedEvents = await db
     .insert(schema.sessionEvents)
     .values(withLosslessContentWriteVersion(events, "payload", "payloadCodecVersion"))