@opengeni/db 0.31.1 → 0.36.1

package/src/session-control.ts

@@ -200,7 +200,7 @@ export class SessionCommandIdempotencyError extends Error {
 
 export class AgentCommandAuthorityError extends Error {
   constructor(
-    readonly code: "CALLER_STALE" | "CALLER_INTERRUPTED" | "SELF_OR_ANCESTOR_PAUSE" | "SELF_STEER",
+    readonly code: "CALLER_STALE" | "CALLER_INTERRUPTED" | "TARGET_NOT_VERTICAL" | "SELF_STEER",
     message: string,
   ) {
     super(message);
@@ -232,10 +232,12 @@ export async function assertAgentCommandAuthorityInTransaction(
     attemptIds: [input.actor.attemptId],
   });
   const lockedSessions = authorityLocks.sessions;
-  if (!lockedSessions.some((row) => row.id === input.actor.sessionId)) {
+  const callerSession = lockedSessions.find((row) => row.id === input.actor.sessionId);
+  if (!callerSession) {
     throw new AgentCommandAuthorityError("CALLER_STALE", "The calling session no longer exists");
   }
-  if (!lockedSessions.some((row) => row.id === input.targetSessionId)) {
+  const targetSession = lockedSessions.find((row) => row.id === input.targetSessionId);
+  if (!targetSession) {
     throw new SessionControlInvariantError(`Target session not found: ${input.targetSessionId}`);
   }
   const rows = await db.execute<{
@@ -298,37 +300,21 @@ export async function assertAgentCommandAuthorityInTransaction(
   if (input.action === "steer" && input.targetSessionId === input.actor.sessionId) {
     throw new AgentCommandAuthorityError("SELF_STEER", "An agent cannot steer its own session");
   }
-  if (input.action !== "pause") return;
-  const ancestry = await db.execute<{
-    containsCaller: boolean;
-    invalid: boolean;
-  }>(sql`
-    with recursive caller_ancestry(id, parent_id, depth, path, cycle) as (
-      select session.id, session.parent_session_id, 0, array[session.id], false
-      from ${schema.sessions} session
-      where session.workspace_id = ${input.workspaceId}
-        and session.id = ${input.actor.sessionId}
-      union all
-      select parent.id, parent.parent_session_id, child.depth + 1,
-             child.path || parent.id, parent.id = any(child.path)
-      from caller_ancestry child
-      join ${schema.sessions} parent
-        on parent.workspace_id = ${input.workspaceId} and parent.id = child.parent_id
-      where child.depth < ${SESSION_ANCESTRY_LIMIT} and not child.cycle
-    )
-    select
-      coalesce(bool_or(id = ${input.targetSessionId}), false) as "containsCaller",
-      coalesce(bool_or(cycle), false) or coalesce(max(depth), 0) >= ${SESSION_ANCESTRY_LIMIT}
-        as invalid
-    from caller_ancestry
-  `);
-  if (ancestry[0]?.invalid) {
-    throw new SessionControlInvariantError("Caller ancestry is invalid");
-  }
-  if (ancestry[0]?.containsCaller) {
+  const targetsSelf = targetSession.id === callerSession.id;
+  const targetsDirectParent = callerSession.parentSessionId === targetSession.id;
+  const targetsDirectChild = targetSession.parentSessionId === callerSession.id;
+  const verticalTargetAllowed =
+    input.action === "goal"
+      ? targetsSelf
+      : input.action === "message"
+        ? targetsSelf || targetsDirectParent || targetsDirectChild
+        : targetsDirectChild;
+  if (!verticalTargetAllowed) {
     throw new AgentCommandAuthorityError(
-      "SELF_OR_ANCESTOR_PAUSE",
-      "An agent cannot pause its own session or an ancestor workstream",
+      "TARGET_NOT_VERTICAL",
+      input.action === "message"
+        ? "An agent may message only its own session, direct parent, or direct child"
+        : "An agent may control only a direct child session",
     );
   }
 }
@@ -430,7 +416,7 @@ export type SessionEventWriteLocks = {
  *
  *   workspace_inference_controls (when control-aware)
  *     -> actual workspaces row FOR KEY SHARE
- *     -> session rows FOR UPDATE, UUID ordered
+ *     -> session rows FOR NO KEY UPDATE, UUID ordered
  *     -> exact turn rows FOR UPDATE, UUID ordered
  *     -> exact attempt rows FOR UPDATE, UUID ordered
  *
@@ -439,6 +425,11 @@ export type SessionEventWriteLocks = {
  * `FOR UPDATE` lock serialized unrelated sessions and inverted the activity
  * path's session -> implicit workspace-FK edge.
  *
+ * `FOR NO KEY UPDATE` is equally deliberate for sessions. Session primary and
+ * composite identity keys are immutable, so writers need to exclude only concurrent
+ * non-key mutation. Keeping FK `FOR KEY SHARE` checks compatible prevents the
+ * activity finalizer's workspace counter from participating in a lock cycle.
+ *
  * Complex lifecycle transactions may acquire allocator/control locks before
  * this helper and may discover exact turn IDs only after locking the session.
  * They use the explicit `already_locked` stages, while retaining the same
@@ -478,7 +469,7 @@ export async function lockSessionEventWriteRows(
             ),
           )
           .orderBy(schema.sessions.id)
-          .for("update")
+          .for("no key update")
       : [];
 
   const turnIds = [...new Set(input.turnIds ?? [])].sort();
@@ -529,14 +520,24 @@ export async function registerSessionTurnAttemptClaim(
     temporalWorkflowRunId: string;
     temporalActivityId: string;
     verifiedControlRevision: number;
+    authorityEpoch: number;
+    authorityVisibility: "user_private" | "workspace_shared";
+    authorityOwnerOrganizationMembershipId: string | null;
     mcpApprovalPolicies: Record<string, SessionMcpApprovalPolicy>;
     connectorActionPolicies: schema.ConnectorActionPolicySnapshotEntry[];
   },
 ): Promise<typeof schema.sessionTurnAttempts.$inferSelect> {
+  const authoritySnapshot = assertSessionAuthoritySnapshot({
+    attemptId: input.id,
+    authorityEpoch: input.authorityEpoch,
+    authorityVisibility: input.authorityVisibility,
+    authorityOwnerOrganizationMembershipId: input.authorityOwnerOrganizationMembershipId,
+  });
   const [inserted] = await db
     .insert(schema.sessionTurnAttempts)
     .values({
       ...input,
+      ...authoritySnapshot,
       state: "claimed",
     })
     // Only an idempotent replay of this exact preallocated attempt ID may
@@ -557,12 +558,22 @@ export async function registerSessionTurnAttemptClaim(
     )
     .for("update")
     .limit(1);
+  const existingAuthoritySnapshot = existing
+    ? assertSessionAuthoritySnapshot({
+        attemptId: existing.id,
+        authorityEpoch: existing.authorityEpoch,
+        authorityVisibility: existing.authorityVisibility,
+        authorityOwnerOrganizationMembershipId: existing.authorityOwnerOrganizationMembershipId,
+      })
+    : null;
   if (
     !existing ||
     existing.accountId !== input.accountId ||
     existing.sessionId !== input.sessionId ||
     existing.turnId !== input.turnId ||
     existing.executionGeneration !== input.executionGeneration ||
+    !existingAuthoritySnapshot ||
+    !sessionAuthoritySnapshotsEqual(existingAuthoritySnapshot, authoritySnapshot) ||
     existing.temporalWorkflowId !== input.temporalWorkflowId ||
     existing.temporalWorkflowRunId !== input.temporalWorkflowRunId ||
     existing.temporalActivityId !== input.temporalActivityId ||
@@ -577,6 +588,80 @@ export async function registerSessionTurnAttemptClaim(
   return existing;
 }
 
+export type SessionAuthoritySnapshot = {
+  authorityEpoch: number;
+  authorityVisibility: "user_private" | "workspace_shared";
+  authorityOwnerOrganizationMembershipId: string | null;
+};
+
+/**
+ * Validate the complete accepted-attempt authority tuple. Missing or partial
+ * values are not legacy defaults: current claim writers must provide the
+ * exact locked session authority explicitly.
+ */
+export function assertSessionAuthoritySnapshot(input: {
+  attemptId?: string;
+  authorityEpoch: unknown;
+  authorityVisibility: unknown;
+  authorityOwnerOrganizationMembershipId: unknown;
+}): SessionAuthoritySnapshot {
+  const valid =
+    Number.isSafeInteger(input.authorityEpoch) &&
+    (input.authorityEpoch as number) > 0 &&
+    (input.authorityVisibility === "user_private" ||
+      input.authorityVisibility === "workspace_shared") &&
+    ((input.authorityVisibility === "user_private" &&
+      typeof input.authorityOwnerOrganizationMembershipId === "string") ||
+      (input.authorityVisibility === "workspace_shared" &&
+        (input.authorityOwnerOrganizationMembershipId === null ||
+          typeof input.authorityOwnerOrganizationMembershipId === "string")));
+  if (!valid) {
+    throw new SessionControlInvariantError(
+      `Attempt ${input.attemptId ?? "unknown"} has an invalid session authority snapshot`,
+    );
+  }
+  return {
+    authorityEpoch: input.authorityEpoch as number,
+    authorityVisibility:
+      input.authorityVisibility as SessionAuthoritySnapshot["authorityVisibility"],
+    authorityOwnerOrganizationMembershipId: input.authorityOwnerOrganizationMembershipId as
+      | string
+      | null,
+  };
+}
+
+export function sessionAuthoritySnapshotMatchesSession(
+  snapshot: SessionAuthoritySnapshot,
+  session: Pick<
+    typeof schema.sessions.$inferSelect,
+    "authorityEpoch" | "visibility" | "ownerOrganizationMembershipId"
+  >,
+): boolean {
+  return (
+    snapshot.authorityEpoch === session.authorityEpoch &&
+    snapshot.authorityVisibility === session.visibility &&
+    snapshot.authorityOwnerOrganizationMembershipId ===
+      (session.ownerOrganizationMembershipId ?? null)
+  );
+}
+
+export function sessionAuthoritySnapshotsEqual(
+  left: Pick<
+    SessionAuthoritySnapshot,
+    "authorityEpoch" | "authorityVisibility" | "authorityOwnerOrganizationMembershipId"
+  >,
+  right: Pick<
+    SessionAuthoritySnapshot,
+    "authorityEpoch" | "authorityVisibility" | "authorityOwnerOrganizationMembershipId"
+  >,
+): boolean {
+  return (
+    left.authorityEpoch === right.authorityEpoch &&
+    left.authorityVisibility === right.authorityVisibility &&
+    left.authorityOwnerOrganizationMembershipId === right.authorityOwnerOrganizationMembershipId
+  );
+}
+
 /**
  * Close the exact first-class owner while the caller still holds the owning
  * session/turn locks. Every path that clears `session_turns.active_attempt_id`
@@ -1415,12 +1500,12 @@ export async function reserveSessionCommandReceipt(
   if (
     identityScope === "goal_operation" &&
     (input.actor.type !== "agent_attempt" ||
-      input.action !== "goal.update" ||
+      !["goal.update", "goal.progress"].includes(input.action) ||
       input.targetSessionId === null ||
       input.targetTurnId !== null)
   ) {
     throw new SessionControlInvariantError(
-      "Target-scoped receipt identity is reserved for agent goal.update commands",
+      "Target-scoped receipt identity is reserved for agent goal commands",
     );
   }
   const actorSubjectId = input.actor.type === "agent_attempt" ? null : input.actor.subjectId;

package/src/session-queue-commands.ts

@@ -1,4 +1,6 @@
 import {
+  WORKSPACE_XAI_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1,
+  XaiProviderAccountAuthoritySnapshotV1,
   DraftTimelineAnnotations,
   McpPersonalConnectionDelegations,
   TimelineAnnotations,
@@ -32,6 +34,7 @@ import {
   withLosslessContentWriteVersion,
 } from "./lossless-json";
 import { closePendingSessionToolCallsInTransaction } from "./session-tool-call-settlement";
+import { cancelTurnInteractionInterventionsInTransaction } from "./browser-auth";
 import {
   assertAgentCommandAuthorityInTransaction,
   autoResumeSessionBranchInTransaction,
@@ -61,6 +64,7 @@ import {
   initiatorFromStorage,
   type FrozenTurnInitiator,
 } from "./turn-initiator";
+import { resolveXaiProviderAccountAuthoritySnapshotForAcceptanceInTransaction } from "./xai-subscription";
 
 type SessionEventInsertWithPayload = typeof schema.sessionEvents.$inferInsert & {
   payload: unknown;
@@ -233,6 +237,43 @@ async function personalConnectionDelegationsForAgentActor(
   return parsed.data.map((delegation) => ({ ...delegation }));
 }
 
+async function xaiAuthorityForAgentActor(
+  db: Database,
+  workspaceId: string,
+  actor: Extract<SessionCommandActor, { type: "agent_attempt" }>,
+): Promise<{
+  snapshot: ReturnType<typeof XaiProviderAccountAuthoritySnapshotV1.parse>;
+  subjectId: string | null;
+}> {
+  const [row] = await db
+    .select({
+      snapshot: schema.sessionTurns.xaiProviderAccountAuthoritySnapshot,
+      initiatingHumanSubjectId: schema.sessionTurns.initiatingHumanSubjectId,
+      initiatorKind: schema.sessionTurns.initiatorKind,
+      initiatorSubjectId: schema.sessionTurns.initiatorSubjectId,
+    })
+    .from(schema.sessionTurns)
+    .where(
+      and(
+        eq(schema.sessionTurns.workspaceId, workspaceId),
+        eq(schema.sessionTurns.sessionId, actor.sessionId),
+        eq(schema.sessionTurns.id, actor.turnId),
+      ),
+    )
+    .limit(1);
+  if (!row) {
+    throw new SessionControlInvariantError(
+      `Agent xAI authority turn not found: ${actor.sessionId}/${actor.turnId}`,
+    );
+  }
+  return {
+    snapshot: XaiProviderAccountAuthoritySnapshotV1.parse(row.snapshot),
+    subjectId:
+      row.initiatingHumanSubjectId ??
+      (row.initiatorKind === "subject" ? row.initiatorSubjectId : null),
+  };
+}
+
 async function lockSession(
   db: Database,
   workspaceId: string,
@@ -344,6 +385,12 @@ export async function supersedeSessionCurrentDirectionInTransaction(
   }
 
   const now = new Date();
+  await cancelTurnInteractionInterventionsInTransaction(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    turnId: current.id,
+  });
   const closedTools = await closePendingSessionToolCallsInTransaction(db, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -392,7 +439,10 @@ export async function supersedeSessionCurrentDirectionInTransaction(
             turnId: current.id,
             turnGeneration: current.executionGeneration,
             turnAssociation: "current",
-            payload: { requestId: request.id, response: { outcome: "cancelled" } },
+            payload: {
+              requestId: request.id,
+              response: { outcome: "cancelled" },
+            },
             occurredAt: now,
           })),
           "payload",
@@ -454,6 +504,17 @@ export async function supersedeSessionCurrentDirectionInTransaction(
           eq(schema.codexCapacityWaiters.status, "waiting"),
         ),
       );
+    await db
+      .update(schema.xaiCapacityWaiters)
+      .set({ status: "superseded", lastWakeReason: "steer", updatedAt: now })
+      .where(
+        and(
+          eq(schema.xaiCapacityWaiters.workspaceId, input.workspaceId),
+          eq(schema.xaiCapacityWaiters.sessionId, input.sessionId),
+          eq(schema.xaiCapacityWaiters.blockedTurnId, current.id),
+          eq(schema.xaiCapacityWaiters.status, "waiting"),
+        ),
+      );
   }
   return {
     interruptionCount: 0,
@@ -1652,6 +1713,15 @@ export async function submitHumanPromptInTransaction(
       input.subjectLabel,
     );
   }
+  const xaiProviderAccountAuthoritySnapshot = editedSourceTurn
+    ? XaiProviderAccountAuthoritySnapshotV1.parse(
+        editedSourceTurn.xaiProviderAccountAuthoritySnapshot,
+      )
+    : input.actor.type === "human"
+      ? await resolveXaiProviderAccountAuthoritySnapshotForAcceptanceInTransaction(db, {
+          workspaceId: input.workspaceId,
+        })
+      : WORKSPACE_XAI_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1;
   const acceptedEventId = crypto.randomUUID();
   const turnId = crypto.randomUUID();
   const workflowId = session.temporalWorkflowId ?? `session-${session.id}`;
@@ -1730,6 +1800,7 @@ export async function submitHumanPromptInTransaction(
           personalConnectionDelegations: editedSourceTurn
             ? editedSourceTurn.personalConnectionDelegations
             : (input.personalConnectionDelegations ?? []),
+          xaiProviderAccountAuthoritySnapshot,
           createdAt: now,
           updatedAt: now,
         },
@@ -2083,6 +2154,7 @@ export async function sendAgentMessageInTransaction(
     input.workspaceId,
     input.actor,
   );
+  const xaiAuthority = await xaiAuthorityForAgentActor(db, input.workspaceId, input.actor);
   const session = await lockSession(db, input.workspaceId, input.targetSessionId);
   if (session.status === "cancelled") {
     throw new QueueCommandConflictError(
@@ -2124,8 +2196,10 @@ export async function sendAgentMessageInTransaction(
               callerTurnId: input.actor.turnId,
               callerAttemptId: input.actor.attemptId,
               callerExecutionGeneration: input.actor.executionGeneration,
+              ...(xaiAuthority.subjectId ? { xaiAuthoritySubjectId: xaiAuthority.subjectId } : {}),
             },
             personalConnectionDelegations,
+            xaiProviderAccountAuthoritySnapshot: xaiAuthority.snapshot,
             state: "pending",
           },
           "summary",
@@ -2290,6 +2364,7 @@ export async function steerAgentSessionInTransaction(
     input.workspaceId,
     input.actor,
   );
+  const xaiAuthority = await xaiAuthorityForAgentActor(db, input.workspaceId, input.actor);
   const resumed = await autoResumeSessionBranchInTransaction(db, {
     workspaceId: input.workspaceId,
     sessionId: input.targetSessionId,
@@ -2351,8 +2426,10 @@ export async function steerAgentSessionInTransaction(
               callerTurnId: input.actor.turnId,
               callerAttemptId: input.actor.attemptId,
               callerExecutionGeneration: input.actor.executionGeneration,
+              ...(xaiAuthority.subjectId ? { xaiAuthoritySubjectId: xaiAuthority.subjectId } : {}),
             },
             personalConnectionDelegations,
+            xaiProviderAccountAuthoritySnapshot: xaiAuthority.snapshot,
             state: "pending",
           },
           "summary",

package/src/session-tenancy.ts

@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+import { sql } from "drizzle-orm";
+import {
+  rawRows,
+  type Database,
+  rlsContextForWorkspace,
+  withWorkspaceSubjectRls,
+  withWorkspaceSubjectSessionActivityRls,
+} from "./database";
+
+export type SessionTenancyVisibility = "user_private" | "workspace_shared";
+
+export type TransitionSessionVisibilityInput = {
+  workspaceId: string;
+  sessionId: string;
+  actorSubjectId: string;
+  targetVisibility: SessionTenancyVisibility;
+  expectedAuthorityEpoch: number;
+  operationKey: string;
+};
+
+export type TransitionSessionVisibilityResult = {
+  operationId: string;
+  visibility: SessionTenancyVisibility;
+  authorityEpoch: number;
+  ownerOrganizationMembershipId: string | null;
+  changed: boolean;
+  replay: boolean;
+  interruptedAttemptCount: number;
+  cancelledTurnCount: number;
+  cancelledUpdateCount: number;
+  pausedGoalCount: number;
+  revokedGrantCount: number;
+};
+
+export type ForkSessionContentInput = {
+  sourceWorkspaceId: string;
+  sourceSessionId: string;
+  actorSubjectId: string;
+  destinationWorkspaceId: string;
+  destinationVisibility: SessionTenancyVisibility;
+  operationKey: string;
+};
+
+export type ForkSessionContentResult = {
+  operationId: string;
+  sessionId: string;
+  workspaceId: string;
+  visibility: SessionTenancyVisibility;
+  authorityEpoch: number;
+  copiedHistoryItemCount: number;
+  replay: boolean;
+};
+
+export function canonicalSessionVisibilityTransitionHash(
+  input: Pick<
+    TransitionSessionVisibilityInput,
+    "sessionId" | "targetVisibility" | "expectedAuthorityEpoch"
+  >,
+): string {
+  return createHash("sha256")
+    .update(
+      JSON.stringify({
+        version: 1,
+        sessionId: input.sessionId,
+        targetVisibility: input.targetVisibility,
+        expectedAuthorityEpoch: input.expectedAuthorityEpoch,
+      }),
+    )
+    .digest("hex");
+}
+
+export function canonicalSessionForkHash(
+  input: Pick<
+    ForkSessionContentInput,
+    "sourceSessionId" | "destinationWorkspaceId" | "destinationVisibility"
+  >,
+): string {
+  return createHash("sha256")
+    .update(
+      JSON.stringify({
+        version: 1,
+        sourceSessionId: input.sourceSessionId,
+        destinationWorkspaceId: input.destinationWorkspaceId,
+        destinationVisibility: input.destinationVisibility,
+      }),
+    )
+    .digest("hex");
+}
+
+export async function transitionSessionVisibility(
+  db: Database,
+  input: TransitionSessionVisibilityInput,
+): Promise<TransitionSessionVisibilityResult> {
+  if (!Number.isSafeInteger(input.expectedAuthorityEpoch) || input.expectedAuthorityEpoch < 1) {
+    throw new Error("expectedAuthorityEpoch must be a positive safe integer");
+  }
+  if (!input.operationKey.trim()) throw new Error("operationKey must not be empty");
+  const requestHash = canonicalSessionVisibilityTransitionHash(input);
+  const { accountId } = await rlsContextForWorkspace(db, input.workspaceId);
+  return await withWorkspaceSubjectSessionActivityRls(
+    db,
+    input.workspaceId,
+    input.actorSubjectId,
+    async (scopedDb) => {
+      const rows = await rawRows<{
+        operationId: string;
+        visibility: SessionTenancyVisibility;
+        authorityEpoch: number;
+        ownerOrganizationMembershipId: string | null;
+        changed: boolean;
+        replay: boolean;
+        interruptedAttemptCount: number;
+        cancelledTurnCount: number;
+        cancelledUpdateCount: number;
+        pausedGoalCount: number;
+        revokedGrantCount: number;
+      }>(
+        scopedDb,
+        sql`select
+          operation_id as "operationId",
+          visibility,
+          authority_epoch as "authorityEpoch",
+          owner_organization_membership_id as "ownerOrganizationMembershipId",
+          changed,
+          replay,
+          interrupted_attempt_count as "interruptedAttemptCount",
+          cancelled_turn_count as "cancelledTurnCount",
+          cancelled_update_count as "cancelledUpdateCount",
+          paused_goal_count as "pausedGoalCount",
+          revoked_grant_count as "revokedGrantCount"
+        from transition_session_visibility(
+          ${accountId}::uuid,
+          ${input.workspaceId}::uuid,
+          ${input.sessionId}::uuid,
+          ${input.actorSubjectId},
+          ${input.targetVisibility},
+          ${input.expectedAuthorityEpoch},
+          ${input.operationKey},
+          ${requestHash}
+        )`,
+      );
+      const result = rows[0];
+      if (!result) throw new Error("Session visibility transition returned no result");
+      return result;
+    },
+  );
+}
+
+export async function forkSessionContent(
+  db: Database,
+  input: ForkSessionContentInput,
+): Promise<ForkSessionContentResult> {
+  if (!input.operationKey.trim()) throw new Error("operationKey must not be empty");
+  const { accountId } = await rlsContextForWorkspace(db, input.sourceWorkspaceId);
+  const requestHash = canonicalSessionForkHash(input);
+  return await withWorkspaceSubjectRls(
+    db,
+    input.sourceWorkspaceId,
+    input.actorSubjectId,
+    async (scopedDb) => {
+      const rows = await rawRows<ForkSessionContentResult>(
+        scopedDb,
+        sql`select
+          operation_id as "operationId",
+          session_id as "sessionId",
+          workspace_id as "workspaceId",
+          visibility,
+          authority_epoch as "authorityEpoch",
+          copied_history_item_count as "copiedHistoryItemCount",
+          replay
+        from fork_session_content(
+          ${accountId}::uuid,
+          ${input.sourceWorkspaceId}::uuid,
+          ${input.sourceSessionId}::uuid,
+          ${input.actorSubjectId},
+          ${input.destinationWorkspaceId}::uuid,
+          ${input.destinationVisibility},
+          ${input.operationKey},
+          ${requestHash}
+        )`,
+      );
+      const result = rows[0];
+      if (!result) throw new Error("Session fork returned no result");
+      return result;
+    },
+  );
+}

package/src/session-tool-call-settlement.ts

@@ -135,6 +135,10 @@ export async function closePendingSessionToolCallsInTransaction(
       row.resultItem === null
         ? null
         : fromPostgresLosslessJson(row.resultItem, row.resultItemCodecVersion),
+    eventOutput:
+      row.eventOutput === null
+        ? null
+        : fromPostgresLosslessJson(row.eventOutput, row.eventOutputCodecVersion),
   }));
   if (pending.length === 0) return { sequence: input.sequence, events: [], closed: 0 };
 
@@ -306,9 +310,11 @@ export async function closePendingSessionToolCallsInTransaction(
                 },
               ],
             }
-          : ((resolution.existingResult?.item ?? resolution.call.resultItem)?.output ??
-            resolution.existingResult?.item ??
-            resolution.call.resultItem),
+          : resolution.call.eventOutput !== null
+            ? resolution.call.eventOutput.value
+            : ((resolution.existingResult?.item ?? resolution.call.resultItem)?.output ??
+              resolution.existingResult?.item ??
+              resolution.call.resultItem),
         recovery: {
           interrupted: resolution.interrupted,
           outcome: resolution.interrupted ? "unknown" : "durable_result_found",