@opengeni/core 2.5.3 → 2.6.3-canary.0

package/src/domain/personal-connection-delegations.ts

@@ -384,6 +384,7 @@ export function personalConnectionDelegationsFromVisibleConnections(input: {
 export function personalConnectionDelegationsFromParent(input: {
   servers: McpServerConfig[];
   parentDelegations: McpPersonalConnectionDelegation[];
+  personalGitHubResources?: ResourceRef[];
   targetSessionId?: string;
   rejectActivatedConnections?: boolean;
 }): McpPersonalConnectionDelegation[] {
@@ -416,19 +417,55 @@ export function personalConnectionDelegationsFromParent(input: {
           childEligible(item) &&
           (item.connectionType === "social" ||
             item.connectionType === "atlassian" ||
+            item.connectionType === "github_personal" ||
             item.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID),
       )
       .map((item) => ({ ...item })),
   ];
+  const requestedGitHub = personalGitHubRepositoryResources(input.personalGitHubResources ?? []);
+  const inherited = projected.flatMap((delegation) => {
+    if (delegation.connectionType !== "github_personal") return [delegation];
+    if (requestedGitHub.length === 0) return [];
+    const snapshot = delegation.personalGitHubRepositorySelection;
+    if (!snapshot) return [];
+    const repositories = requestedGitHub.map((resource) => {
+      const parent = snapshot.repositories.find(
+        (candidate) =>
+          candidate.repositoryId === resource.repositoryId &&
+          candidate.canonicalUrl === resource.uri &&
+          candidate.ref === resource.ref,
+      );
+      if (
+        !parent ||
+        resource.credentialBindingId !== snapshot.credentialBindingId ||
+        (resource.access === "write" && parent.access !== "write")
+      ) {
+        throw new Error("agent-created personal GitHub repository exceeds parent authority");
+      }
+      return { ...parent, access: resource.access };
+    });
+    return [
+      {
+        ...delegation,
+        personalGitHubRepositorySelection: { ...snapshot, repositories },
+      },
+    ];
+  });
+  if (
+    requestedGitHub.length > 0 &&
+    !inherited.some((delegation) => delegation.connectionType === "github_personal")
+  ) {
+    throw new Error("agent-created personal GitHub repository authority is unavailable");
+  }
   if (
     input.rejectActivatedConnections &&
-    projected.some((delegation) => delegation.userDelegation)
+    inherited.some((delegation) => delegation.userDelegation)
   ) {
     throw new Error(
       "scheduled connection authority is not available until task occurrence authority is activated",
     );
   }
-  return projected;
+  return inherited;
 }
 
 /**
@@ -798,11 +835,6 @@ export async function freezePersonalConnectionDelegations(input: {
         "agent-created work inherits connection authority from its exact parent turn",
       );
     }
-    if (personalGitHubResources.length > 0) {
-      throw new Error(
-        "agent-created personal GitHub repository authority is not activated in this delivery phase",
-      );
-    }
     const inherited = personalConnectionDelegationsFromParent({
       servers,
       parentDelegations: await getSessionTurnPersonalConnectionDelegations(
@@ -811,6 +843,7 @@ export async function freezePersonalConnectionDelegations(input: {
         input.source.sessionId,
         input.source.turnId,
       ),
+      personalGitHubResources,
       ...(input.targetSessionId ? { targetSessionId: input.targetSessionId } : {}),
       ...(input.rejectUnselectedActivatedConnections !== undefined
         ? { rejectActivatedConnections: input.rejectUnselectedActivatedConnections }

package/src/domain/remember.ts

@@ -35,6 +35,7 @@ import { createHash } from "node:crypto";
 import {
   createCompanyBrainLearningPolicyRouter,
   derivedGovernedLearningOperationId,
+  dispatchBestEffortGovernedLearningNotification,
 } from "./company-brain-governed-writes";
 import { publishGovernedLearningEventToSlack } from "./governed-learning-slack-publication";
 
@@ -548,16 +549,14 @@ export function createRememberRouter(options: RememberRouterOptions): {
         }
       }
       if (!activation) throw asRememberFailure(lastFailure);
-      try {
-        await notifyActivation({
+      dispatchBestEffortGovernedLearningNotification(() =>
+        notifyActivation({
           db: options.db,
           receipt: activation,
           sessionId: attempt.sessionId,
           attemptId: attempt.attemptId,
-        });
-      } catch {
-        // Notification is best-effort; the durable receipts already exist.
-      }
+        }),
+      );
       return RememberConfirmReceipt.parse({
         status: "activated",
         operationId: request.operationId,

package/src/domain/scheduled-tasks.ts

@@ -22,6 +22,8 @@ import {
   createScheduledTask,
   deleteScheduledTask,
   getConnectionMetadata,
+  getEnrollment,
+  getLiveEnrollmentConnection,
   getKnowledgeSourceForSyncAuthority,
   getNestedAgentDepthDeploymentPolicy,
   getRig,
@@ -29,6 +31,7 @@ import {
   getScheduledTaskIncludingDeletedForUpdate,
   getScheduledTaskPersonalConnectionDelegations,
   getScheduledTaskXaiProviderAccountAuthoritySnapshot,
+  getSandbox,
   getSessionTurnXaiProviderAccountAuthoritySnapshot,
   getSession,
   nestedPostgresSqlState,
@@ -164,6 +167,15 @@ export async function createValidatedScheduledTask(input: {
         rigId: input.payload.rigId,
         agentConfig,
       });
+  if (!knowledgeAction) {
+    await validateScheduledTaskMachineTarget({
+      settings: input.settings,
+      db: input.db,
+      grant: input.grant,
+      runMode: input.payload.runMode,
+      agentConfig,
+    });
+  }
   if (!knowledgeAction && input.payload.variableSetId) {
     await validateVariableSetAttachment(
       { settings: input.settings, db: input.db },
@@ -399,6 +411,81 @@ export async function validateScheduledTaskTarget(input: {
   return session;
 }
 
+export async function validateScheduledTaskMachineTarget(input: {
+  settings: Settings;
+  db: Database;
+  grant: AccessGrant;
+  runMode: ScheduledTask["runMode"];
+  agentConfig: ScheduledTaskAgentConfig;
+  requireOnline?: boolean;
+}): Promise<{
+  sandboxId: string;
+  enrollmentId: string;
+  sandboxOs: Session["sandboxOs"];
+} | null> {
+  const machineTarget = input.agentConfig.machineTarget;
+  if (!machineTarget) {
+    if (
+      input.runMode !== "existing_session" &&
+      (input.agentConfig.sandboxBackend ?? input.settings.sandboxBackend) === "selfhosted"
+    ) {
+      throw new HTTPException(422, {
+        message:
+          "self-hosted scheduled tasks require a Connected Machine; select a machine before saving",
+      });
+    }
+    return null;
+  }
+  if (input.runMode === "existing_session") {
+    throw new HTTPException(422, {
+      message: "machineTarget cannot be used with an existing-session target",
+    });
+  }
+  if (!input.settings.sandboxOwnershipEnabled || !input.settings.sandboxSelfhostedEnabled) {
+    throw new HTTPException(422, {
+      message: "Connected Machines are not enabled for scheduled tasks in this deployment",
+    });
+  }
+  const access = {
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    subjectId: input.grant.subjectId,
+  };
+  const sandbox = await getSandbox(input.db, access, machineTarget.targetSandboxId);
+  if (!sandbox || sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
+    throw new HTTPException(422, {
+      message: "the selected Connected Machine is unavailable",
+    });
+  }
+  if (sandbox.scope === "user") {
+    throw new HTTPException(422, {
+      message:
+        "personal Connected Machines cannot run unattended schedules; select a workspace or organization machine",
+    });
+  }
+  const enrollment = input.requireOnline
+    ? await getLiveEnrollmentConnection(input.db, access, sandbox.enrollmentId)
+    : await getEnrollment(input.db, access, sandbox.enrollmentId);
+  if (!enrollment || enrollment.status !== "active") {
+    throw new HTTPException(422, {
+      message: input.requireOnline
+        ? "the selected Connected Machine is offline"
+        : "the selected Connected Machine is unavailable",
+    });
+  }
+  if (input.requireOnline && !enrollment.workspaceRoot) {
+    throw new HTTPException(422, {
+      message:
+        "the selected Connected Machine has not reported a workspace root; reconnect it with a current agent",
+    });
+  }
+  return {
+    sandboxId: sandbox.id,
+    enrollmentId: sandbox.enrollmentId,
+    sandboxOs: enrollment.os,
+  };
+}
+
 export function scheduledTaskForGrant(task: ScheduledTask, grant: AccessGrant): ScheduledTask {
   if (hasPermission(grant.permissions, "sessions:control") || task.targetSessionId === null) {
     return task;
@@ -793,6 +880,13 @@ export async function validatedScheduledTaskUpdate(input: {
     rigId: input.payload.rigId !== undefined ? input.payload.rigId : input.existing.rigId,
     agentConfig: update.agentConfig ?? input.existing.agentConfig,
   });
+  await validateScheduledTaskMachineTarget({
+    settings: input.settings,
+    db: input.db,
+    grant: input.grant,
+    runMode: nextRunMode,
+    agentConfig: update.agentConfig ?? input.existing.agentConfig,
+  });
   if (
     input.payload.targetSessionId !== undefined ||
     input.existing.runMode === "existing_session" ||

package/src/domain/sessions.ts

@@ -10,6 +10,7 @@ import {
   type Settings,
 } from "@opengeni/config";
 import {
+  AUTOMATIC_SESSION_TITLE_FALLBACK,
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
   DEFAULT_FIRST_PARTY_MCP_TOOLS,
@@ -20,6 +21,7 @@ import {
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
   evaluateWorkspaceModelPolicy,
+  normalizeAutomaticSessionTitle,
   resolveWorkspaceSessionToolDefaults,
   stableJson,
   type AccessGrant,
@@ -126,6 +128,7 @@ import {
   SessionAuthorizationDeniedError,
 } from "../session-authorization";
 import { swapActiveSandbox, type FleetContext } from "../sandbox/fleet";
+import { managedSessionGroupBackend } from "../sandbox/runtime-settings";
 import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
 import { validateSubmittedTimelineAnnotations } from "./timeline-annotations";
 import { requireVariableSetEncryption, validateVariableSetAttachment } from "./environments";
@@ -607,6 +610,44 @@ export type CreateSessionRequestOutcome = CreateSessionOutcome & {
   usageRecording: "recorded" | "failed";
 };
 
+type AgentChildSessionCreatePresentation = {
+  /** Model-authored title candidate from the first-party `session_create` tool.
+   * This is deliberately separate from the public REST request contract. */
+  automaticTitleCandidate?: string | null;
+};
+
+const AGENT_CHILD_AUTOMATIC_TITLE_CONTEXT_KEY = "agentChildAutomaticTitle" as const;
+
+/** @internal Exported for the keyed-create repair regression. */
+export function freezeAgentChildAutomaticTitleInCreatorContext(
+  context: TurnInitiatorContext | undefined,
+  title: string | null | undefined,
+): TurnInitiatorContext | undefined {
+  return title ? { ...(context ?? {}), [AGENT_CHILD_AUTOMATIC_TITLE_CONTEXT_KEY]: title } : context;
+}
+
+/** @internal Keyed repair must use the committed winner, not the retry payload. */
+export function initialAutomaticTitleForSessionStart(
+  session: Pick<Session, "createdByContext">,
+  requestedTitle: string | null | undefined,
+): string | null {
+  const frozenTitle = session.createdByContext[AGENT_CHILD_AUTOMATIC_TITLE_CONTEXT_KEY];
+  return typeof frozenTitle === "string" ? frozenTitle : (requestedTitle ?? null);
+}
+
+function automaticTitleForAgentChildCreate(
+  presentation: AgentChildSessionCreatePresentation,
+  goal: GoalSpec | null | undefined,
+  initialMessage: string | null | undefined,
+): string | null {
+  for (const candidate of [presentation.automaticTitleCandidate, goal?.text, initialMessage]) {
+    if (typeof candidate !== "string") continue;
+    const normalized = normalizeAutomaticSessionTitle(candidate);
+    if (normalized && normalized !== AUTOMATIC_SESSION_TITLE_FALLBACK) return normalized;
+  }
+  return null;
+}
+
 export async function createAndStartSessionWithOutcome(input: {
   requestedSessionId?: string;
   db: Database;
@@ -652,6 +693,9 @@ export async function createAndStartSessionWithOutcome(input: {
   // resolved workspace-scoped by the caller). Null/omitted ⇒ unfiled (inbox).
   channelId?: string | null;
   goal?: GoalSpec | null;
+  /** Trusted sensitive-safe automatic title for an agent-created child. The
+   * atomic initializer commits the row mutation and `session.title_set`. */
+  initialAutomaticTitle?: string | null;
   // Per-session agent persona/system instructions (org-visible metadata, not a
   // secret). Persisted on the session row and composed system-level AFTER the
   // workspace agentInstructions at turn time; never emitted as a timeline event.
@@ -737,6 +781,10 @@ export async function createAndStartSessionWithOutcome(input: {
     reasoningEffort: input.reasoningEffort,
     ...(input.latencyMode !== undefined ? { latencyMode: input.latencyMode } : {}),
   };
+  const frozenCreatedByContext = freezeAgentChildAutomaticTitleInCreatorContext(
+    input.createdByContext,
+    input.initialAutomaticTitle,
+  );
   // Keyed creation is intentionally handled only by the database admission
   // transaction below. Its workspace/key lock replays either the successful
   // session or the committed denial atomically; an application-side lookup
@@ -755,7 +803,7 @@ export async function createAndStartSessionWithOutcome(input: {
       toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
       ...(input.createdBy ? { createdBy: input.createdBy } : {}),
-      ...(input.createdByContext ? { createdByContext: input.createdByContext } : {}),
+      ...(frozenCreatedByContext ? { createdByContext: frozenCreatedByContext } : {}),
       createdByActor: input.createdByActor ?? null,
       model: input.model,
       reasoningEffort: input.reasoningEffort,
@@ -827,7 +875,7 @@ export async function createAndStartSessionWithOutcome(input: {
       toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
       ...(input.createdBy ? { createdBy: input.createdBy } : {}),
-      ...(input.createdByContext ? { createdByContext: input.createdByContext } : {}),
+      ...(frozenCreatedByContext ? { createdByContext: frozenCreatedByContext } : {}),
       createdByActor: input.createdByActor ?? null,
       model: input.model,
       reasoningEffort: input.reasoningEffort,
@@ -905,6 +953,7 @@ async function finishStartSession(
     sandboxBackend: Settings["sandboxBackend"];
     variableSets?: Array<{ id: string; name: string; scope: VariableSet["scope"] }>;
     goal?: GoalSpec | null;
+    initialAutomaticTitle?: string | null;
     sessionMcpServers?: SessionMcpServerMetadata[];
     seedTargetSandbox?: {
       sandboxId: string;
@@ -1009,6 +1058,10 @@ async function finishStartSession(
             : {}),
         }
       : null,
+    initialAutomaticTitle: initialAutomaticTitleForSessionStart(
+      session,
+      input.initialAutomaticTitle,
+    ),
     consumeNewSessionDraft: input.consumeNewSessionDraft ?? null,
     rememberNewSessionSelection: input.rememberNewSessionSelection ?? null,
     deferInitialTurn: input.deferInitialTurn === true,
@@ -1485,6 +1538,7 @@ export async function createSessionForRequestWithOutcome(
   workspaceId: string,
   rawPayload: unknown,
   authorization?: AccessGrantAuthorization,
+  agentChildPresentation?: AgentChildSessionCreatePresentation,
 ): Promise<CreateSessionRequestOutcome> {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
@@ -1612,6 +1666,14 @@ export async function createSessionForRequestWithOutcome(
       });
     }
   }
+  const initialAutomaticTitle =
+    parentSession && agentChildPresentation
+      ? automaticTitleForAgentChildCreate(
+          agentChildPresentation,
+          effectiveGoal,
+          payload.initialMessage,
+        )
+      : null;
   const personalResourceSubjectId = creationInitiator.actor
     ? (await requireLiveAgentAttemptAuthorization(db, grant, creationInitiator.actor.sessionId))
         .initiatingHumanSubjectId
@@ -2038,6 +2100,8 @@ export async function createSessionForRequestWithOutcome(
     payload.sandbox ?? (payload.targetSandboxId ? "new" : parentSessionId ? "shared" : "new");
   let sandboxGroupId: string | null = null;
   let inheritedBackend: Session["sandboxBackend"] | undefined;
+  let inheritedSandboxOs: Session["sandboxOs"] | undefined;
+  let inheritedActiveTarget: { sandboxId: string; workingDir: string | null } | null = null;
   // ENV-AWARE GROUPING: under the CURRENT mechanics the workspace VariableSet is
   // creation-time box state — the box's manifest env is fixed when it is cold-
   // created, and the SDK's provided-session guard rejects any manifest-env delta
@@ -2112,6 +2176,17 @@ export async function createSessionForRequestWithOutcome(
     } else {
       sandboxGroupId = parent.sandboxGroupId;
       inheritedBackend = parent.sandboxBackend;
+      inheritedSandboxOs = parent.sandboxOs;
+      // A Connected Machine route is session-local even when two sessions share
+      // one logical sandbox group. Copy the trusted parent's exact active route
+      // so an omitted child sandbox really does share the creator's current box
+      // instead of creating a selfhosted row with no bound agent.
+      inheritedActiveTarget = parent.activeSandboxId
+        ? {
+            sandboxId: parent.activeSandboxId,
+            workingDir: parent.workingDir,
+          }
+        : null;
     }
   } else if (typeof sandboxChoice === "object") {
     const member = await getAnySessionInGroup(db, workspaceId, sandboxChoice.groupId);
@@ -2160,6 +2235,7 @@ export async function createSessionForRequestWithOutcome(
     }
     sandboxGroupId = sandboxChoice.groupId;
     inheritedBackend = member.sandboxBackend;
+    inheritedSandboxOs = member.sandboxOs;
   }
   // else "new": leave sandboxGroupId null → own singleton group (group ≡ id).
   // A working dir is only meaningful for a TARGETED machine (it is the chosen
@@ -2172,6 +2248,19 @@ export async function createSessionForRequestWithOutcome(
         "workingDir requires targetSandboxId (it is the targeted machine's working directory)",
     });
   }
+  // A registry-built selfhosted client is deliberately inert: it has no live
+  // agent identity until a concrete Connected Machine is named. Reject an own
+  // targetless home before persisting a session whose first turn can only fail.
+  // Shared children retain their already-bound group through inheritedBackend.
+  if (
+    inheritedBackend === undefined &&
+    !payload.targetSandboxId &&
+    (payload.sandboxBackend ?? settings.sandboxBackend) === "selfhosted"
+  ) {
+    throw new HTTPException(422, {
+      message: "selfhosted sessions require targetSandboxId; select an online Connected Machine",
+    });
+  }
   // Honest-label (Stage-D closure): a session TARGETED at a Connected
   // Machine (a selfhosted sandbox) runs machine-primary every turn, so its HOME
   // sandbox_backend must read "selfhosted" — not the deployment cloud default —
@@ -2230,6 +2319,25 @@ export async function createSessionForRequestWithOutcome(
       }
     }
   }
+  const effectiveSandboxBackend =
+    inheritedBackend ?? machineHomeBackend ?? payload.sandboxBackend ?? settings.sandboxBackend;
+  const effectiveSandboxOs = inheritedSandboxOs ?? machineHomeOs;
+  const effectiveSeedTarget = payload.targetSandboxId
+    ? {
+        sandboxId: payload.targetSandboxId,
+        workingDir: payload.workingDir ?? null,
+      }
+    : inheritedActiveTarget;
+  if (
+    effectiveSandboxBackend === "selfhosted" &&
+    effectiveSeedTarget === null &&
+    managedSessionGroupBackend(settings.sandboxBackend, effectiveSandboxBackend) === null
+  ) {
+    throw new HTTPException(422, {
+      message:
+        "self-hosted execution runs on a Connected Machine, but no machine was selected or inherited; connect the parent session to a machine or provide machineTarget",
+    });
+  }
   if (payload.startMode !== "realtime") {
     await requireLimit(deps, {
       accountId: grant.accountId,
@@ -2266,11 +2374,10 @@ export async function createSessionForRequestWithOutcome(
       // machine-targeted create (top-level or own-box child) labels the home
       // "selfhosted" (machineHomeBackend), overriding the caller/deployment
       // default so the row matches where the session actually runs.
-      sandboxBackend:
-        inheritedBackend ?? machineHomeBackend ?? payload.sandboxBackend ?? settings.sandboxBackend,
+      sandboxBackend: effectiveSandboxBackend,
       // Mirror the backend relabel on the OS axis: a machine-targeted own-box
-      // create carries a derived OS; shared spawns keep the parent-box behavior.
-      ...(machineHomeOs ? { sandboxOs: machineHomeOs } : {}),
+      // create carries a derived OS; shared spawns inherit the exact parent box.
+      ...(effectiveSandboxOs ? { sandboxOs: effectiveSandboxOs } : {}),
       sandboxGroupId,
       metadata: payload.metadata,
       ...(creationInitiator.initiator ? { createdBy: creationInitiator.initiator } : {}),
@@ -2286,6 +2393,7 @@ export async function createSessionForRequestWithOutcome(
       rigVersionId: frozenRigVersionId,
       channelId,
       goal: effectiveGoal ?? null,
+      initialAutomaticTitle,
       // Per-session persona instructions (already trimmed/validated by the
       // contracts schema). Persisted on the row; composed system-level at turn
       // time. Not surfaced as an event.
@@ -2307,11 +2415,11 @@ export async function createSessionForRequestWithOutcome(
       // active-sandbox pointer is seeded race-free inside createAndStartSession
       // (after the row exists, before the first turn dispatches). Validation
       // (ownership/liveness) lives in swapActiveSandbox; an invalid target 422s.
-      seedTargetSandbox: payload.targetSandboxId
+      seedTargetSandbox: effectiveSeedTarget
         ? {
-            sandboxId: payload.targetSandboxId,
+            sandboxId: effectiveSeedTarget.sandboxId,
             settings,
-            workingDir: payload.workingDir ?? null,
+            workingDir: effectiveSeedTarget.workingDir,
             resourceSubjectId: personalResourceSubjectId,
           }
         : null,

package/src/domain/workspace-members.ts

@@ -44,7 +44,9 @@ export function assertWorkspaceMemberRemovable(input: {
 }): void {
   const { members, subjectId, callerSubjectId } = input;
   if (subjectId === callerSubjectId) {
-    throw new HTTPException(409, { message: "you cannot remove your own membership" });
+    throw new HTTPException(409, {
+      message: "you cannot remove your own membership",
+    });
   }
   const target = members.find((member) => member.subjectId === subjectId);
   if (!target) {
@@ -62,6 +64,34 @@ export function assertWorkspaceMemberRemovable(input: {
   }
 }
 
+/** Keep scoped member edits from orphaning the workspace or changing the caller's own grant. */
+export function assertWorkspaceMemberUpdateAllowed(input: {
+  members: WorkspaceMember[];
+  subjectId: string;
+  callerSubjectId: string;
+  nextPermissions: Permission[];
+}): void {
+  const { members, subjectId, callerSubjectId, nextPermissions } = input;
+  if (subjectId === callerSubjectId) {
+    throw new HTTPException(409, {
+      message: "you cannot change your own workspace access",
+    });
+  }
+  const target = members.find((member) => member.subjectId === subjectId);
+  if (!target) {
+    throw new HTTPException(404, { message: "member not found" });
+  }
+  if (
+    memberCanAdminister(target) &&
+    !memberCanAdminister({ permissions: nextPermissions }) &&
+    !members.some((member) => member.subjectId !== subjectId && memberCanAdminister(member))
+  ) {
+    throw new HTTPException(409, {
+      message: "the workspace must keep at least one administrator",
+    });
+  }
+}
+
 /**
  * Guard the workspace-delete path before any external/DB mutation. Refuses
  * (409) to delete the account's last workspace, and refuses while any session
@@ -74,7 +104,9 @@ export function assertWorkspaceDeletable(input: {
   activeSessionCount: number;
 }): void {
   if (input.workspaceCountForAccount <= 1) {
-    throw new HTTPException(409, { message: "cannot delete the account's only workspace" });
+    throw new HTTPException(409, {
+      message: "cannot delete the account's only workspace",
+    });
   }
   if (input.activeSessionCount > 0) {
     throw new HTTPException(409, {

package/src/managed-auth-session-sets.ts

@@ -278,25 +278,48 @@ export async function authenticateAndAdoptManagedAuthSession(input: {
     credentials: { email: input.email, password: input.password },
     headers: input.isolatedHeaders,
   });
+  return await adoptManagedAuthSession({
+    ...input,
+    authorityHash: managedAuthSha256(input.authority),
+    transactionSecretHash: managedAuthSha256(input.transactionSecret),
+    authSessionId: created.authSessionId,
+  });
+}
+
+export async function adoptManagedAuthSession(input: {
+  db: Database;
+  adapter: ManagedAuthSessionAdapter;
+  authority: string;
+  authorityHash: string;
+  csrfHash: string;
+  operationId: string;
+  requestDigest: string;
+  expectedGeneration: string;
+  expectedActorEpoch: string;
+  transactionId: string;
+  transactionSecretHash: string;
+  authSessionId: string;
+  mode: ManagedAuthSessionSetMode;
+}): Promise<{ projection: ManagedAuthDatabaseProjection; returnIntent: string | null }> {
   let completed: { projection: ManagedAuthDatabaseProjection; returnIntent: string | null };
   try {
     completed = await completeManagedAuthLoginTransaction(input.db, {
-      authorityHash: managedAuthSha256(input.authority),
+      authorityHash: input.authorityHash,
       csrfHash: input.csrfHash,
       operationId: input.operationId,
       requestDigest: input.requestDigest,
       expectedGeneration: input.expectedGeneration,
       expectedActorEpoch: input.expectedActorEpoch,
       transactionId: input.transactionId,
-      transactionSecretHash: managedAuthSha256(input.transactionSecret),
-      authSessionId: created.authSessionId,
+      transactionSecretHash: input.transactionSecretHash,
+      authSessionId: input.authSessionId,
       mode: input.mode,
     });
   } catch (error) {
     let receipt: Awaited<ReturnType<typeof getManagedAuthSessionSetOperationReceipt>>;
     try {
       receipt = await getManagedAuthSessionSetOperationReceipt(input.db, {
-        authorityHash: managedAuthSha256(input.authority),
+        authorityHash: input.authorityHash,
         operationId: input.operationId,
         requestDigest: input.requestDigest,
       });
@@ -304,14 +327,16 @@ export async function authenticateAndAdoptManagedAuthSession(input: {
       throw new ManagedAuthCompletionOutcomeUnknownError({ cause: receiptError });
     }
     if (receipt) {
-      await reconcileCreatedManagedAuthSession(input, created.authSessionId);
+      await reconcileCreatedManagedAuthSession(input, input.authSessionId);
       return receipt;
     }
-    await input.adapter.revokeSession(created).catch(() => undefined);
+    await input.adapter
+      .revokeSession({ authSessionId: input.authSessionId })
+      .catch(() => undefined);
     throw error;
   }
   try {
-    await reconcileCreatedManagedAuthSession(input, created.authSessionId);
+    await reconcileCreatedManagedAuthSession(input, input.authSessionId);
   } catch (error) {
     throw new ManagedAuthCompletionOutcomeUnknownError({ cause: error });
   }
@@ -319,10 +344,12 @@ export async function authenticateAndAdoptManagedAuthSession(input: {
 }
 
 async function reconcileCreatedManagedAuthSession(
-  input: Pick<
-    Parameters<typeof authenticateAndAdoptManagedAuthSession>[0],
-    "db" | "adapter" | "authority" | "mode"
-  >,
+  input: {
+    db: Database;
+    adapter: ManagedAuthSessionAdapter;
+    authority: string;
+    mode: ManagedAuthSessionSetMode;
+  },
   authSessionId: string,
 ): Promise<void> {
   const snapshot = await getManagedAuthSessionSetSnapshot(input.db, {