@opengeni/db 5.0.1 → 6.0.0

package/src/schema.ts

@@ -1,5 +1,7 @@
+import type { StoredSessionAdmissionBlock } from "./session-admission-block";
 import type {
   SandboxProviderCommand,
+  CommandSupervisionReceipt,
   AutomationAcceptedExecution,
   AutomationSessionTemplate,
   AttemptToolCatalog,
@@ -7,6 +9,7 @@ import type {
   DraftTimelineAnnotation,
   FirstPartyMcpToolName,
   McpPersonalConnectionDelegation,
+  McpConnectionAccountBinding,
   PersonalResourceAttachmentIntent,
   PersonalResourceAttachmentSummary,
   Permission,
@@ -106,6 +109,46 @@ export const managedAccounts = pgTable(
   }),
 );
 
+export const organizationIntegrationPolicies = pgTable(
+  "organization_integration_policies",
+  {
+    accountId: uuid("account_id")
+      .primaryKey()
+      .references(() => managedAccounts.id, { onDelete: "cascade" }),
+    mode: text("mode").$type<"unrestricted" | "restricted">().notNull(),
+    allowedIntegrationKeys: jsonb("allowed_integration_keys").$type<string[]>().notNull(),
+    revision: bigint("revision", { mode: "number" }).notNull(),
+  },
+  (table) => ({
+    modeCheck: check(
+      "organization_integration_policies_mode_check",
+      sql`${table.mode} in ('unrestricted', 'restricted')`,
+    ),
+    keysCheck: check(
+      "organization_integration_policies_allowed_integration_keys_check",
+      sql`jsonb_typeof(${table.allowedIntegrationKeys}) = 'array'`,
+    ),
+    revisionCheck: check(
+      "organization_integration_policies_revision_check",
+      sql`${table.revision} between 1 and 9007199254740991`,
+    ),
+  }),
+);
+
+export const organizationIntegrationPolicyOperations = pgTable(
+  "organization_integration_policy_operations",
+  {
+    accountId: uuid("account_id")
+      .notNull()
+      .references(() => managedAccounts.id, { onDelete: "cascade" }),
+    operationId: uuid("operation_id").notNull(),
+    actorSubjectId: text("actor_subject_id").notNull(),
+    request: jsonb("request").notNull(),
+    result: jsonb("result").notNull(),
+  },
+  (table) => ({ identity: primaryKey({ columns: [table.accountId, table.operationId] }) }),
+);
+
 export const workspaces = pgTable(
   "workspaces",
   {
@@ -731,7 +774,8 @@ export const organizationPrivateSessionSettingEvents = pgTable(
     accountId: uuid("account_id")
       .notNull()
       .references(() => managedAccounts.id, { onDelete: "cascade" }),
-    actorMembershipId: uuid("actor_membership_id").notNull(),
+    actorMembershipId: uuid("actor_membership_id"),
+    actorSubjectId: text("actor_subject_id"),
     requestedEnabled: boolean("requested_enabled").notNull(),
     expectedVersion: bigint("expected_version", { mode: "number" }).notNull(),
     resultEnabled: boolean("result_enabled").notNull(),
@@ -752,6 +796,10 @@ export const organizationPrivateSessionSettingEvents = pgTable(
       "organization_private_session_setting_events_versions_check",
       sql`${table.expectedVersion} >= 0 and ${table.resultVersion} > 0`,
     ),
+    actorValid: check(
+      "organization_private_session_setting_events_actor_check",
+      sql`${table.actorMembershipId} is not null or (${table.actorSubjectId} is not null and ${table.actorSubjectId} like 'api_key:%')`,
+    ),
   }),
 );
 
@@ -1707,6 +1755,8 @@ export const connections = pgTable(
     kind: text("kind").notNull(),
     status: text("status").notNull().default("active"),
     credentialEncrypted: text("credential_encrypted").notNull(),
+    createOperationId: text("create_operation_id"),
+    createRequestDigest: text("create_request_digest"),
     grantedScopes: jsonb("granted_scopes").$type<string[]>().notNull().default([]),
     expiresAt: timestamp("expires_at", { withTimezone: true }),
     lastRefreshAt: timestamp("last_refresh_at", { withTimezone: true }),
@@ -1746,6 +1796,15 @@ export const connections = pgTable(
       table.providerDomain,
       table.status,
     ),
+    createOperation: uniqueIndex("connections_create_operation_uq")
+      .on(table.workspaceId, table.createdBySubjectId, table.createOperationId)
+      .where(sql`${table.createOperationId} is not null`),
+    createOperationPair: check(
+      "connections_create_operation_pair_check",
+      sql`(${table.createOperationId} is null and ${table.createRequestDigest} is null)
+        or (${table.createOperationId} is not null and ${table.createRequestDigest} is not null
+          and ${table.createdBySubjectId} is not null)`,
+    ),
     workspaceSubjectProvider: index("connections_workspace_subject_provider_idx").on(
       table.workspaceId,
       table.subjectId,
@@ -4369,6 +4428,7 @@ export const sessions = pgTable(
     // NULL and use the bounded metadata.role compatibility fallback at the
     // attempt-snapshot boundary.
     policyRole: text("policy_role"),
+    admissionBlock: jsonb("admission_block").$type<StoredSessionAdmissionBlock>(),
     resources: jsonb("resources").$type<unknown[]>().notNull().default([]),
     skills: jsonb("skills").$type<unknown[]>().notNull().default([]),
     tools: jsonb("tools").$type<unknown[]>().notNull().default([]),
@@ -4391,6 +4451,8 @@ export const sessions = pgTable(
       .notNull()
       .default("workspace_shared"),
     authorityEpoch: integer("authority_epoch").notNull().default(1),
+    // Old accepted epochs remain valid across sharing, never across revocation.
+    executionAuthorityEpoch: integer("execution_authority_epoch").notNull().default(1),
     // Agent-access scope (migration 0427). Declares how far a live attempt on
     // this session may reach across the workspace and how far peers may reach
     // into it. 'workspace' is the pre-0426 behaviour; 'user' limits reach to
@@ -4489,6 +4551,9 @@ export const sessions = pgTable(
       .$type<McpPersonalConnectionDelegation[]>()
       .notNull()
       .default([]),
+    initialMcpAccountBindings: jsonb("initial_mcp_account_bindings").$type<
+      McpConnectionAccountBinding[] | null
+    >(),
     // Initial accepted-work staging only. The initializer consumes this inside
     // the same transaction that inserts the first logical turn and grant
     // snapshots; runtime never authorizes from the session field.
@@ -4506,6 +4571,10 @@ export const sessions = pgTable(
     toolPolicy: jsonb("tool_policy").$type<SessionToolPolicy>().notNull(),
     // Optimistic-concurrency fence for durable session tool-policy writes.
     toolPolicyVersion: integer("tool_policy_version").notNull().default(1),
+    mcpApprovalPolicies: jsonb("mcp_approval_policies")
+      .$type<Record<string, SessionMcpApprovalPolicy>>()
+      .notNull()
+      .default({}),
     // The manager session that spawned this one via session_create. Set only
     // when the creating grant carried a worker-signed sessionId claim (a session
     // spawning a worker); null for direct API creates and scheduled-task runs.
@@ -6705,6 +6774,7 @@ export const sessionTurns = pgTable(
       .$type<McpPersonalConnectionDelegation[]>()
       .notNull()
       .default([]),
+    mcpAccountBindings: jsonb("mcp_account_bindings").$type<McpConnectionAccountBinding[] | null>(),
     // Credential-free public summary of a turn-bound personal Variable
     // Set/Rig attachment. Exact resource and grant identity lives only in the
     // immutable accepted-work snapshot tables.
@@ -8109,6 +8179,7 @@ export const sessionSystemUpdates = pgTable(
       .$type<McpPersonalConnectionDelegation[]>()
       .notNull()
       .default([]),
+    mcpAccountBindings: jsonb("mcp_account_bindings").$type<McpConnectionAccountBinding[] | null>(),
     xaiProviderAccountAuthoritySnapshot: jsonb("xai_provider_account_authority_snapshot")
       .$type<XaiProviderAccountAuthoritySnapshotV1>()
       .notNull()
@@ -8208,6 +8279,7 @@ export const sessionSystemUpdateOutbox = pgTable(
       .$type<McpPersonalConnectionDelegation[]>()
       .notNull()
       .default([]),
+    mcpAccountBindings: jsonb("mcp_account_bindings").$type<McpConnectionAccountBinding[] | null>(),
     xaiProviderAccountAuthoritySnapshot: jsonb("xai_provider_account_authority_snapshot")
       .$type<XaiProviderAccountAuthoritySnapshotV1>()
       .notNull()
@@ -9255,6 +9327,7 @@ export const sandboxLeases = pgTable(
       .notNull()
       .references(() => workspaces.id, { onDelete: "cascade" }),
     sandboxGroupId: uuid("sandbox_group_id").notNull(),
+    publicRecovery: jsonb("public_recovery").$type<Record<string, unknown>>(),
 
     unobservableCommandDrainIds: uuid("unobservable_command_drain_ids").array(),
     unobservableCommandCheckedAt: timestamp("unobservable_command_checked_at", {
@@ -9332,6 +9405,11 @@ export const sandboxLeases = pgTable(
     // can recover immediately without pretending it resumes one provider RPC.
     archiveCaptureTakeoverSafe: boolean("archive_capture_takeover_safe").notNull().default(false),
     archiveCaptureAttempt: integer("archive_capture_attempt"),
+    // Periodic capture cadence survives a failed claim's release and worker
+    // restarts. This is not evidence that a recovery archive was published.
+    archiveCaptureLastAttemptAt: timestamp("archive_capture_last_attempt_at", {
+      withTimezone: true,
+    }),
     archiveCaptureGeneration: integer("archive_capture_generation"),
     archiveCaptureStartedAt: timestamp("archive_capture_started_at", {
       withTimezone: true,
@@ -9844,6 +9922,13 @@ export const sandboxRetainedProcesses = pgTable(
     routeEpoch: integer("route_epoch").notNull(),
     providerSessionId: integer("provider_session_id").notNull(),
     providerCommand: jsonb("provider_command").$type<SandboxProviderCommand>(),
+    supervisionRetentionXid: customType<{ data: string }>({ dataType: () => "xid8" })(
+      "supervision_retention_xid",
+    ).default(sql`pg_current_xact_id()`),
+    supervisionReceipt: jsonb("supervision_receipt").$type<CommandSupervisionReceipt>(),
+    supervisionOutputCaptured: boolean("supervision_output_captured").notNull().default(false),
+    cancellationRequestedAt: timestamp("cancellation_requested_at", { withTimezone: true }),
+    cancellationReason: text("cancellation_reason"),
     providerCommandInputIndex: bigint("provider_command_input_index", { mode: "number" })
       .notNull()
       .default(0),
@@ -9943,7 +10028,7 @@ export const sandboxRetainedProcesses = pgTable(
       sql`${table.providerCommand} IS NULL OR ((
         ${table.providerBackend} = 'modal'
         AND jsonb_typeof(${table.providerCommand}) = 'object'
-        AND ${table.providerCommand}->>'kind' = 'modal-control-v1'
+        AND ${table.providerCommand}->>'kind' IN ('modal-control-v1', 'modal-router-v1')
         AND ${table.providerCommand}->>'sandboxId' = ${table.providerInstanceId}
         AND length(${table.providerCommand}->>'taskId') > 0
         AND length(${table.providerCommand}->>'execId') > 0
@@ -11078,6 +11163,7 @@ export const scheduledTasks = pgTable(
       .notNull()
       .references(() => workspaces.id, { onDelete: "cascade" }),
     name: text("name").notNull(),
+    ownerSubjectId: text("owner_subject_id"),
     status: text("status").notNull().default("active"),
     schedule: jsonb("schedule").$type<unknown>().notNull(),
     temporalScheduleId: text("temporal_schedule_id").notNull(),
@@ -11729,6 +11815,17 @@ export const usageEvents = pgTable(
       table.eventType,
       table.occurredAt,
     ),
+    accountRecent: index("usage_events_account_recent_idx").on(
+      table.accountId,
+      table.occurredAt.desc(),
+      table.recordedAt.desc(),
+    ),
+    workspaceRecent: index("usage_events_workspace_recent_idx").on(
+      table.accountId,
+      table.workspaceId,
+      table.occurredAt.desc(),
+      table.recordedAt.desc(),
+    ),
     workspaceSession: index("usage_events_workspace_session_idx").on(
       table.workspaceId,
       table.sessionId,
@@ -12159,80 +12256,6 @@ export const auditEvents = pgTable(
   }),
 );
 
-export const packInstallations = pgTable(
-  "pack_installations",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    accountId: uuid("account_id")
-      .notNull()
-      .references(() => managedAccounts.id, { onDelete: "cascade" }),
-    workspaceId: uuid("workspace_id")
-      .notNull()
-      .references(() => workspaces.id, { onDelete: "cascade" }),
-    packId: text("pack_id").notNull(),
-    status: text("status").notNull().default("active"),
-    version: integer("version").notNull().default(1),
-    manifestSnapshot: jsonb("manifest_snapshot").$type<Record<string, unknown>>(),
-    manifestDigest: text("manifest_digest"),
-    selectedRigId: uuid("selected_rig_id").references(() => rigs.id, {
-      onDelete: "set null",
-    }),
-    installedBySubjectId: text("installed_by_subject_id"),
-    metadata: jsonb("metadata").$type<Record<string, unknown>>().notNull().default({}),
-    enabledAt: timestamp("enabled_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => ({
-    workspaceIdentity: uniqueIndex("pack_installations_workspace_id_uq").on(
-      table.workspaceId,
-      table.id,
-    ),
-    workspacePack: uniqueIndex("pack_installations_workspace_pack_idx").on(
-      table.workspaceId,
-      table.packId,
-    ),
-    status: index("pack_installations_workspace_status_idx").on(table.workspaceId, table.status),
-    selectedRig: index("pack_installations_workspace_rig_idx")
-      .on(table.workspaceId, table.selectedRigId)
-      .where(sql`${table.selectedRigId} is not null`),
-  }),
-);
-
-export const packInstallationComponents = pgTable(
-  "pack_installation_components",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    accountId: uuid("account_id")
-      .notNull()
-      .references(() => managedAccounts.id, { onDelete: "cascade" }),
-    workspaceId: uuid("workspace_id")
-      .notNull()
-      .references(() => workspaces.id, { onDelete: "cascade" }),
-    packInstallationId: uuid("pack_installation_id")
-      .notNull()
-      .references(() => packInstallations.id, { onDelete: "cascade" }),
-    componentKey: text("component_key").notNull(),
-    kind: text("kind").notNull(),
-    capabilityId: text("capability_id").notNull(),
-    resolvedId: text("resolved_id").notNull(),
-    digest: text("digest").notNull(),
-    metadata: jsonb("metadata").$type<Record<string, unknown>>().notNull().default({}),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => ({
-    installationKey: uniqueIndex("pack_installation_components_pack_key_uq").on(
-      table.packInstallationId,
-      table.componentKey,
-    ),
-    workspaceCapability: index("pack_installation_components_workspace_capability_idx").on(
-      table.workspaceId,
-      table.kind,
-      table.capabilityId,
-    ),
-  }),
-);
-
 export const automationSources = pgTable(
   "automation_sources",
   {
@@ -12250,8 +12273,7 @@ export const automationSources = pgTable(
     webhookSecretEncrypted: text("webhook_secret_encrypted").notNull(),
     status: text("status").notNull().default("active"),
     version: integer("version").notNull().default(1),
-    packInstallationId: uuid("pack_installation_id"),
-    packConnectorId: text("pack_connector_id"),
+
     createdBySubjectId: text("created_by_subject_id").notNull(),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
@@ -12273,21 +12295,13 @@ export const automationSources = pgTable(
         and octet_length(${table.name}) between 1 and 512
         and octet_length(${table.adapterId}) between 1 and 128
         and octet_length(${table.createdBySubjectId}) between 1 and 4096
-        and jsonb_typeof(${table.configuration}) = 'object'
-        and ((${table.packInstallationId} is null and ${table.packConnectorId} is null)
-          or (${table.packInstallationId} is not null
-            and octet_length(${table.packConnectorId}) between 1 and 128))`,
+        and jsonb_typeof(${table.configuration}) = 'object'`,
     ),
     workspaceAccount: foreignKey({
       columns: [table.workspaceId, table.accountId],
       foreignColumns: [workspaces.id, workspaces.accountId],
       name: "automation_sources_workspace_account_fk",
     }).onDelete("cascade"),
-    packInstallation: foreignKey({
-      columns: [table.workspaceId, table.packInstallationId],
-      foreignColumns: [packInstallations.workspaceId, packInstallations.id],
-      name: "automation_sources_pack_installation_fk",
-    }).onDelete("cascade"),
   }),
 );
 
@@ -12333,8 +12347,7 @@ export const automationTriggers = pgTable(
     name: text("name").notNull(),
     status: text("status").notNull().default("active"),
     currentRevision: integer("current_revision").notNull().default(1),
-    packInstallationId: uuid("pack_installation_id"),
-    packTemplateId: text("pack_template_id"),
+
     createdBySubjectId: text("created_by_subject_id").notNull(),
     createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
@@ -12358,11 +12371,7 @@ export const automationTriggers = pgTable(
       foreignColumns: [automationSources.workspaceId, automationSources.id],
       name: "automation_triggers_source_fk",
     }).onDelete("cascade"),
-    packInstallation: foreignKey({
-      columns: [table.workspaceId, table.packInstallationId],
-      foreignColumns: [packInstallations.workspaceId, packInstallations.id],
-      name: "automation_triggers_pack_installation_fk",
-    }).onDelete("cascade"),
+
     workspaceAccount: foreignKey({
       columns: [table.workspaceId, table.accountId],
       foreignColumns: [workspaces.id, workspaces.accountId],
@@ -12373,9 +12382,7 @@ export const automationTriggers = pgTable(
       sql`${table.status} in ('active', 'paused', 'disabled')
         and ${table.currentRevision} > 0
         and octet_length(${table.name}) between 1 and 512
-        and octet_length(${table.createdBySubjectId}) between 1 and 4096
-        and ((${table.packInstallationId} is null and ${table.packTemplateId} is null)
-          or (${table.packInstallationId} is not null and octet_length(${table.packTemplateId}) between 1 and 128))`,
+        and octet_length(${table.createdBySubjectId}) between 1 and 4096`,
     ),
   }),
 );
@@ -12605,29 +12612,6 @@ export const automationRunEventLinks = pgTable(
   }),
 );
 
-export const workspacePacks = pgTable(
-  "workspace_packs",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    accountId: uuid("account_id")
-      .notNull()
-      .references(() => managedAccounts.id, { onDelete: "cascade" }),
-    workspaceId: uuid("workspace_id")
-      .notNull()
-      .references(() => workspaces.id, { onDelete: "cascade" }),
-    packId: text("pack_id").notNull(),
-    manifest: jsonb("manifest").$type<Record<string, unknown>>().notNull(),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
-  },
-  (table) => ({
-    workspacePack: uniqueIndex("workspace_packs_workspace_pack_idx").on(
-      table.workspaceId,
-      table.packId,
-    ),
-  }),
-);
-
 export const importBatches = pgTable(
   "import_batches",
   {

package/src/session-admission-block.ts

@@ -0,0 +1,29 @@
+import { SessionAdmissionBlock, SessionStatus } from "@opengeni/contracts";
+import { z } from "zod";
+
+export type SessionAdmissionFence = { lastSequence: number; controlVersion: number };
+export const StoredSessionAdmissionBlock = SessionAdmissionBlock.extend({
+  attemptId: z.string().uuid(),
+  fence: z
+    .object({
+      lastSequence: z.number().int().nonnegative(),
+      controlVersion: z.number().int().nonnegative(),
+    })
+    .strict(),
+  previousStatus: SessionStatus.exclude(["failed", "cancelled"]),
+}).strict();
+export type StoredSessionAdmissionBlock = z.infer<typeof StoredSessionAdmissionBlock>;
+
+/** Never expose internal attempt/fence identities through the public projection. */
+export function projectSessionAdmissionBlock(
+  value: StoredSessionAdmissionBlock | null | undefined,
+): SessionAdmissionBlock | null {
+  if (!value) return null;
+  StoredSessionAdmissionBlock.parse(value);
+  return SessionAdmissionBlock.parse({
+    reason: value.reason,
+    sqlState: value.sqlState,
+    retryPolicy: value.retryPolicy,
+    blockedAt: value.blockedAt,
+  });
+}

package/src/session-attempt-writers.ts

@@ -0,0 +1,48 @@
+import { sql, type SQL } from "drizzle-orm";
+
+/** Physical writers retain ownership after logical settlement. A durably
+ * adopted background command owns its lifetime independently of the turn. */
+export function sessionAttemptPendingWritersSql(attempt: SQL): SQL {
+  return sql`(
+    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
+          ))
+        )
+        and not exists (
+          select 1 from sandbox_retained_processes process
+          join session_background_commands command on command.retained_process_id = process.id
+          where process.account_id = ${attempt}.account_id
+            and process.workspace_id = ${attempt}.workspace_id
+            and process.session_id = ${attempt}.session_id
+            and (process.parent_admission_id = admission.id
+              or (admission.actor_kind = 'process' and process.id = admission.actor_id))
+            and command.state in ('running', 'stopping')
+        )
+    ) 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'
+        and not exists (
+          select 1 from session_background_commands command
+          where command.retained_process_id = process.id
+            and command.state in ('running', 'stopping')
+        )
+    )
+  )`;
+}

package/src/session-control.ts

@@ -492,7 +492,7 @@ function lockBudgetFor(options: WorkspaceControlLockOptions): WorkspaceControlLo
 }
 
 /** Run one lock-acquiring statement under the remaining budget. */
-async function boundedLockStep<T>(
+export async function boundedLockStep<T>(
   db: Database,
   workspaceId: string,
   budget: WorkspaceControlLockBudget | null,
@@ -989,11 +989,15 @@ export function sessionAuthoritySnapshotMatchesSession(
   session: Pick<
     typeof schema.sessions.$inferSelect,
     "authorityEpoch" | "visibility" | "ownerOrganizationMembershipId"
-  >,
+  > & { executionAuthorityEpoch?: number },
 ): boolean {
   return (
-    snapshot.authorityEpoch === session.authorityEpoch &&
-    snapshot.authorityVisibility === session.visibility &&
+    snapshot.authorityEpoch >= (session.executionAuthorityEpoch ?? session.authorityEpoch) &&
+    snapshot.authorityEpoch <= session.authorityEpoch &&
+    (snapshot.authorityVisibility === session.visibility ||
+      (snapshot.authorityVisibility === "user_private" &&
+        session.visibility === "workspace_shared" &&
+        snapshot.authorityEpoch < session.authorityEpoch)) &&
     snapshot.authorityOwnerOrganizationMembershipId ===
       (session.ownerOrganizationMembershipId ?? null)
   );
@@ -2805,10 +2809,12 @@ async function insertChildOutboxRowInTransaction(
   }
   let personalConnectionDelegations: (typeof schema.sessionTurns.$inferSelect)["personalConnectionDelegations"] =
     [];
+  let mcpAccountBindings: (typeof schema.sessionTurns.$inferSelect)["mcpAccountBindings"] = null;
   if (input.childSession.parentTurnId) {
     const [parentTurn] = await db
       .select({
         delegations: schema.sessionTurns.personalConnectionDelegations,
+        mcpAccountBindings: schema.sessionTurns.mcpAccountBindings,
       })
       .from(schema.sessionTurns)
       .where(
@@ -2820,6 +2826,7 @@ async function insertChildOutboxRowInTransaction(
       )
       .limit(1);
     if (parentTurn) {
+      mcpAccountBindings = parentTurn.mcpAccountBindings;
       const parsed = McpPersonalConnectionDelegations.safeParse(parentTurn.delegations);
       if (!parsed.success) {
         throw new SessionControlInvariantError(
@@ -2856,6 +2863,7 @@ async function insertChildOutboxRowInTransaction(
               ...(input.lineage ?? {}),
             },
             personalConnectionDelegations,
+            mcpAccountBindings,
           },
           "summary",
           "summaryCodecVersion",
@@ -3518,7 +3526,8 @@ export async function mutateSessionControlInTransaction(
             sessionId: input.sessionId,
             directPauseRevision,
           }))
-        : before.state === "paused" ||
+        : targetSession.admissionBlock != null ||
+          before.state === "paused" ||
           (await continuableWakeRepairNeeded(db, {
             workspaceId: input.workspaceId,
             rootSessionId: input.sessionId,
@@ -3603,6 +3612,7 @@ export async function mutateSessionControlInTransaction(
       input.action === "pause" || input.action === "cancel"
         ? {
             directControlState: "paused",
+            ...(input.action === "cancel" ? { admissionBlock: null } : {}),
             directPauseRevision: revision,
             controlVersion: revision,
             directControlReason: input.reason ?? null,
@@ -3615,6 +3625,12 @@ export async function mutateSessionControlInTransaction(
           }
         : {
             directControlState: "active",
+            ...(targetSession.admissionBlock
+              ? {
+                  admissionBlock: null,
+                  status: targetSession.admissionBlock.previousStatus,
+                }
+              : {}),
             directPauseRevision: null,
             subtreeRunOverrideRevision: revision,
             controlVersion: revision,