@opengeni/worker-bundle 1.0.1 → 2.0.0

package/src/activities/scheduled-tasks.ts

@@ -17,7 +17,6 @@ import {
   type ScheduledTaskRun,
 } from "@opengeni/contracts";
 import {
-  defaultSessionMcpServerIds,
   openGeniSlackBotMetadata,
   requireOpenGeniSlackBotConnection,
   resolveWorkspaceCatalogSettings,
@@ -25,6 +24,12 @@ import {
   workspaceCustomModelReference,
   lockActiveCustomModelForAdmission,
   scheduledSlackBotConnectionId,
+  freezeConnectionAccounts,
+  ConnectionAccountSelectionError,
+  scheduledConnectionSurfaceEligibility,
+  scheduledConnectionTools,
+  settingsWithEnabledCapabilityMcpServers,
+  settingsWithSessionMcpServerMetadata,
   swapActiveSandbox,
 } from "@opengeni/core";
 import {
@@ -41,7 +46,6 @@ import {
   getScheduledTaskRunAcceptedExecution,
   getScheduledTaskRunByProducerKey,
   getScheduledTargetSessionExecution,
-  getScheduledTaskPersonalConnectionDelegations,
   getScheduledTaskRunPersonalResourceAuthority,
   getScheduledTaskPersonalResourceAuthoritySubject,
   getScheduledTaskRevisionAuthority,
@@ -57,7 +61,6 @@ import {
   isCodexBilledModel,
   initializeSessionStartAtomically,
   materializeScheduledTaskReusableSessionFromRun,
-  listEnabledMcpCapabilityServerIds,
   listInstalledApiIntegrationServerIdsForDelegations,
   markScheduledTaskRunFailedIfQueued,
   markScheduledTaskRunSkippedIfQueued,
@@ -391,20 +394,6 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
       if (incidentDeclaration.action === "blocked") {
         return incidentDeclaration;
       }
-      const taskPersonalConnectionDelegations = await getScheduledTaskPersonalConnectionDelegations(
-        db,
-        task.workspaceId,
-        task.id,
-      );
-      const taskConnectionAuthoritySubjects = [
-        ...new Set(
-          taskPersonalConnectionDelegations.map((delegation) => delegation.ownerSubjectId),
-        ),
-      ];
-      if (taskConnectionAuthoritySubjects.length > 1) {
-        throw new Error("scheduled connection authority has multiple causal humans");
-      }
-      const taskConnectionAuthoritySubjectId = taskConnectionAuthoritySubjects[0] ?? null;
       const taskPersonalResourceAuthoritySubjectId =
         await getScheduledTaskPersonalResourceAuthoritySubject(db, {
           accountId: task.accountId,
@@ -418,17 +407,16 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
         taskId: task.id,
         taskAuthorityRevision: task.authorityRevision,
       });
+      const taskAuthoritySubjectId = task.ownerSubjectId;
       if (
-        taskConnectionAuthoritySubjectId &&
-        taskPersonalResourceAuthoritySubjectId &&
-        taskConnectionAuthoritySubjectId !== taskPersonalResourceAuthoritySubjectId
+        task.action.kind === "agent_turn" &&
+        ((taskRevisionAuthority?.subjectId ?? null) !== taskAuthoritySubjectId ||
+          [taskPersonalResourceAuthoritySubjectId].some(
+            (subject) => subject !== null && subject !== taskAuthoritySubjectId,
+          ))
       ) {
-        throw new Error("scheduled authority classes have different causal humans");
+        throw new Error("scheduled authority differs from its immutable execution owner");
       }
-      const taskAuthoritySubjectId =
-        taskRevisionAuthority?.subjectId ??
-        taskPersonalResourceAuthoritySubjectId ??
-        taskConnectionAuthoritySubjectId;
       const acceptedTargetSessionId =
         task.runMode === "existing_session"
           ? task.targetSessionId
@@ -467,6 +455,60 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
       const firstPartyMcpPermissions = creatorPolicy?.firstPartyMcpPermissions
         ? [...creatorPolicy.firstPartyMcpPermissions]
         : [...DEFAULT_FIRST_PARTY_MCP_PERMISSIONS];
+      // A fresh occurrence resolves the immutable owner's current accounts.
+      // Retry/recovery above uses the already accepted occurrence snapshot.
+      const connectionSettings = await settingsWithEnabledCapabilityMcpServers(
+        db,
+        task.workspaceId,
+        settings,
+        taskAuthoritySubjectId ? { subjectId: taskAuthoritySubjectId } : {},
+      );
+      const connectionTarget =
+        acceptedTargetSessionId && targetSessionExecutionBase
+          ? await requireSession(db, task.workspaceId, acceptedTargetSessionId)
+          : null;
+      const connectionTools = await scheduledConnectionTools(
+        db,
+        task.workspaceId,
+        connectionSettings,
+        connectionTarget,
+        taskTools,
+        taskAuthoritySubjectId ?? undefined,
+      );
+      const taskConnections = await freezeConnectionAccounts({
+        db,
+        accountId: task.accountId,
+        workspaceId: task.workspaceId,
+        settings: connectionTarget
+          ? settingsWithSessionMcpServerMetadata(connectionSettings, connectionTarget.mcpServers)
+          : connectionSettings,
+        tools: connectionTools,
+        resources: connectionTarget?.resources ?? task.agentConfig.resources,
+        source: taskAuthoritySubjectId
+          ? { kind: "subject", subjectId: taskAuthoritySubjectId, accountId: task.accountId }
+          : { kind: "none" },
+        authoritySelections: task.agentConfig.connectionAccounts ?? [],
+        authoritySelectionsFrozen: task.agentConfig.connectionAccountsFrozen === true,
+        ...scheduledConnectionSurfaceEligibility(
+          settings,
+          connectionTarget ?? {
+            firstPartyMcpTools,
+            firstPartyMcpPermissions,
+          },
+        ),
+      }).catch((error: unknown) => {
+        if (error instanceof ConnectionAccountSelectionError) return null;
+        throw error;
+      });
+      if (taskConnections === null) {
+        return { action: "blocked", reason: "connection_account_unavailable" };
+      }
+      const {
+        personalConnectionDelegations: taskPersonalConnectionDelegations,
+        mcpAccountBindings: taskMcpAccountBindings,
+      } = taskConnections;
+      const taskConnectionAuthoritySubjectId =
+        taskPersonalConnectionDelegations.length > 0 ? taskAuthoritySubjectId : null;
       const creatorSessionPolicy = scheduledCreatorSessionPolicyInput(
         creatorPolicy?.sessionPolicy ?? null,
       );
@@ -537,20 +579,16 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
         : null;
       const targetSessionExecution = targetSessionExecutionBase
         ? await (async () => {
-            const [capabilityServerIds, apiIntegrationServerIds] = await Promise.all([
-              listEnabledMcpCapabilityServerIds(db, task.workspaceId),
-              listInstalledApiIntegrationServerIdsForDelegations(
+            const apiIntegrationServerIds =
+              await listInstalledApiIntegrationServerIdsForDelegations(
                 db,
                 task.workspaceId,
                 taskPersonalConnectionDelegations,
-              ),
+              );
+            const availableMcpServerIds = new Set([
+              ...connectionSettings.mcpServers.map((server) => server.id),
+              ...apiIntegrationServerIds,
             ]);
-            const workspaceDefaultMcpServerIds = new Set(
-              settings.mcpServers.map((server) => server.id),
-            );
-            for (const id of capabilityServerIds) workspaceDefaultMcpServerIds.add(id);
-            for (const id of apiIntegrationServerIds) workspaceDefaultMcpServerIds.add(id);
-            const availableMcpServerIds = new Set(workspaceDefaultMcpServerIds);
             for (const id of targetSessionExecutionBase.mcpServerIds) {
               availableMcpServerIds.add(id);
             }
@@ -558,9 +596,10 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
               toolPolicy: targetSessionExecutionBase.toolPolicy,
               sessionTools: targetSessionExecutionBase.tools,
               availableMcpServerIds,
-              defaultMcpServerIds: defaultSessionMcpServerIds(
-                [...workspaceDefaultMcpServerIds].map((id) => ({ id })),
-              ),
+              defaultMcpServerIds: [
+                ...connectionTools.map((tool) => tool.id),
+                ...apiIntegrationServerIds,
+              ],
             });
             return {
               ...targetSessionExecutionBase,
@@ -604,7 +643,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
             )
           : null;
       if (generatedTarget && task.rigId && (!acceptedRig || !acceptedRig.activeVersion)) {
-        throw new Error(`rig has no active version to bind: ${task.rigId}`);
+        throw new Error(`sandbox environment has no active version to bind: ${task.rigId}`);
       }
       const acceptedRigDefaultVariableSets = acceptedRig?.activeVersion
         ? await Promise.all(
@@ -619,7 +658,9 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
                 variableSetId,
               );
               if (!variableSet) {
-                throw new Error(`rig default Variable Set not found: ${variableSetId}`);
+                throw new Error(
+                  `sandbox environment default Variable Set not found: ${variableSetId}`,
+                );
               }
               return { id: variableSet.id, generation: variableSet.generation };
             }),
@@ -843,6 +884,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
           targetSessionExecution,
           generatedSessionBinding,
           personalConnectionDelegations: taskPersonalConnectionDelegations,
+          mcpAccountBindings: taskMcpAccountBindings,
           personalResourceAuthoritySubjectId: taskPersonalResourceAuthoritySubjectId,
           causalHumanSubjectId,
           causalHumanAuthority: taskRevisionAuthority,
@@ -966,16 +1008,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
                 taskId: task.id,
               },
             );
-            if (
-              stableJson({
-                task: exactAuthority.task,
-                personalConnectionDelegations: exactAuthority.personalConnectionDelegations,
-              }) !==
-              stableJson({
-                task,
-                personalConnectionDelegations: taskPersonalConnectionDelegations,
-              })
-            ) {
+            if (stableJson(exactAuthority) !== stableJson(task)) {
               throw new IncidentTelemetryPreflightBlockedError(
                 "incident_preflight_metadata_missing",
               );
@@ -1009,7 +1042,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
             if (task.rigId) {
               const rig = acceptedRig;
               if (!rig || !rig.activeVersion) {
-                throw new Error(`rig has no active version to bind: ${task.rigId}`);
+                throw new Error(`sandbox environment has no active version to bind: ${task.rigId}`);
               }
               frozenRigId = rig.id;
               frozenRigVersionId =
@@ -1017,7 +1050,9 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
                   (resource) => resource.resourceKind === "rig" && resource.resourceId === rig.id,
                 )?.resourceVersionId ?? rig.activeVersion.id;
               if (frozenRigVersionId !== rig.activeVersion.id) {
-                throw new Error("scheduled run rig version changed during admission");
+                throw new Error(
+                  "scheduled run sandbox environment version changed during admission",
+                );
               }
             }
             let session: Awaited<ReturnType<typeof createSession>>;
@@ -1368,6 +1403,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
                     : {}),
                 },
                 personalConnectionDelegations: taskPersonalConnectionDelegations,
+                mcpAccountBindings: taskMcpAccountBindings,
                 xaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
                 scheduledTaskRunId: run.id,
               },
@@ -1495,6 +1531,7 @@ export function createScheduledTaskActivities(services: () => Promise<ControlAct
                     : {}),
                 },
                 personalConnectionDelegations: taskPersonalConnectionDelegations,
+                mcpAccountBindings: taskMcpAccountBindings,
                 xaiProviderAccountAuthoritySnapshot: taskXaiProviderAccountAuthoritySnapshot,
                 scheduledTaskRunId: run.id,
               },
@@ -1799,18 +1836,10 @@ async function prepareIncidentTelemetrySource(input: {
   workspaceId: string;
   sessionId: string;
   alertOccurrenceLabels: Readonly<Record<string, string>> | null;
-  acceptedExecution?: ScheduledTaskRunAcceptedExecution;
+  acceptedExecution: ScheduledTaskRunAcceptedExecution;
 }) {
   const session = await requireSession(input.tx, input.workspaceId, input.sessionId);
-  const { task, personalConnectionDelegations } = input.acceptedExecution
-    ? {
-        task: input.acceptedExecution.task,
-        personalConnectionDelegations: input.acceptedExecution.personalConnectionDelegations,
-      }
-    : await requireScheduledTaskIncidentAuthorityInTransaction(input.tx, {
-        workspaceId: input.workspaceId,
-        taskId: input.taskId,
-      });
+  const { task, personalConnectionDelegations } = input.acceptedExecution;
   const responder = await resolveIncidentTelemetryResponderMetadata({
     db: input.tx,
     settings: input.settings,
@@ -1818,39 +1847,34 @@ async function prepareIncidentTelemetrySource(input: {
     session,
     personalConnectionDelegations,
     personalResourceAuthoritySubjectId:
-      input.acceptedExecution?.personalResourceAuthoritySubjectId ?? null,
-    ...(input.acceptedExecution
+      input.acceptedExecution.personalResourceAuthoritySubjectId ?? null,
+    executionPolicy: input.acceptedExecution.targetSessionExecution
       ? {
-          executionPolicy: input.acceptedExecution.targetSessionExecution
-            ? {
-                tools: input.acceptedExecution.targetSessionExecution.tools,
-                firstPartyMcpTools:
-                  input.acceptedExecution.targetSessionExecution.firstPartyMcpTools,
-                firstPartyMcpPermissions:
-                  input.acceptedExecution.targetSessionExecution.firstPartyMcpPermissions,
-                variableSetIds: input.acceptedExecution.targetSessionExecution.variableSets.map(
-                  (variableSet) => variableSet.id,
-                ),
-                variableSetId: input.acceptedExecution.targetSessionExecution.variableSetId,
-                rigId: input.acceptedExecution.targetSessionExecution.rigId,
-                rigVersionId: input.acceptedExecution.targetSessionExecution.rigVersionId,
-                toolPolicy: input.acceptedExecution.targetSessionExecution.toolPolicy,
-                mcpServerIds: input.acceptedExecution.targetSessionExecution.mcpServerIds,
-                toolPolicyVersion: input.acceptedExecution.targetSessionExecution.toolPolicyVersion,
-              }
-            : {
-                tools: input.acceptedExecution.resolvedTools,
-                firstPartyMcpTools: input.acceptedExecution.resolvedFirstPartyMcpTools,
-                firstPartyMcpPermissions: input.acceptedExecution.resolvedFirstPartyMcpPermissions,
-                variableSetId: input.acceptedExecution.resolvedVariableSet?.id ?? null,
-                rigId: input.acceptedExecution.resolvedRig?.id ?? null,
-                rigVersionId: input.acceptedExecution.resolvedRig?.versionId ?? null,
-                toolPolicy: session.toolPolicy,
-                mcpServerIds: [],
-                toolPolicyVersion: session.toolPolicyVersion,
-              },
+          tools: input.acceptedExecution.targetSessionExecution.tools,
+          firstPartyMcpTools: input.acceptedExecution.targetSessionExecution.firstPartyMcpTools,
+          firstPartyMcpPermissions:
+            input.acceptedExecution.targetSessionExecution.firstPartyMcpPermissions,
+          variableSetIds: input.acceptedExecution.targetSessionExecution.variableSets.map(
+            (variableSet) => variableSet.id,
+          ),
+          variableSetId: input.acceptedExecution.targetSessionExecution.variableSetId,
+          rigId: input.acceptedExecution.targetSessionExecution.rigId,
+          rigVersionId: input.acceptedExecution.targetSessionExecution.rigVersionId,
+          toolPolicy: input.acceptedExecution.targetSessionExecution.toolPolicy,
+          mcpServerIds: input.acceptedExecution.targetSessionExecution.mcpServerIds,
+          toolPolicyVersion: input.acceptedExecution.targetSessionExecution.toolPolicyVersion,
         }
-      : {}),
+      : {
+          tools: input.acceptedExecution.resolvedTools,
+          firstPartyMcpTools: input.acceptedExecution.resolvedFirstPartyMcpTools,
+          firstPartyMcpPermissions: input.acceptedExecution.resolvedFirstPartyMcpPermissions,
+          variableSetId: input.acceptedExecution.resolvedVariableSet?.id ?? null,
+          rigId: input.acceptedExecution.resolvedRig?.id ?? null,
+          rigVersionId: input.acceptedExecution.resolvedRig?.versionId ?? null,
+          toolPolicy: session.toolPolicy,
+          mcpServerIds: [],
+          toolPolicyVersion: session.toolPolicyVersion,
+        },
   });
   const preflight = evaluateIncidentTelemetryPreflight({
     agentConfig: task.agentConfig,
@@ -2356,6 +2380,7 @@ async function recoverBoundScheduledTaskDispatch(input: {
           : {}),
       },
       personalConnectionDelegations: input.acceptedExecution.personalConnectionDelegations,
+      mcpAccountBindings: input.acceptedExecution.mcpAccountBindings ?? null,
       xaiProviderAccountAuthoritySnapshot:
         input.acceptedExecution.xaiProviderAccountAuthoritySnapshot,
       scheduledTaskRunId: input.run.id,

package/src/activities/session-state.ts

@@ -3,6 +3,7 @@ import {
   applySessionTurnSettlement,
   enqueueSessionWorkflowWake,
   failSessionWorkBeforeAttemptClaim,
+  blockSessionWorkBeforeAttemptClaim,
   requestSessionTurnRecovery,
   recoverSessionDispatch,
   reconcileSessionAttemptQuiescence,
@@ -19,6 +20,8 @@ import {
   settleSessionIdleWithParentOutbox,
 } from "@opengeni/db";
 import { publishDurableSessionEvents } from "@opengeni/events";
+import { CancelledFailure } from "@temporalio/activity";
+import { currentActivityContext } from "./streaming";
 import { deliverFailedChildTurnToParent, notifyParentOfChildIdle } from "./parent-wake";
 import { recordTurnsQueuedGauge, recordWorkerDeathRecoveryMetrics } from "../observability-metrics";
 import {
@@ -52,6 +55,7 @@ export type SessionStateActivityOverrides = Partial<{
   applySessionTurnSettlement: typeof applySessionTurnSettlement;
   enqueueSessionWorkflowWake: typeof enqueueSessionWorkflowWake;
   failSessionWorkBeforeAttemptClaim: typeof failSessionWorkBeforeAttemptClaim;
+  blockSessionWorkBeforeAttemptClaim: typeof blockSessionWorkBeforeAttemptClaim;
   requestSessionTurnRecovery: typeof requestSessionTurnRecovery;
   recoverSessionDispatch: typeof recoverSessionDispatch;
   reconcileSessionAttemptQuiescence: typeof reconcileSessionAttemptQuiescence;
@@ -91,6 +95,8 @@ export function createSessionStateActivities(
     overrides.enqueueSessionWorkflowWake ?? enqueueSessionWorkflowWake;
   const failSessionWorkBeforeAttemptClaimFn =
     overrides.failSessionWorkBeforeAttemptClaim ?? failSessionWorkBeforeAttemptClaim;
+  const blockSessionWorkBeforeAttemptClaimFn =
+    overrides.blockSessionWorkBeforeAttemptClaim ?? blockSessionWorkBeforeAttemptClaim;
   const requestSessionTurnRecoveryFn =
     overrides.requestSessionTurnRecovery ?? requestSessionTurnRecovery;
   const recoverSessionDispatchFn = overrides.recoverSessionDispatch ?? recoverSessionDispatch;
@@ -153,6 +159,28 @@ export function createSessionStateActivities(
 
       const preClaimFailureDisposition =
         input.preClaimFailure?.disposition ?? input.preClaimFailureDisposition;
+      if (
+        preClaimFailureDisposition === "blocked" &&
+        input.admissionFence &&
+        input.preClaimFailure?.reason
+      ) {
+        const blocked = await blockSessionWorkBeforeAttemptClaimFn(db, input.workspaceId, {
+          accountId: input.accountId,
+          sessionId: input.sessionId,
+          workflowId,
+          attemptId: input.attemptId,
+          fence: input.admissionFence,
+          reason: input.preClaimFailure.reason,
+          sqlState: input.preClaimFailure.sqlState ?? null,
+        });
+        await publishDurableSessionEventsFn(
+          bus,
+          input.workspaceId,
+          input.sessionId,
+          blocked.events,
+        );
+        return { action: blocked.action };
+      }
       if (preClaimFailureDisposition === "permanent" && input.trigger) {
         const failed = await failSessionWorkBeforeAttemptClaimFn(db, input.workspaceId, {
           accountId: input.accountId,
@@ -160,7 +188,14 @@ export function createSessionStateActivities(
           workflowId,
           trigger: input.trigger,
           error: input.error ?? "Agent turn admission failed before attempt claim.",
-          ...(input.preClaimFailure ? { admissionFailure: input.preClaimFailure } : {}),
+          ...(input.preClaimFailure?.disposition === "permanent"
+            ? {
+                admissionFailure: {
+                  disposition: "permanent" as const,
+                  code: input.preClaimFailure.code,
+                },
+              }
+            : {}),
         });
         if (failed.action === "terminal") return { action: "terminal" };
         if (failed.action === "stale") return { action: "stale" };
@@ -488,8 +523,53 @@ export function createSessionStateActivities(
   }
 
   async function peekSessionWork(input: PeekSessionWorkInput) {
-    const { db, observability } = await services();
-    const peek = await peekSessionWorkFn(db, input.workspaceId, input.sessionId);
+    const { db, observability, inspectSessionAttemptActivity } = await services();
+    const peek = await peekSessionWorkFn(
+      db,
+      input.workspaceId,
+      input.sessionId,
+      input.includeAdmissionFence,
+      input.observerAccountId,
+    );
+    if (peek.kind === "unavailable") return peek;
+    if (peek.kind === "attempt-owned") {
+      // Observation never revokes a writer or recovers a live owner. In
+      // particular, a settled Temporal activity is not physical-writer proof.
+      let ownerActivityState: "pending" | "settled" | "unknown" = "unknown";
+      if (inspectSessionAttemptActivity) {
+        try {
+          ownerActivityState = await inspectSessionAttemptActivity(peek.activityRef);
+        } catch (error) {
+          if (error instanceof CancelledFailure) throw error;
+          if (currentActivityContext()?.cancellationSignal.aborted)
+            throw new CancelledFailure("Control observation cancelled");
+          // This optional metadata observation grants no recovery authority.
+          // An unavailable inspector must not pin the control activity in
+          // retries and prevent a fresh Pause/owner/visibility observation.
+          // Database reads below remain outside this catch and retry normally.
+        }
+      }
+      if (currentActivityContext()?.cancellationSignal.aborted)
+        throw new CancelledFailure("Control observation cancelled");
+      const current = await peekSessionWorkFn(
+        db,
+        input.workspaceId,
+        input.sessionId,
+        input.includeAdmissionFence,
+        input.observerAccountId,
+      );
+      if (
+        current.kind !== "attempt-owned" ||
+        current.turnId !== peek.turnId ||
+        current.attemptId !== peek.attemptId ||
+        current.executionGeneration !== peek.executionGeneration ||
+        current.activityRef.workflowId !== peek.activityRef.workflowId ||
+        current.activityRef.workflowRunId !== peek.activityRef.workflowRunId ||
+        current.activityRef.activityId !== peek.activityRef.activityId
+      )
+        return current;
+      return { ...current, ownerActivityState };
+    }
     await refreshQueuedTurnsGauge(db, observability, countQueuedTurnsFn, recordTurnsQueuedGaugeFn);
     return peek;
   }

package/src/activities/types.ts

@@ -7,7 +7,11 @@ import type {
   ScheduledTaskTriggerType,
   TurnInitiator,
 } from "@opengeni/contracts";
-import type { Database, SessionWorkflowWakeDeliveryResult } from "@opengeni/db";
+import type {
+  Database,
+  SessionWorkflowWakeDeliveryResult,
+  SessionAdmissionFence,
+} from "@opengeni/db";
 import type { DocumentServices } from "@opengeni/documents";
 import type { EventBus } from "@opengeni/events";
 import type { Observability } from "@opengeni/observability";
@@ -252,6 +256,7 @@ export type FailSessionAttemptInput = {
    * committed claim discovered by the control lane can recover the exact
    * attempt instead of terminally failing it. */
   preClaimFailure?: PreClaimFailureDetail;
+  admissionFence?: SessionAdmissionFence;
   /** Added in v4. A claimed attempt that lost operational database access
    * before turn-start completion carries its exact immutable turn identity so
    * the DB-only control lane can recover it instead of terminally failing it. */
@@ -263,17 +268,24 @@ export type FailSessionAttemptInput = {
 };
 
 export type FailSessionAttemptResult =
+  | { action: "blocked" }
   | { action: "failed" }
   | { action: "recovering" }
   | { action: "unclaimed" }
   | { action: "terminal" }
   | { action: "stale" };
 
-export type PreClaimFailureDisposition = "retryable" | "permanent";
+export type PreClaimFailureDisposition = "retryable" | "permanent" | "blocked";
 
 export type PreClaimFailureDetail = {
   disposition: PreClaimFailureDisposition;
   code: "db_deadlock" | "db_serialization_failure" | "db_failure" | "claim_invariant";
+  sqlState?: string | null;
+  reason?:
+    | "database_claim_rejected"
+    | "initiator_membership_required"
+    | "personal_resource_grant_required";
+  retryPolicy?: "explicit_recheck";
 };
 
 export const PRE_CLAIM_FAILURE_TYPE = "OpenGeniPreClaimFailure";
@@ -344,6 +356,9 @@ export type RecoverEscapedMcpTimeoutResult = {
 export type PeekSessionWorkInput = {
   workspaceId: string;
   sessionId: string;
+  includeAdmissionFence?: boolean;
+  /** Versioned workflow observer opt-in, never a caller authorization grant. */
+  observerAccountId?: string;
 };
 
 export type SettleSessionInputWaitInput = {
@@ -434,6 +449,7 @@ export type DispatchScheduledTaskRunResult =
         | "scheduled_authority_exhausted"
         | "scheduled_run_terminal"
         | "scheduled_execution_unrepresentable"
+        | "connection_account_unavailable"
         | "knowledge_source_paused"
         | "legacy_source_schedule_requires_migration"
         | "incident_preflight_metadata_missing"

package/src/activities/workflow-wake.ts

@@ -6,6 +6,7 @@ import {
   type Database,
 } from "@opengeni/db";
 import { publishDurableWorkspaceControlEvent } from "@opengeni/events";
+import { recordWorkflowWakeReconciliation } from "@opengeni/observability";
 import type { ControlActivityServices } from "./types";
 import {
   reconcileAutomaticSessionTitleFanout,
@@ -115,23 +116,7 @@ export function createWorkflowWakeActivities(services: () => Promise<ControlActi
         pendingAdmissionBlockers,
         exhaustedBatchLimit,
       };
-      if (claimed > 0) {
-        service.observability.info("session workflow wake delivery reconciled", {
-          claimed,
-          signaled,
-          delivered,
-          pendingAdmission,
-          unconfirmed,
-          failed,
-          exhaustedBatchLimit,
-          ...Object.fromEntries(
-            Object.entries(pendingAdmissionBlockers).map(([blocker, count]) => [
-              `pendingAdmissionBlockers.${blocker}`,
-              count,
-            ]),
-          ),
-        });
-      }
+      recordWorkflowWakeReconciliation(service.observability, result);
       return result;
     },
   };

package/src/editable-artifact-materializer-service.ts

@@ -1,4 +1,8 @@
-import { dbSearchPath, getSettings, type Settings } from "@opengeni/config";
+import {
+  dbSearchPath,
+  getArtifactMaterializerSettings,
+  type ArtifactMaterializerSettings,
+} from "@opengeni/config";
 import {
   createDb,
   dbSql,
@@ -77,7 +81,7 @@ export type CreateEditableArtifactMaterializerServiceInput = Readonly<{
 }>;
 
 export type ProductionEditableArtifactMaterializerServiceOptions = Readonly<{
-  settings: Settings;
+  settings: ArtifactMaterializerSettings;
   /** Dedicated DSN; never defaults to settings.databaseUrl. */
   databaseUrl: string;
   declaredDatabaseRole: string;
@@ -671,7 +675,7 @@ export async function createMaterializerSidecarFromEnvironment(
 }> | null> {
   const sidecar = readEditableArtifactMaterializerSidecarEnvironment(environment);
   if (!sidecar) return null;
-  const settings = getSettings();
+  const settings = getArtifactMaterializerSettings(environment);
   const service = await createProductionEditableArtifactMaterializerService({
     settings,
     databaseUrl: sidecar.databaseUrl,

package/src/editable-artifact-outbox-service.ts

@@ -1,8 +1,8 @@
 import {
   dbSearchPath,
-  getSettings,
+  getArtifactOutboxSettings,
   resolveNatsControlPlaneAuth,
-  type Settings,
+  type ArtifactOutboxSettings,
 } from "@opengeni/config";
 import type { EditableArtifactOutboxDispatchSummary } from "@opengeni/core";
 import { createObservability, type Observability } from "@opengeni/observability";
@@ -51,7 +51,7 @@ export type CreateEditableArtifactOutboxServiceInput = Readonly<{
 }>;
 
 export type ProductionEditableArtifactOutboxServiceOptions = Readonly<{
-  settings: Settings;
+  settings: ArtifactOutboxSettings;
   databaseUrl: string;
   declaredDatabaseRole: string;
   natsUrl: string;
@@ -360,7 +360,7 @@ export async function createOutboxSidecarFromEnvironment(
 ): Promise<Readonly<{ service: EditableArtifactOutboxService; httpPort: number }> | null> {
   const sidecar = readEditableArtifactOutboxSidecarEnvironment(environment);
   if (!sidecar) return null;
-  const settings = getSettings();
+  const settings = getArtifactOutboxSettings(environment);
   const controlPlaneAuth = resolveNatsControlPlaneAuth(settings);
   const natsAuth: EditableArtifactHintNatsAuth = controlPlaneAuth
     ? {

package/src/github-rest-mcp.ts

@@ -519,7 +519,6 @@ function exactPersonalDelegation(
     delegation.providerDomain !== "github.com" ||
     delegation.kind !== "oauth2" ||
     !delegation.originWorkspaceId ||
-    !delegation.userDelegation ||
     !delegation.personalGitHubRepositorySelection
   ) {
     throw new GitHubRestAuthorityError("Personal GitHub delegation is unavailable");

package/src/index.ts

@@ -9,6 +9,7 @@ import {
 } from "@opengeni/config";
 import {
   assertRuntimeDatabasePosture,
+  isRetryableRuntimeDatabaseStartupError,
   countSessionRecoveryBacklog,
   createDb,
   getContextCompactionPendingSummary,
@@ -1162,7 +1163,7 @@ export async function startWorker() {
     await retryStartupDependency(
       "PostgreSQL runtime posture",
       () => assertRuntimeDatabasePosture(dbClient.db, databasePosture),
-      { ...retryOptions, onRetry },
+      { ...retryOptions, onRetry, shouldRetry: isRetryableRuntimeDatabaseStartupError },
     );
     bus = await retryStartupDependency(
       "NATS",