@opengeni/db 4.0.0-canary.0 → 4.0.0-canary.2

package/dist/chunk-DUB3LUVM.js

@@ -0,0 +1,4145 @@
+import {
+  cancelUnacceptedVideoGenerationsForToolCallsInTransaction
+} from "./chunk-CQF6G4IF.js";
+import {
+  nestedPostgresSqlState,
+  withRlsContext,
+  withSessionActivityRlsContext
+} from "./chunk-XIYAXH47.js";
+import {
+  LOSSLESS_CONTENT_CODEC_VERSION,
+  auditEvents,
+  codexCapacityWaiters,
+  fromPostgresLosslessJson,
+  sandboxRetainedProcesses,
+  sessionAttemptInterruptions,
+  sessionBackgroundCommands,
+  sessionCommandReceipts,
+  sessionEventCursors,
+  sessionEvents,
+  sessionHistoryItems,
+  sessionHumanInputRequests,
+  sessionPendingToolCalls,
+  sessionRealtimeEntries,
+  sessionRealtimeModes,
+  sessionSystemUpdateOutbox,
+  sessionSystemUpdates,
+  sessionTurnAttempts,
+  sessionTurns,
+  sessionWorkflowWakeOutbox,
+  sessions,
+  withLosslessContentWriteVersion,
+  workspaceControlEvents,
+  workspaceInferenceControls,
+  workspaces
+} from "./chunk-PWJJKCTF.js";
+
+// src/session-background-commands.ts
+import { SessionCommandFailure } from "@opengeni/contracts";
+import { isDeepStrictEqual } from "util";
+import { and as and4, asc as asc2, desc as desc2, eq as eq4, gte, inArray as inArray3, sql as sql4 } from "drizzle-orm";
+
+// src/session-control.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  boundWorkspaceControlEvent,
+  childPausedClassification,
+  McpPersonalConnectionDelegations,
+  workspaceControlUtf8Bytes
+} from "@opengeni/contracts";
+import { and as and3, eq as eq3, inArray as inArray2, sql as sql3 } from "drizzle-orm";
+
+// src/child-lifecycle-notices.ts
+import {
+  CHILD_PAUSED_REASON_MAX_BYTES,
+  CHILD_PROGRESS_NOTE_MAX_BYTES,
+  CHILD_REQUIRES_ACTION_MAX_REQUESTS,
+  CHILD_REQUIRES_ACTION_PAYLOAD_MAX_BYTES,
+  CHILD_REQUIRES_ACTION_QUESTION_PREVIEW_MAX_BYTES,
+  approvalIdentifier
+} from "@opengeni/contracts";
+var childLifecycleNoticesEnabledFlag = false;
+function configureChildLifecycleNotices(input) {
+  childLifecycleNoticesEnabledFlag = input.enabled === true;
+}
+function childLifecycleNoticesEnabled() {
+  return childLifecycleNoticesEnabledFlag;
+}
+function boundedChildNoticeText(value, maxBytes) {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(value);
+  if (bytes.byteLength <= maxBytes) return { text: value, truncated: false };
+  const marker = "\u2026";
+  const budget = Math.max(0, maxBytes - encoder.encode(marker).byteLength);
+  let end = Math.min(budget, bytes.byteLength);
+  while (end > 0 && end < bytes.byteLength && (bytes[end] & 192) === 128) end -= 1;
+  return { text: `${new TextDecoder().decode(bytes.subarray(0, end))}${marker}`, truncated: true };
+}
+var CHILD_LIFECYCLE_DEDUPE_PREFIX = {
+  requiresAction: "child-requires-action",
+  requiresActionResolved: "child-requires-action-resolved",
+  paused: "child-paused",
+  waitingCapacity: "child-waiting-capacity",
+  progress: "child-progress"
+};
+function childRequiresActionDedupeKey(input) {
+  return `${CHILD_LIFECYCLE_DEDUPE_PREFIX.requiresAction}:${input.childSessionId}:${input.turnId}:${input.turnGeneration}`;
+}
+function childRequiresActionResolvedDedupeKey(input) {
+  return `${CHILD_LIFECYCLE_DEDUPE_PREFIX.requiresActionResolved}:${input.childSessionId}:${input.turnId}:${input.turnGeneration}:${input.requestId ?? input.approvalId ?? "unknown"}`;
+}
+function childPausedDedupeKey(input) {
+  return `${CHILD_LIFECYCLE_DEDUPE_PREFIX.paused}:${input.childSessionId}:${input.receiptId}`;
+}
+function childWaitingCapacityDedupeKey(input) {
+  return `${CHILD_LIFECYCLE_DEDUPE_PREFIX.waitingCapacity}:${input.childSessionId}:${input.waiterId}`;
+}
+function childProgressDedupeKey(input) {
+  return `${CHILD_LIFECYCLE_DEDUPE_PREFIX.progress}:${input.childSessionId}:${input.receiptId}`;
+}
+function approvalToolName(value) {
+  if (!value || typeof value !== "object") return null;
+  const approval = value;
+  const rawItem = approval.rawItem && typeof approval.rawItem === "object" ? approval.rawItem : null;
+  const candidate = rawItem?.name ?? approval.name;
+  return typeof candidate === "string" && candidate.length > 0 ? boundedChildNoticeText(candidate, 128).text : null;
+}
+function buildChildRequiresActionPayload(input) {
+  const requests = [];
+  for (const request of input.humanInputRequests) {
+    const first = request.questions[0];
+    requests.push({
+      kind: "human_input",
+      requestId: request.id,
+      questionCount: request.questions.length,
+      firstQuestion: boundedChildNoticeText(
+        typeof first?.prompt === "string" ? first.prompt : "",
+        CHILD_REQUIRES_ACTION_QUESTION_PREVIEW_MAX_BYTES
+      ).text,
+      allowSkip: request.allowSkip,
+      expiresAt: request.expiresAt ? request.expiresAt.toISOString() : null
+    });
+  }
+  const seenApprovals = /* @__PURE__ */ new Set();
+  for (const pending of input.pendingApprovals) {
+    const approvalId = approvalIdentifier(pending);
+    if (!approvalId || seenApprovals.has(approvalId)) continue;
+    seenApprovals.add(approvalId);
+    requests.push({
+      kind: "approval",
+      approvalId: boundedChildNoticeText(approvalId, 256).text,
+      toolName: approvalToolName(pending)
+    });
+  }
+  let truncated = requests.length > CHILD_REQUIRES_ACTION_MAX_REQUESTS;
+  let bounded = requests.slice(0, CHILD_REQUIRES_ACTION_MAX_REQUESTS);
+  const build = () => ({
+    type: "child_requires_action",
+    childSessionId: input.childSessionId,
+    childTurnId: input.childTurnId,
+    childTurnGeneration: input.childTurnGeneration,
+    requests: bounded,
+    truncated
+  });
+  let payload = build();
+  while (bounded.length > 0 && Buffer.byteLength(JSON.stringify(payload)) > CHILD_REQUIRES_ACTION_PAYLOAD_MAX_BYTES) {
+    bounded = bounded.slice(0, -1);
+    truncated = true;
+    payload = build();
+  }
+  return payload;
+}
+function childRequiresActionSummary(childSessionId, payload) {
+  const humanInputs = payload.requests.filter((request) => request.kind === "human_input");
+  const approvals = payload.requests.filter((request) => request.kind === "approval");
+  const first = humanInputs[0];
+  const lines = [
+    `Worker ${childSessionId} is blocked and needs input (turn ${payload.childTurnId}).`
+  ];
+  if (first && first.kind === "human_input") {
+    lines.push(
+      `It asked: ${first.firstQuestion}${first.questionCount > 1 ? ` (+${first.questionCount - 1} more question${first.questionCount > 2 ? "s" : ""})` : ""}${humanInputs.length > 1 ? ` [${humanInputs.length} open requests]` : ""}.`
+    );
+  }
+  if (approvals.length > 0) {
+    const names = approvals.map((request) => request.kind === "approval" ? request.toolName : null).filter((name) => name !== null);
+    lines.push(
+      `${approvals.length} tool approval${approvals.length > 1 ? "s are" : " is"} waiting for a human${names.length > 0 ? ` (${names.join(", ")})` : ""}.`
+    );
+  }
+  if (payload.truncated) lines.push("The request list was truncated.");
+  return lines.join(" ");
+}
+function childRequiresActionResolvedSummary(childSessionId, payload) {
+  const subject = payload.requestId ? "input request" : "approval";
+  return `Worker ${childSessionId}: its ${subject} was ${payload.outcome} (by ${payload.respondedByKind.replace("_", " ")}); the worker is no longer blocked on it.`;
+}
+function childPausedSummary(childSessionId, payload) {
+  const base = `Worker ${childSessionId} was paused by ${payload.actorKind === "agent" ? "an agent" : payload.actorKind === "api" ? "the API" : "a human"}.`;
+  return payload.reason ? `${base} Reason: ${payload.reason}` : base;
+}
+function childWaitingCapacitySummary(childSessionId, payload) {
+  return `Worker ${childSessionId} is waiting for ${payload.provider === "codex" ? "Codex" : "xAI"} provider capacity${payload.nextCheckAt ? ` (next check ${payload.nextCheckAt})` : ""}; its turn resumes automatically.`;
+}
+function childProgressSummary(childSessionId, payload) {
+  return `Worker ${childSessionId} progress: ${payload.progressNote}`;
+}
+function boundedChildPausedReason(reason) {
+  if (reason === null || reason === void 0 || reason.length === 0) return null;
+  return boundedChildNoticeText(reason, CHILD_PAUSED_REASON_MAX_BYTES).text;
+}
+function boundedChildProgressNote(note) {
+  return boundedChildNoticeText(note, CHILD_PROGRESS_NOTE_MAX_BYTES).text;
+}
+
+// src/session-tool-call-settlement.ts
+import { canonicalizePersistedHistoryItem, omitOutputOnlyHistoryItemFields } from "@opengeni/codex";
+import { and, asc, eq, inArray, sql } from "drizzle-orm";
+var TOOL_RESULT_TYPE_BY_CALL_TYPE = {
+  function_call: "function_call_result",
+  computer_call: "computer_call_result",
+  shell_call: "shell_call_output",
+  apply_patch_call: "apply_patch_call_output",
+  tool_search_call: "tool_search_output"
+};
+function historyCallId(item) {
+  const providerData = item.providerData && typeof item.providerData === "object" && !Array.isArray(item.providerData) ? item.providerData : null;
+  const value = [
+    item.callId,
+    item.call_id,
+    providerData?.callId,
+    providerData?.call_id,
+    item.id
+  ].find((candidate) => typeof candidate === "string" && candidate.length > 0);
+  return value ?? null;
+}
+function historyItemType(item) {
+  return typeof item.type === "string" ? item.type : null;
+}
+function interruptedToolCallResult(input) {
+  const message = `Tool execution was interrupted by ${input.reason} before its result was durably recorded. The side-effect outcome is unknown; inspect actual state before repeating the call.`;
+  if (input.callType === "function_call") {
+    const name = typeof input.callItem.name === "string" ? input.callItem.name : "tool";
+    return {
+      type: "function_call_result",
+      name,
+      ...typeof input.callItem.namespace === "string" ? { namespace: input.callItem.namespace } : {},
+      callId: input.callId,
+      status: "incomplete",
+      output: { type: "text", text: message }
+    };
+  }
+  if (input.callType === "shell_call") {
+    return {
+      type: "shell_call_output",
+      callId: input.callId,
+      output: [{ stdout: "", stderr: message, outcome: { type: "exit", exitCode: null } }]
+    };
+  }
+  if (input.callType === "apply_patch_call") {
+    return {
+      type: "apply_patch_call_output",
+      callId: input.callId,
+      status: "failed",
+      output: message
+    };
+  }
+  if (input.callType === "computer_call") return null;
+  if (input.callType === "tool_search_call") {
+    const providerData = input.callItem.providerData && typeof input.callItem.providerData === "object" && !Array.isArray(input.callItem.providerData) ? input.callItem.providerData : null;
+    const execution = input.callItem.execution === "client" || input.callItem.execution === "server" ? input.callItem.execution : providerData?.execution === "client" || providerData?.execution === "server" ? providerData.execution : null;
+    const providerIdentity = typeof providerData?.call_id === "string" || typeof providerData?.callId === "string";
+    const snakeId = typeof input.callItem.call_id === "string";
+    return {
+      type: "tool_search_output",
+      ...providerIdentity ? {
+        providerData: {
+          call_id: input.callId,
+          ...execution ? { execution } : {}
+        }
+      } : snakeId ? { call_id: input.callId, ...execution ? { execution } : {} } : { callId: input.callId, ...execution ? { execution } : {} },
+      status: "incomplete",
+      tools: []
+    };
+  }
+  return null;
+}
+function mapEvent(row) {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    sessionId: row.sessionId,
+    sequence: row.sequence,
+    type: row.type,
+    payload: fromPostgresLosslessJson(row.payload, row.payloadCodecVersion),
+    occurredAt: row.occurredAt.toISOString(),
+    clientEventId: row.clientEventId,
+    turnId: row.turnId,
+    turnGeneration: row.turnGeneration,
+    turnAttemptId: row.turnAttemptId,
+    turnAssociation: row.turnAssociation,
+    duplicateOfEventId: row.duplicateOfEventId,
+    duplicateReason: row.duplicateReason
+  };
+}
+async function closePendingSessionToolCallsInTransaction(tx, input) {
+  const pendingRows = await tx.select().from(sessionPendingToolCalls).where(
+    and(
+      eq(sessionPendingToolCalls.workspaceId, input.workspaceId),
+      eq(sessionPendingToolCalls.sessionId, input.sessionId),
+      eq(sessionPendingToolCalls.turnId, input.turnId)
+    )
+  ).orderBy(asc(sessionPendingToolCalls.createdAt), asc(sessionPendingToolCalls.id)).for("update");
+  const pending = pendingRows.filter((row) => !(input.preserveInterruptionRows && row.interruptionKind !== null)).map((row) => ({
+    ...row,
+    callItem: fromPostgresLosslessJson(row.callItem, row.callItemCodecVersion),
+    resultItem: 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 };
+  const history = await tx.select({
+    position: sessionHistoryItems.position,
+    item: sessionHistoryItems.item,
+    itemCodecVersion: sessionHistoryItems.itemCodecVersion,
+    active: sessionHistoryItems.active
+  }).from(sessionHistoryItems).where(
+    and(
+      eq(sessionHistoryItems.workspaceId, input.workspaceId),
+      eq(sessionHistoryItems.sessionId, input.sessionId),
+      eq(sessionHistoryItems.turnId, input.turnId)
+    )
+  ).orderBy(asc(sessionHistoryItems.position));
+  const decodedHistory = history.map((row) => ({
+    ...row,
+    item: fromPostgresLosslessJson(row.item, row.itemCodecVersion)
+  }));
+  const [{ maxPosition } = { maxPosition: -1 }] = await tx.select({ maxPosition: sql`coalesce(max(${sessionHistoryItems.position}), -1)` }).from(sessionHistoryItems).where(
+    and(
+      eq(sessionHistoryItems.workspaceId, input.workspaceId),
+      eq(sessionHistoryItems.sessionId, input.sessionId)
+    )
+  );
+  const existingOutputEvents = await tx.select({ callId: sql`${sessionEvents.payload} ->> 'id'` }).from(sessionEvents).where(
+    and(
+      eq(sessionEvents.workspaceId, input.workspaceId),
+      eq(sessionEvents.sessionId, input.sessionId),
+      eq(sessionEvents.turnId, input.turnId),
+      eq(sessionEvents.type, "agent.toolCall.output")
+    )
+  );
+  const projectedCallIds = new Set(
+    existingOutputEvents.flatMap(({ callId }) => callId ? [callId] : [])
+  );
+  let nextPosition = Math.floor(Number(maxPosition)) + 1;
+  let sequence = input.sequence;
+  const historyValues = [];
+  const eventValues = [];
+  const resolutions = pending.map((call) => {
+    const resultType = TOOL_RESULT_TYPE_BY_CALL_TYPE[call.callType];
+    const existingCall = decodedHistory.find(
+      ({ item }) => historyItemType(item) === call.callType && historyCallId(item) === call.callId
+    );
+    const existingResult = resultType ? decodedHistory.find(
+      ({ item, position }) => position > (existingCall?.position ?? Number.MAX_SAFE_INTEGER) && historyItemType(item) === resultType && historyCallId(item) === call.callId
+    ) : void 0;
+    const activeCall = decodedHistory.find(
+      ({ item, active }) => active && historyItemType(item) === call.callType && historyCallId(item) === call.callId
+    );
+    const activeResult = resultType ? decodedHistory.find(
+      ({ item, active, position }) => active && position > (activeCall?.position ?? Number.MAX_SAFE_INTEGER) && historyItemType(item) === resultType && historyCallId(item) === call.callId
+    ) : void 0;
+    const interruptedResult = interruptedToolCallResult({
+      callType: call.callType,
+      callId: call.callId,
+      callItem: call.callItem,
+      reason: input.reason
+    });
+    return {
+      call,
+      existingCall,
+      existingResult,
+      activeCall,
+      activeResult,
+      completeDurablePair: Boolean(existingCall && existingResult),
+      supersededDurablePair: Boolean(
+        existingCall && existingResult && (!existingCall.active || !existingResult.active)
+      ),
+      rawCallIsValid: historyItemType(call.callItem) === call.callType,
+      result: existingResult?.item ?? call.resultItem ?? interruptedResult,
+      interrupted: !existingResult && !call.resultItem
+    };
+  });
+  for (const resolution of resolutions) {
+    if (!resolution.completeDurablePair && !resolution.activeCall && resolution.result && resolution.rawCallIsValid) {
+      historyValues.push({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        position: nextPosition++,
+        item: omitOutputOnlyHistoryItemFields(resolution.call.callItem),
+        itemCodecVersion: LOSSLESS_CONTENT_CODEC_VERSION,
+        active: true
+      });
+    }
+  }
+  const orderedResults = [...resolutions].sort(
+    (left, right) => (left.call.resultRecordedAt?.getTime() ?? Number.MAX_SAFE_INTEGER) - (right.call.resultRecordedAt?.getTime() ?? Number.MAX_SAFE_INTEGER)
+  );
+  for (const resolution of orderedResults) {
+    if (!resolution.completeDurablePair && !resolution.activeResult && resolution.result && resolution.rawCallIsValid) {
+      historyValues.push({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        position: nextPosition++,
+        item: canonicalizePersistedHistoryItem(
+          resolution.result,
+          resolution.call.modelToolOutputTruncationTokens ?? void 0
+        ),
+        itemCodecVersion: LOSSLESS_CONTENT_CODEC_VERSION,
+        active: true
+      });
+    }
+    if (resolution.supersededDurablePair || projectedCallIds.has(resolution.call.callId)) continue;
+    eventValues.push({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      sequence: ++sequence,
+      type: "agent.toolCall.output",
+      turnId: input.turnId,
+      turnGeneration: resolution.call.executionGeneration,
+      turnAttemptId: resolution.call.attemptId,
+      turnAssociation: input.turnAssociation === void 0 ? "current" : input.turnAssociation,
+      payload: {
+        id: resolution.call.callId,
+        output: resolution.interrupted ? {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Tool execution was interrupted by ${input.reason}; its side-effect outcome is unknown.`
+            }
+          ]
+        } : 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",
+          reason: input.reason,
+          unsupportedCallShape: resolution.interrupted && (!resolution.result || !resolution.rawCallIsValid)
+        }
+      },
+      payloadCodecVersion: LOSSLESS_CONTENT_CODEC_VERSION,
+      occurredAt: input.now
+    });
+  }
+  if (historyValues.length > 0) await tx.insert(sessionHistoryItems).values(historyValues);
+  const inserted = eventValues.length > 0 ? await tx.insert(sessionEvents).values(eventValues).returning() : [];
+  await cancelUnacceptedVideoGenerationsForToolCallsInTransaction(tx, {
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    turnId: input.turnId,
+    toolCallIds: pending.map((call) => call.callId),
+    reason: input.reason,
+    now: input.now
+  });
+  await tx.delete(sessionPendingToolCalls).where(
+    and(
+      eq(sessionPendingToolCalls.workspaceId, input.workspaceId),
+      eq(sessionPendingToolCalls.sessionId, input.sessionId),
+      eq(sessionPendingToolCalls.turnId, input.turnId),
+      inArray(
+        sessionPendingToolCalls.id,
+        pending.map((call) => call.id)
+      )
+    )
+  );
+  return { sequence, events: inserted.map(mapEvent), closed: pending.length };
+}
+
+// src/session-realtime-mirror.ts
+import { createHash } from "crypto";
+import { and as and2, desc, eq as eq2, gt, sql as sql2 } from "drizzle-orm";
+var SESSION_REALTIME_MIRROR_MAX_TEXT_BYTES = 131072;
+var SESSION_REALTIME_MIRROR_MAX_PAYLOAD_BYTES = 131072;
+var TRUNCATION_MARKER = "\n\u2026realtime context truncated\u2026";
+function deterministicUuid(seed) {
+  const bytes = createHash("sha256").update(seed, "utf8").digest().subarray(0, 16);
+  bytes[6] = (bytes[6] ?? 0) & 15 | 80;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function takeUtf8Head(value, maximumBytes) {
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maximumBytes) return value;
+  let end = maximumBytes;
+  while (end > 0 && (bytes[end] & 192) === 128) end -= 1;
+  return bytes.subarray(0, end).toString("utf8");
+}
+function boundedText(value) {
+  if (Buffer.byteLength(value, "utf8") <= SESSION_REALTIME_MIRROR_MAX_TEXT_BYTES) return value;
+  const markerBytes = Buffer.byteLength(TRUNCATION_MARKER, "utf8");
+  return `${takeUtf8Head(value, SESSION_REALTIME_MIRROR_MAX_TEXT_BYTES - markerBytes)}${TRUNCATION_MARKER}`;
+}
+function boundedPayload(value) {
+  const payload = value;
+  if (Buffer.byteLength(JSON.stringify(payload), "utf8") > SESSION_REALTIME_MIRROR_MAX_PAYLOAD_BYTES) {
+    throw new Error("Realtime mirror payload exceeds the durable ledger limit");
+  }
+  return payload;
+}
+async function mirrorSessionRealtimeContextInTransaction(db, input) {
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const modes = await db.select().from(sessionRealtimeModes).where(
+    and2(
+      eq2(sessionRealtimeModes.accountId, input.accountId),
+      eq2(sessionRealtimeModes.workspaceId, input.workspaceId),
+      eq2(sessionRealtimeModes.sessionId, input.sessionId),
+      eq2(sessionRealtimeModes.state, "active"),
+      gt(sessionRealtimeModes.leaseExpiresAt, now)
+    )
+  ).orderBy(desc(sessionRealtimeModes.startedAt)).for("update").limit(2);
+  if (modes.length === 0) return null;
+  if (modes.length !== 1) {
+    throw new Error(`Session ${input.sessionId} has multiple active realtime modes`);
+  }
+  const mode = modes[0];
+  const operationId = deterministicUuid(
+    `opengeni:session-realtime-mirror:${mode.id}:${input.sourceKind}:${input.sourceId}`
+  );
+  const [existing] = await db.select().from(sessionRealtimeEntries).where(
+    and2(
+      eq2(sessionRealtimeEntries.realtimeId, mode.id),
+      eq2(sessionRealtimeEntries.operationId, operationId)
+    )
+  ).limit(1);
+  if (existing) return { entry: existing, replay: true };
+  const [sequenceRow] = await db.select({ next: sql2`coalesce(max(${sessionRealtimeEntries.sequence}), 0) + 1` }).from(sessionRealtimeEntries).where(eq2(sessionRealtimeEntries.realtimeId, mode.id));
+  const payload = boundedPayload({
+    ...input.payload ?? {},
+    source: input.sourceKind,
+    sourceId: input.sourceId,
+    channel: input.channel,
+    ...input.turnId ? { sourceTurnId: input.turnId } : {}
+  });
+  const [entry] = await db.insert(sessionRealtimeEntries).values({
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    realtimeId: mode.id,
+    operationId,
+    connectionEpoch: mode.connectionEpoch,
+    sequence: Number(sequenceRow?.next ?? 1),
+    direction: "provider_out",
+    kind: "session_update",
+    text: boundedText(input.text),
+    textCodecVersion: LOSSLESS_CONTENT_CODEC_VERSION,
+    payload,
+    payloadCodecVersion: LOSSLESS_CONTENT_CODEC_VERSION,
+    createdAt: now,
+    updatedAt: now
+  }).returning();
+  if (!entry) throw new Error("Failed to append realtime session context");
+  return { entry, replay: false };
+}
+function renderRealtimeHumanInputContext(input) {
+  return [
+    "<session_user_message>",
+    `  <status>${input.routing}</status>`,
+    `  <delivery>${input.delivery}</delivery>`,
+    `  <text>${escapeXmlText(input.text)}</text>`,
+    "  <instruction>Already routed by OpenGeni; do not delegate this message again.</instruction>",
+    "</session_user_message>"
+  ].join("\n");
+}
+function renderRealtimeHumanInputRequestContext(input) {
+  const lines = ["<session_human_input_request>", "  <status>waiting_for_user</status>"];
+  for (const request of input.requests) {
+    lines.push(
+      "  <request>",
+      `    <id>${escapeXmlText(request.id)}</id>`,
+      `    <allow_skip>${String(request.allowSkip)}</allow_skip>`,
+      `    <expires_at>${escapeXmlText(renderExpiry(request.expiresAt))}</expires_at>`
+    );
+    for (const question of request.questions) {
+      lines.push(
+        "    <question>",
+        `      <id>${escapeXmlText(question.id)}</id>`,
+        `      <kind>${escapeXmlText(question.kind)}</kind>`,
+        `      <required>${String(question.required)}</required>`
+      );
+      if (question.label) lines.push(`      <label>${escapeXmlText(question.label)}</label>`);
+      lines.push(`      <prompt>${escapeXmlText(question.prompt)}</prompt>`);
+      if (question.helpText) {
+        lines.push(`      <help_text>${escapeXmlText(question.helpText)}</help_text>`);
+      }
+      if (question.options.length > 0) {
+        lines.push("      <options>");
+        for (const option of question.options) {
+          lines.push(
+            "        <option>",
+            `          <id>${escapeXmlText(option.id)}</id>`,
+            `          <label>${escapeXmlText(option.label)}</label>`
+          );
+          if (option.description) {
+            lines.push(`          <description>${escapeXmlText(option.description)}</description>`);
+          }
+          lines.push("        </option>");
+        }
+        lines.push("      </options>");
+      }
+      lines.push(
+        `      <allow_other>${String(question.kind !== "text")}</allow_other>`,
+        "    </question>"
+      );
+    }
+    lines.push("  </request>");
+  }
+  lines.push(
+    "  <instruction>The current work is waiting for the user's input. Ask the questions naturally, one at a time when useful, without changing their meaning or answering for the user. The user may answer in the visible form or answer conversationally here. If the user answers here, delegate exactly once with a complete message containing the relevant question and the user's answer. If the user changes direction instead, delegate that new direction normally. Do not claim the work resumed until a later session update confirms it.</instruction>",
+    "</session_human_input_request>"
+  );
+  return lines.join("\n");
+}
+function renderRealtimeHumanInputResponseContext(input) {
+  const lines = [
+    "<session_human_input_response>",
+    `  <request_id>${escapeXmlText(input.requestId)}</request_id>`,
+    `  <outcome>${escapeXmlText(input.response.outcome)}</outcome>`
+  ];
+  if (input.response.outcome === "answered") {
+    const questions = new Map(input.questions.map((question) => [question.id, question]));
+    lines.push("  <answers>");
+    for (const answer of input.response.answers) {
+      const question = questions.get(answer.questionId);
+      const optionLabels = new Map(
+        question?.options.map((option) => [option.id, option.label]) ?? []
+      );
+      lines.push(
+        "    <answer>",
+        `      <question_id>${escapeXmlText(answer.questionId)}</question_id>`
+      );
+      if (question) lines.push(`      <question>${escapeXmlText(question.prompt)}</question>`);
+      for (const value of answer.values) {
+        lines.push(`      <value>${escapeXmlText(optionLabels.get(value) ?? value)}</value>`);
+      }
+      if (answer.other) lines.push(`      <other>${escapeXmlText(answer.other)}</other>`);
+      lines.push("    </answer>");
+    }
+    lines.push("  </answers>");
+  }
+  lines.push(
+    input.response.outcome === "answered" || input.response.outcome === "skipped" ? "  <instruction>This structured response was accepted through the session UI and the same work can resume. Treat it as authoritative user context, do not delegate it again, and acknowledge briefly only if useful.</instruction>" : "  <instruction>This pending question is no longer active. Do not ask it again unless the user raises it.</instruction>",
+    "</session_human_input_response>"
+  );
+  return lines.join("\n");
+}
+function renderExpiry(value) {
+  if (value === null || value === void 0) return "none";
+  return value instanceof Date ? value.toISOString() : value;
+}
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+// src/session-control.ts
+var SESSION_ANCESTRY_LIMIT = 1e4;
+var NO_SETTLEMENT_ATTEMPTS = {
+  attemptCount: 0,
+  interruptionPendingCount: 0,
+  quiescencePendingCount: 0
+};
+var SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS = 200;
+var SESSION_DISCOVERY_CONTROL_TARGET_LIMIT = 100;
+function serializeEffectiveSessionControl(control) {
+  const blocker = (value) => ({
+    ...value,
+    changedAt: value.changedAt?.toISOString() ?? null
+  });
+  return {
+    ...control,
+    primaryBlocker: control.primaryBlocker ? blocker(control.primaryBlocker) : null,
+    blockers: control.blockers.map(blocker),
+    resumeOptions: control.resumeOptions.map(({ remainingPrimaryBlocker, ...option }) => ({
+      ...option,
+      ...remainingPrimaryBlocker ? { remainingPrimaryBlocker: blocker(remainingPrimaryBlocker) } : {}
+    }))
+  };
+}
+var SessionControlInvariantError = class extends Error {
+  code = "SESSION_CONTROL_INVARIANT";
+  constructor(message) {
+    super(message);
+    this.name = "SessionControlInvariantError";
+  }
+};
+var SessionControlConflictError = class extends Error {
+  code = "CONTROL_CHANGED";
+  constructor(message = "The workstream control changed") {
+    super(message);
+    this.name = "SessionControlConflictError";
+  }
+};
+var SessionCommandIdempotencyError = class extends Error {
+  code = "IDEMPOTENCY_KEY_REUSED";
+  constructor() {
+    super("The operation key was already used with different input");
+    this.name = "SessionCommandIdempotencyError";
+  }
+};
+var AgentCommandAuthorityError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AgentCommandAuthorityError";
+  }
+};
+async function assertAgentCommandAuthorityInTransaction(db, input) {
+  if (["goal", "wait"].includes(input.action) && input.targetSessionId !== input.actor.sessionId) {
+    throw new SessionControlInvariantError("An agent self command must target its own session");
+  }
+  const authorityLocks = await lockSessionEventWriteRows(db, {
+    workspaceId: input.workspaceId,
+    controlLock: "already_locked",
+    workspaceLock: "already_locked",
+    sessionIds: [input.actor.sessionId, input.targetSessionId],
+    turnIds: [input.actor.turnId],
+    attemptIds: [input.actor.attemptId]
+  });
+  const lockedSessions = authorityLocks.sessions;
+  const callerSession = lockedSessions.find((row) => row.id === input.actor.sessionId);
+  if (!callerSession) {
+    throw new AgentCommandAuthorityError("CALLER_STALE", "The calling session no longer exists");
+  }
+  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(sql3`
+    select
+      attempt.id as "attemptId",
+      attempt.state as "attemptState",
+      attempt.session_id as "attemptSessionId",
+      attempt.turn_id as "attemptTurnId",
+      attempt.execution_generation as "executionGeneration",
+      turn.active_attempt_id as "activeAttemptId",
+      turn.status as "turnStatus",
+      session.active_turn_id as "activeTurnId",
+      exists (
+        select 1
+        from ${sessionAttemptInterruptions} interruption
+        where interruption.workspace_id = ${input.workspaceId}
+          and interruption.attempt_id = attempt.id
+          and interruption.state in ('pending', 'delivered', 'acknowledged')
+      ) as interrupted
+    from ${sessionTurnAttempts} attempt
+    join ${sessionTurns} turn
+      on turn.workspace_id = attempt.workspace_id and turn.id = attempt.turn_id
+    join ${sessions} session
+      on session.workspace_id = attempt.workspace_id and session.id = attempt.session_id
+    where attempt.workspace_id = ${input.workspaceId}
+      and attempt.id = ${input.actor.attemptId}
+  `);
+  const caller = rows[0];
+  if (!caller || !["claimed", "running"].includes(caller.attemptState) || caller.attemptSessionId !== input.actor.sessionId || caller.attemptTurnId !== input.actor.turnId || Number(caller.executionGeneration) !== input.actor.executionGeneration || caller.activeAttemptId !== input.actor.attemptId || caller.activeTurnId !== input.actor.turnId || !["running", "requires_action", "recovering", "waiting_capacity"].includes(caller.turnStatus)) {
+    throw new AgentCommandAuthorityError(
+      "CALLER_STALE",
+      "The calling agent attempt no longer owns its turn"
+    );
+  }
+  if (caller.interrupted) {
+    throw new AgentCommandAuthorityError(
+      "CALLER_INTERRUPTED",
+      "The calling agent attempt is being interrupted"
+    );
+  }
+  if (input.action === "steer" && input.targetSessionId === input.actor.sessionId) {
+    throw new AgentCommandAuthorityError("SELF_STEER", "An agent cannot steer its own session");
+  }
+}
+function asSafeRevision(value, label) {
+  if (value === null) return null;
+  const revision = Number(value);
+  if (!Number.isSafeInteger(revision) || revision < 0) {
+    throw new SessionControlInvariantError(`${label} is not a safe non-negative revision`);
+  }
+  return revision;
+}
+function asDate(value) {
+  if (value === null) return null;
+  return value instanceof Date ? value : new Date(value);
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)])
+    );
+  }
+  return value;
+}
+function canonicalSessionCommandHash(value) {
+  return createHash2("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
+}
+function controlEtag(value) {
+  return `sc1:${canonicalSessionCommandHash(value)}`;
+}
+function lockClause(mode) {
+  if (mode === "none") return sql3.empty();
+  return mode === "update" ? sql3.raw("for update") : sql3.raw("for share");
+}
+var WORKSPACE_CONTROL_REQUEST_LOCK_TIMEOUT_MS = 2e4;
+var configuredRequestLockTimeoutMs = WORKSPACE_CONTROL_REQUEST_LOCK_TIMEOUT_MS;
+function configureWorkspaceControlRequestLockTimeoutMs(lockTimeoutMs) {
+  if (!Number.isSafeInteger(lockTimeoutMs) || lockTimeoutMs <= 0) {
+    throw new Error("Workspace control request lock timeout must be a positive integer (ms)");
+  }
+  configuredRequestLockTimeoutMs = lockTimeoutMs;
+}
+function workspaceControlRequestLockTimeoutMs() {
+  return configuredRequestLockTimeoutMs;
+}
+var WorkspaceControlBusyError = class extends Error {
+  constructor(workspaceId, lockTimeoutMs) {
+    super("The workspace control row is busy; retry shortly");
+    this.workspaceId = workspaceId;
+    this.lockTimeoutMs = lockTimeoutMs;
+    this.name = "WorkspaceControlBusyError";
+  }
+  code = "WORKSPACE_CONTROL_BUSY";
+};
+function workspaceControlLockBudget(lockTimeoutMs) {
+  if (!Number.isFinite(lockTimeoutMs) || lockTimeoutMs <= 0) {
+    throw new Error("Workspace control lockTimeoutMs must be a positive number");
+  }
+  const totalMs = Math.max(1, Math.floor(lockTimeoutMs));
+  return { totalMs, deadlineAt: Date.now() + totalMs };
+}
+function advisoryLockFunction(mode) {
+  return mode === "update" ? sql3.raw("pg_advisory_xact_lock") : sql3.raw("pg_advisory_xact_lock_shared");
+}
+function lockBudgetFor(options) {
+  if (options.budget) return options.budget;
+  if (options.lockTimeoutMs === void 0) return null;
+  return workspaceControlLockBudget(options.lockTimeoutMs);
+}
+async function boundedLockStep(db, workspaceId, budget, step) {
+  if (!budget) return await step();
+  const remainingMs = budget.deadlineAt - Date.now();
+  if (remainingMs <= 0) throw new WorkspaceControlBusyError(workspaceId, budget.totalMs);
+  await db.execute(
+    sql3`select set_config('lock_timeout', ${`${Math.max(1, Math.floor(remainingMs))}ms`}, true)`
+  );
+  try {
+    return await step();
+  } catch (error) {
+    if (nestedPostgresSqlState(error) === "55P03") {
+      throw new WorkspaceControlBusyError(workspaceId, budget.totalMs);
+    }
+    throw error;
+  }
+}
+async function lockWorkspaceInferenceControl(db, workspaceId, mode, options = {}) {
+  const budget = lockBudgetFor(options);
+  const [prior] = budget ? await db.execute(sql3`select current_setting('lock_timeout') as value`) : [];
+  if (mode !== "none") {
+    await boundedLockStep(
+      db,
+      workspaceId,
+      budget,
+      () => db.execute(
+        sql3`select ${advisoryLockFunction(mode)}(hashtextextended(${`workspace-control:${workspaceId}`}, 0))`
+      )
+    );
+  }
+  const rows = await boundedLockStep(
+    db,
+    workspaceId,
+    budget,
+    () => db.execute(sql3`
+      select
+        workspace_id as "workspaceId",
+        account_id as "accountId",
+        revision,
+        workspace_state as "workspaceState",
+        workspace_pause_revision as "workspacePauseRevision",
+        reason,
+        changed_by as "changedBy",
+        changed_at as "changedAt"
+      from ${workspaceInferenceControls}
+      where workspace_id = ${workspaceId}
+      ${lockClause(mode)}
+    `)
+  );
+  if (budget) {
+    await db.execute(sql3`select set_config('lock_timeout', ${prior?.value ?? "0"}, true)`);
+  }
+  const row = rows[0];
+  if (!row) {
+    throw new SessionControlInvariantError(
+      `Workspace ${workspaceId} has no mandatory inference-control row`
+    );
+  }
+  return row;
+}
+var WORKSPACE_CONTROL_ADMISSION_SAVEPOINT = "opengeni_workspace_control_admission";
+async function lockWorkspaceInferenceControlForAdmission(db, input) {
+  const lockOptions = input.lockTimeoutMs === void 0 ? {} : { budget: workspaceControlLockBudget(input.lockTimeoutMs) };
+  await db.execute(sql3.raw(`savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+  const shared = await lockWorkspaceInferenceControl(db, input.workspaceId, "share", lockOptions);
+  if (!input.resumePausedBranch) {
+    await db.execute(sql3.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+    return { control: shared, mode: "share" };
+  }
+  const effective = await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
+    workspaceControl: shared
+  });
+  if (effective.state === "active") {
+    await db.execute(sql3.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+    return { control: shared, mode: "share" };
+  }
+  await db.execute(sql3.raw(`rollback to savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+  await db.execute(sql3.raw(`release savepoint ${WORKSPACE_CONTROL_ADMISSION_SAVEPOINT}`));
+  return {
+    control: await lockWorkspaceInferenceControl(db, input.workspaceId, "update", lockOptions),
+    mode: "update"
+  };
+}
+async function lockSessionEventWriteRows(db, input) {
+  const controlLock = input.controlLock;
+  const control = controlLock === "share" || controlLock === "update" ? await lockWorkspaceInferenceControl(db, input.workspaceId, controlLock) : null;
+  let workspace = null;
+  if ((input.workspaceLock ?? "key_share") === "key_share") {
+    const [lockedWorkspace] = await db.select().from(workspaces).where(eq3(workspaces.id, input.workspaceId)).for("key share").limit(1);
+    workspace = lockedWorkspace ?? null;
+  }
+  const sessionIds = [...new Set(input.sessionIds ?? [])].sort();
+  const sessionLock = input.sessionLock ?? "no_key_update";
+  let sessions2 = sessionIds.length > 0 ? await db.select().from(sessions).where(
+    and3(
+      eq3(sessions.workspaceId, input.workspaceId),
+      inArray2(sessions.id, sessionIds)
+    )
+  ).orderBy(sessions.id).for(sessionLock === "key_share" ? "key share" : "no key update") : [];
+  const cursors = sessions2.length > 0 ? await db.select().from(sessionEventCursors).where(
+    and3(
+      eq3(sessionEventCursors.workspaceId, input.workspaceId),
+      inArray2(
+        sessionEventCursors.sessionId,
+        sessions2.map((session) => session.id)
+      )
+    )
+  ).orderBy(sessionEventCursors.sessionId).for("update") : [];
+  if (cursors.length !== sessions2.length) {
+    throw new SessionControlInvariantError(
+      `Session event cursor lock set was incomplete for workspace ${input.workspaceId}`
+    );
+  }
+  if (sessionLock === "key_share" && sessions2.length > 0) {
+    sessions2 = await db.select().from(sessions).where(
+      and3(
+        eq3(sessions.workspaceId, input.workspaceId),
+        inArray2(sessions.id, sessionIds)
+      )
+    ).orderBy(sessions.id).for("key share");
+  }
+  const canonicalSessions = sessions2.map((session, index) => {
+    const cursor = cursors[index];
+    if (cursor.sessionId !== session.id || cursor.accountId !== session.accountId || cursor.workspaceId !== session.workspaceId) {
+      throw new SessionControlInvariantError(
+        `Session event cursor identity failed for session ${session.id}`
+      );
+    }
+    if (cursor.lastSequence < session.lastSequence) {
+      throw new SessionControlInvariantError(
+        `Session event cursor is behind session projection for session ${session.id}`
+      );
+    }
+    return { ...session, lastSequence: cursor.lastSequence };
+  });
+  const turnIds = [...new Set(input.turnIds ?? [])].sort();
+  const turns = turnIds.length > 0 ? await db.select().from(sessionTurns).where(
+    and3(
+      eq3(sessionTurns.workspaceId, input.workspaceId),
+      inArray2(sessionTurns.id, turnIds)
+    )
+  ).orderBy(sessionTurns.id).for("update") : [];
+  const attemptIds = [...new Set(input.attemptIds ?? [])].sort();
+  const attempts = attemptIds.length > 0 ? await db.select().from(sessionTurnAttempts).where(
+    and3(
+      eq3(sessionTurnAttempts.workspaceId, input.workspaceId),
+      inArray2(sessionTurnAttempts.id, attemptIds)
+    )
+  ).orderBy(sessionTurnAttempts.id).for("update") : [];
+  return { control, workspace, sessions: canonicalSessions, cursors, turns, attempts };
+}
+async function registerSessionTurnAttemptClaim(db, input) {
+  const authoritySnapshot = assertSessionAuthoritySnapshot({
+    attemptId: input.id,
+    authorityEpoch: input.authorityEpoch,
+    authorityVisibility: input.authorityVisibility,
+    authorityOwnerOrganizationMembershipId: input.authorityOwnerOrganizationMembershipId
+  });
+  const [inserted] = await db.insert(sessionTurnAttempts).values({
+    ...input,
+    ...authoritySnapshot,
+    state: "claimed"
+  }).onConflictDoNothing({ target: sessionTurnAttempts.id }).returning();
+  if (inserted) return inserted;
+  const [existing] = await db.select().from(sessionTurnAttempts).where(
+    and3(
+      eq3(sessionTurnAttempts.workspaceId, input.workspaceId),
+      eq3(sessionTurnAttempts.id, input.id)
+    )
+  ).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 || existing.personalResourceProtocolVersion !== input.personalResourceProtocolVersion || JSON.stringify(existing.connectorActionPolicies) !== JSON.stringify(input.connectorActionPolicies) || existing.state === "closed") {
+    throw new SessionControlInvariantError(
+      `Attempt ${input.id} conflicts with a different or closed ownership chain`
+    );
+  }
+  return existing;
+}
+function assertSessionAuthoritySnapshot(input) {
+  const valid = Number.isSafeInteger(input.authorityEpoch) && input.authorityEpoch > 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,
+    authorityVisibility: input.authorityVisibility,
+    authorityOwnerOrganizationMembershipId: input.authorityOwnerOrganizationMembershipId
+  };
+}
+function sessionAuthoritySnapshotMatchesSession(snapshot, session) {
+  return snapshot.authorityEpoch === session.authorityEpoch && snapshot.authorityVisibility === session.visibility && snapshot.authorityOwnerOrganizationMembershipId === (session.ownerOrganizationMembershipId ?? null);
+}
+function sessionAuthoritySnapshotsEqual(left, right) {
+  return left.authorityEpoch === right.authorityEpoch && left.authorityVisibility === right.authorityVisibility && left.authorityOwnerOrganizationMembershipId === right.authorityOwnerOrganizationMembershipId;
+}
+async function closeSessionTurnAttemptInTransaction(db, input) {
+  const [attempt] = await db.select().from(sessionTurnAttempts).where(
+    and3(
+      eq3(sessionTurnAttempts.workspaceId, input.workspaceId),
+      eq3(sessionTurnAttempts.id, input.id)
+    )
+  ).for("update").limit(1);
+  if (!attempt || attempt.accountId !== input.accountId || attempt.sessionId !== input.sessionId || attempt.turnId !== input.turnId || attempt.executionGeneration !== input.executionGeneration) {
+    throw new SessionControlInvariantError(
+      `Attempt ${input.id} does not own the expected session turn generation`
+    );
+  }
+  if (attempt.state === "closed") {
+    if (attempt.outcome !== input.outcome) {
+      throw new SessionControlInvariantError(
+        `Attempt ${input.id} is already closed as ${attempt.outcome ?? "unknown"}`
+      );
+    }
+    return { action: "already_closed" };
+  }
+  if (attempt.state !== "claimed" && attempt.state !== "running") {
+    throw new SessionControlInvariantError(
+      `Attempt ${input.id} has invalid live state ${attempt.state}`
+    );
+  }
+  const now = input.closedAt ?? /* @__PURE__ */ new Date();
+  const [closed] = await db.update(sessionTurnAttempts).set({
+    state: "closed",
+    outcome: input.outcome,
+    workerId: null,
+    leaseId: null,
+    leaseExpiresAt: null,
+    closedAt: now,
+    updatedAt: now
+  }).where(
+    and3(
+      eq3(sessionTurnAttempts.workspaceId, input.workspaceId),
+      eq3(sessionTurnAttempts.id, input.id),
+      sql3`${sessionTurnAttempts.state} in ('claimed', 'running')`
+    )
+  ).returning({ id: sessionTurnAttempts.id });
+  if (!closed) {
+    throw new SessionControlInvariantError(`Attempt ${input.id} changed while locked`);
+  }
+  return { action: "closed" };
+}
+function targetValues(sessionIds) {
+  if (sessionIds.length === 0) {
+    throw new SessionControlInvariantError("At least one target session is required");
+  }
+  return sql3.join(
+    sessionIds.map((id) => sql3`(${id}::uuid)`),
+    sql3`, `
+  );
+}
+var TARGET_PATH_PROJECTION_LIMIT = 128;
+async function loadTargetAncestryRows(db, workspaceId, sessionIds) {
+  return await db.execute(sql3`
+    with recursive targets(id) as (values ${targetValues(sessionIds)}),
+    ancestry as (
+      select
+        target.id as target_id,
+        session.id as session_id,
+        session.parent_session_id,
+        session.title,
+        session.direct_control_state,
+        session.direct_pause_revision,
+        session.subtree_run_override_revision,
+        session.control_version,
+        session.direct_control_changed_by,
+        session.direct_control_reason,
+        session.direct_control_changed_at,
+        0::integer as depth,
+        array[session.id]::uuid[] as path,
+        false as cycle
+      from targets target
+      join ${sessions} session
+        on session.workspace_id = ${workspaceId} and session.id = target.id
+      union all
+      select
+        child.target_id,
+        parent.id,
+        parent.parent_session_id,
+        parent.title,
+        parent.direct_control_state,
+        parent.direct_pause_revision,
+        parent.subtree_run_override_revision,
+        parent.control_version,
+        parent.direct_control_changed_by,
+        parent.direct_control_reason,
+        parent.direct_control_changed_at,
+        child.depth + 1,
+        child.path || parent.id,
+        parent.id = any(child.path)
+      from ancestry child
+      join ${sessions} parent
+        on parent.workspace_id = ${workspaceId} and parent.id = child.parent_session_id
+      where child.parent_session_id is not null
+        and not child.cycle
+        and child.depth < ${SESSION_ANCESTRY_LIMIT}
+    )
+    select
+      target_id as "targetId",
+      session_id as "sessionId",
+      parent_session_id as "parentSessionId",
+      title,
+      direct_control_state as "directState",
+      direct_pause_revision as "directPauseRevision",
+      subtree_run_override_revision as "subtreeRunOverrideRevision",
+      control_version as "controlVersion",
+      direct_control_changed_by as "directControlChangedBy",
+      direct_control_reason as "directControlReason",
+      direct_control_changed_at as "directControlChangedAt",
+      depth,
+      cycle
+    from ancestry
+    order by target_id, depth
+  `);
+}
+async function loadAncestryNodes(db, workspaceId, sessionIds) {
+  const rows = await db.execute(sql3`
+    with recursive targets(id) as (values ${targetValues(sessionIds)}),
+    ancestry_ids(id) as (
+      select session.id
+      from targets target
+      join ${sessions} session
+        on session.workspace_id = ${workspaceId} and session.id = target.id
+      union
+      select parent.id
+      from ancestry_ids child
+      join ${sessions} current
+        on current.workspace_id = ${workspaceId} and current.id = child.id
+      join ${sessions} parent
+        on parent.workspace_id = current.workspace_id
+       and parent.id = current.parent_session_id
+    )
+    select
+      session.id as "sessionId",
+      session.parent_session_id as "parentSessionId",
+      session.title,
+      session.direct_control_state as "directState",
+      session.direct_pause_revision as "directPauseRevision",
+      session.subtree_run_override_revision as "subtreeRunOverrideRevision",
+      session.control_version as "controlVersion",
+      session.direct_control_changed_by as "directControlChangedBy",
+      session.direct_control_reason as "directControlReason",
+      session.direct_control_changed_at as "directControlChangedAt"
+    from ancestry_ids ancestry
+    join ${sessions} session
+      on session.workspace_id = ${workspaceId} and session.id = ancestry.id
+  `);
+  return new Map(rows.map((row) => [row.sessionId, row]));
+}
+function ancestryRowsForTarget(targetId, nodes) {
+  const rows = [];
+  const path = /* @__PURE__ */ new Set();
+  let sessionId = targetId;
+  for (let depth = 0; sessionId !== null; depth += 1) {
+    const node = nodes.get(sessionId);
+    if (!node) break;
+    const cycle = path.has(sessionId);
+    rows.push({ ...node, targetId, depth, cycle });
+    if (cycle || depth >= SESSION_ANCESTRY_LIMIT) break;
+    path.add(sessionId);
+    sessionId = node.parentSessionId;
+  }
+  return rows;
+}
+function assertCompleteAncestry(sessionId, rows) {
+  if (rows.length === 0) {
+    throw new SessionControlInvariantError(`Session ${sessionId} does not exist in its workspace`);
+  }
+  if (rows.some((row) => row.cycle)) {
+    throw new SessionControlInvariantError(`Session ${sessionId} has cyclic ancestry`);
+  }
+  const last = rows.at(-1);
+  const depth = Number(last.depth);
+  if (last.parentSessionId !== null) {
+    throw new SessionControlInvariantError(
+      depth >= SESSION_ANCESTRY_LIMIT ? `Session ${sessionId} ancestry exceeds ${SESSION_ANCESTRY_LIMIT}` : `Session ${sessionId} has a missing ancestor ${last.parentSessionId}`
+    );
+  }
+}
+function blockerForSession(row, revision) {
+  return {
+    kind: "session",
+    sessionId: row.sessionId,
+    displayName: row.title?.trim() || "Untitled session",
+    actor: row.directControlChangedBy,
+    reason: row.directControlReason,
+    changedAt: asDate(row.directControlChangedAt),
+    revision
+  };
+}
+function projectEffectiveControl(workspace, targetId, rows, settlementAttempts, stoppingBackgroundCommandCount) {
+  assertCompleteAncestry(targetId, rows);
+  const workspaceRevision = asSafeRevision(workspace.revision, "workspace control revision");
+  const path = rows.map((row) => ({
+    row,
+    depth: Number(row.depth),
+    pauseRevision: asSafeRevision(row.directPauseRevision, "direct pause revision"),
+    overrideRevision: asSafeRevision(
+      row.subtreeRunOverrideRevision,
+      "subtree run override revision"
+    ),
+    controlVersion: asSafeRevision(row.controlVersion, "session control version")
+  }));
+  const undefeated = [];
+  for (const candidate of path) {
+    if (candidate.row.directState !== "paused" || candidate.pauseRevision === null) continue;
+    const defeated = path.some(
+      (possibleOverride) => possibleOverride.depth < candidate.depth && possibleOverride.overrideRevision !== null && possibleOverride.overrideRevision > candidate.pauseRevision
+    );
+    if (!defeated) {
+      undefeated.push({
+        blocker: blockerForSession(candidate.row, candidate.pauseRevision),
+        depth: candidate.depth
+      });
+    }
+  }
+  const workspacePauseRevision = asSafeRevision(
+    workspace.workspacePauseRevision,
+    "workspace pause revision"
+  );
+  if (workspace.workspaceState === "paused") {
+    if (workspacePauseRevision === null) {
+      throw new SessionControlInvariantError("Paused workspace is missing its pause revision");
+    }
+    const defeated = path.some(
+      (candidate) => candidate.overrideRevision !== null && candidate.overrideRevision > workspacePauseRevision
+    );
+    if (!defeated) {
+      undefeated.push({
+        blocker: {
+          kind: "workspace",
+          displayName: "Workspace",
+          actor: workspace.changedBy,
+          reason: workspace.reason,
+          changedAt: asDate(workspace.changedAt),
+          revision: workspacePauseRevision
+        },
+        depth: Number.POSITIVE_INFINITY
+      });
+    }
+  }
+  undefeated.sort((left, right) => left.depth - right.depth);
+  const blockers = undefeated.map(({ blocker }) => blocker);
+  const primaryBlocker = blockers[0] ?? null;
+  const target = path[0];
+  const override = path.filter((candidate) => candidate.overrideRevision !== null).sort((left, right) => right.overrideRevision - left.overrideRevision)[0];
+  const options = [];
+  if (blockers.length > 0) {
+    options.push({
+      scope: "selected",
+      targetId,
+      selectedStateAfter: "active",
+      impactCopy: "Resume this session and its descendants without changing sibling workstreams."
+    });
+    for (const entry of undefeated) {
+      if (entry.blocker.kind !== "session" || entry.blocker.sessionId === targetId) continue;
+      const remaining = undefeated.find(
+        (candidate) => candidate.depth < entry.depth && candidate.blocker.sessionId !== entry.blocker.sessionId
+      )?.blocker;
+      options.push({
+        scope: "session",
+        targetId: entry.blocker.sessionId,
+        selectedStateAfter: remaining ? "paused" : "active",
+        ...remaining ? { remainingPrimaryBlocker: remaining } : {},
+        impactCopy: `Resume the workstream rooted at ${entry.blocker.displayName}.`
+      });
+    }
+    if (workspace.workspaceState === "paused") {
+      const remaining = undefeated.find((entry) => entry.blocker.kind === "session")?.blocker;
+      options.push({
+        scope: "workspace",
+        selectedStateAfter: remaining ? "paused" : "active",
+        ...remaining ? { remainingPrimaryBlocker: remaining } : {},
+        impactCopy: "Resume the entire workspace; narrower session pauses remain in force."
+      });
+    }
+  }
+  const etagFacts = {
+    workspace: {
+      state: workspace.workspaceState,
+      pauseRevision: workspacePauseRevision
+    },
+    path: path.map((candidate) => ({
+      sessionId: candidate.row.sessionId,
+      directState: candidate.row.directState,
+      pauseRevision: candidate.pauseRevision,
+      overrideRevision: candidate.overrideRevision
+    }))
+  };
+  return {
+    state: blockers.length > 0 ? "paused" : "active",
+    controlVersion: Math.max(
+      workspaceRevision,
+      ...path.map((candidate) => candidate.controlVersion)
+    ),
+    controlEtag: controlEtag(etagFacts),
+    directState: target.row.directState === "paused" ? "paused" : "active",
+    primaryBlocker,
+    additionalBlockerCount: Math.max(0, blockers.length - 1),
+    blockers,
+    resumeOptions: options,
+    override: override?.overrideRevision === null || !override ? null : {
+      rootSessionId: override.row.sessionId,
+      revision: override.overrideRevision
+    },
+    settlement: settlementAttempts.attemptCount > 0 ? { state: "stopping", ...settlementAttempts } : null,
+    backgroundCommandSettlement: stoppingBackgroundCommandCount > 0 ? { state: "stopping", commandCount: stoppingBackgroundCommandCount } : null
+  };
+}
+async function stoppingBackgroundCommandCounts(db, workspaceId, sessionIds) {
+  const rows = await db.execute(sql3`
+    with recursive targets(id) as (values ${targetValues(sessionIds)}),
+    descendants(target_id, session_id, depth, path) as (
+      select target.id, target.id, 0::integer, array[target.id]::uuid[] from targets target
+      union all
+      select parent.target_id, child.id, parent.depth + 1, parent.path || child.id
+      from descendants parent
+      join ${sessions} child
+        on child.workspace_id = ${workspaceId} and child.parent_session_id = parent.session_id
+      where not child.id = any(parent.path) and parent.depth < ${SESSION_ANCESTRY_LIMIT}
+    )
+    select descendant.target_id as "sessionId", count(distinct command.id)::integer as "commandCount"
+    from descendants descendant
+    join ${sessionBackgroundCommands} command
+      on command.workspace_id = ${workspaceId} and command.session_id = descendant.session_id
+      and command.state = 'stopping'
+    group by descendant.target_id
+  `);
+  return new Map(
+    rows.map((row) => [
+      row.sessionId,
+      Number(row.commandCount)
+    ])
+  );
+}
+async function settlementAttemptCounts(db, workspaceId, sessionIds) {
+  const rows = await db.execute(sql3`
+    with recursive targets(id) as (values ${targetValues(sessionIds)}),
+    descendant_sessions(target_id, session_id, depth, path) as (
+      select target.id, target.id, 0::integer, array[target.id]::uuid[]
+      from targets target
+      union all
+      select
+        descendant.target_id,
+        child.id,
+        descendant.depth + 1,
+        descendant.path || child.id
+      from descendant_sessions descendant
+      join ${sessions} child
+        on child.workspace_id = ${workspaceId}
+       and child.parent_session_id = descendant.session_id
+      where not child.id = any(descendant.path)
+        and descendant.depth < ${SESSION_ANCESTRY_LIMIT}
+    ), interruptions as (
+      select
+        descendant.target_id,
+        interruption.attempt_id,
+        bool_or(interruption.state in ('pending', 'delivered', 'acknowledged'))
+          as interruption_pending,
+        bool_or(
+          interruption.state in ('settled', 'rejected_stale')
+          and attempt.quiesced_at is null
+        ) as quiescence_pending
+      from descendant_sessions descendant
+      join ${sessionAttemptInterruptions} interruption
+        on interruption.workspace_id = ${workspaceId}
+       and interruption.session_id = descendant.session_id
+      join ${sessionTurnAttempts} attempt
+        on attempt.workspace_id = interruption.workspace_id
+       and attempt.id = interruption.attempt_id
+      where (
+          interruption.state in ('pending', 'delivered', 'acknowledged')
+          or (
+            interruption.state in ('settled', 'rejected_stale')
+            and attempt.quiesced_at is null
+          )
+        )
+      group by descendant.target_id, interruption.attempt_id
+    )
+    select
+      target.id as "sessionId",
+      count(interruption.attempt_id)::integer as "attemptCount",
+      count(interruption.attempt_id)
+        filter (where interruption.interruption_pending)::integer as "interruptionPendingCount",
+      count(interruption.attempt_id)
+        filter (where interruption.quiescence_pending)::integer as "quiescencePendingCount"
+    from targets target
+    join interruptions interruption on interruption.target_id = target.id
+    group by target.id
+  `);
+  return new Map(
+    rows.map(
+      (row) => [
+        row.sessionId,
+        {
+          attemptCount: Number(row.attemptCount),
+          interruptionPendingCount: Number(row.interruptionPendingCount),
+          quiescencePendingCount: Number(row.quiescencePendingCount)
+        }
+      ]
+    )
+  );
+}
+async function evaluateSessionControls(db, workspaceId, sessionIds, options = {}) {
+  const uniqueIds = [...new Set(sessionIds)];
+  if (uniqueIds.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  if (options.workspaceControl && options.workspaceControl.workspaceId !== workspaceId) {
+    throw new SessionControlInvariantError(
+      `Locked workspace control ${options.workspaceControl.workspaceId} does not match ${workspaceId}`
+    );
+  }
+  const workspace = options.workspaceControl ?? await lockWorkspaceInferenceControl(db, workspaceId, options.lock ?? "share");
+  const stopping = await settlementAttemptCounts(db, workspaceId, uniqueIds);
+  const stoppingCommands = await stoppingBackgroundCommandCounts(db, workspaceId, uniqueIds);
+  const result = /* @__PURE__ */ new Map();
+  if (uniqueIds.length <= TARGET_PATH_PROJECTION_LIMIT) {
+    const ancestry2 = await loadTargetAncestryRows(db, workspaceId, uniqueIds);
+    const ancestryByTarget = /* @__PURE__ */ new Map();
+    for (const row of ancestry2) {
+      const rows = ancestryByTarget.get(row.targetId);
+      if (rows) rows.push(row);
+      else ancestryByTarget.set(row.targetId, [row]);
+    }
+    for (const sessionId of uniqueIds) {
+      result.set(
+        sessionId,
+        projectEffectiveControl(
+          workspace,
+          sessionId,
+          ancestryByTarget.get(sessionId) ?? [],
+          stopping.get(sessionId) ?? NO_SETTLEMENT_ATTEMPTS,
+          stoppingCommands.get(sessionId) ?? 0
+        )
+      );
+    }
+    return result;
+  }
+  const ancestry = await loadAncestryNodes(db, workspaceId, uniqueIds);
+  for (const sessionId of uniqueIds) {
+    result.set(
+      sessionId,
+      projectEffectiveControl(
+        workspace,
+        sessionId,
+        ancestryRowsForTarget(sessionId, ancestry),
+        stopping.get(sessionId) ?? NO_SETTLEMENT_ATTEMPTS,
+        stoppingCommands.get(sessionId) ?? 0
+      )
+    );
+  }
+  return result;
+}
+async function evaluateSessionWriteAdmissionControl(db, workspaceId, sessionId, options = {}) {
+  if (options.workspaceControl && options.workspaceControl.workspaceId !== workspaceId) {
+    throw new SessionControlInvariantError(
+      `Locked workspace control ${options.workspaceControl.workspaceId} does not match ${workspaceId}`
+    );
+  }
+  const workspace = options.workspaceControl ?? await lockWorkspaceInferenceControl(db, workspaceId, options.lock ?? "share");
+  const projected = projectEffectiveControl(
+    workspace,
+    sessionId,
+    await loadTargetAncestryRows(db, workspaceId, [sessionId]),
+    NO_SETTLEMENT_ATTEMPTS,
+    0
+  );
+  return {
+    state: projected.state,
+    controlVersion: projected.controlVersion,
+    primaryBlockerKind: projected.primaryBlocker?.kind ?? null
+  };
+}
+async function evaluateSessionDiscoveryControls(db, workspaceId, sessionIds) {
+  const uniqueIds = [...new Set(sessionIds)];
+  if (uniqueIds.length === 0) return /* @__PURE__ */ new Map();
+  if (uniqueIds.length > SESSION_DISCOVERY_CONTROL_TARGET_LIMIT) {
+    throw new SessionControlInvariantError(
+      `Session discovery control projection exceeds ${SESSION_DISCOVERY_CONTROL_TARGET_LIMIT} targets`
+    );
+  }
+  const workspace = await lockWorkspaceInferenceControl(db, workspaceId, "none");
+  const workspacePauseRevision = asSafeRevision(
+    workspace.workspacePauseRevision,
+    "workspace pause revision"
+  );
+  if (workspace.workspaceState === "paused" && workspacePauseRevision === null) {
+    throw new SessionControlInvariantError("Paused workspace is missing its pause revision");
+  }
+  const rows = await db.execute(sql3`
+    with recursive targets(id) as (values ${targetValues(uniqueIds)}),
+    ancestry as (
+      select
+        target.id as target_id,
+        session.id as session_id,
+        session.parent_session_id,
+        left(coalesce(nullif(btrim(session.title), ''), 'Untitled session'), ${SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS}) as display_name,
+        char_length(coalesce(nullif(btrim(session.title), ''), 'Untitled session'))::integer as display_name_original_chars,
+        session.direct_control_state,
+        session.direct_pause_revision,
+        session.subtree_run_override_revision,
+        0::integer as depth
+      from targets target
+      join ${sessions} session
+        on session.workspace_id = ${workspaceId} and session.id = target.id
+      union all
+      select
+        child.target_id,
+        parent.id,
+        parent.parent_session_id,
+        left(coalesce(nullif(btrim(parent.title), ''), 'Untitled session'), ${SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS}),
+        char_length(coalesce(nullif(btrim(parent.title), ''), 'Untitled session'))::integer,
+        parent.direct_control_state,
+        parent.direct_pause_revision,
+        parent.subtree_run_override_revision,
+        child.depth + 1
+      from ancestry child
+      join ${sessions} parent
+        on parent.workspace_id = ${workspaceId} and parent.id = child.parent_session_id
+      where child.parent_session_id is not null
+        and child.depth < ${SESSION_ANCESTRY_LIMIT}
+    ),
+    path as (
+      select
+        ancestry.*,
+        max(ancestry.subtree_run_override_revision) over (
+          partition by ancestry.target_id
+          order by ancestry.depth
+          rows between unbounded preceding and 1 preceding
+        ) as descendant_override_revision
+      from ancestry
+    ),
+    session_blockers as (
+      select
+        path.target_id,
+        'session'::text as kind,
+        path.session_id,
+        path.display_name,
+        path.display_name_original_chars,
+        path.depth
+      from path
+      where path.direct_control_state = 'paused'
+        and path.direct_pause_revision is not null
+        and (
+          path.descendant_override_revision is null
+          or path.descendant_override_revision <= path.direct_pause_revision
+        )
+    ),
+    workspace_blockers as (
+      select
+        target.id as target_id,
+        'workspace'::text as kind,
+        null::uuid as session_id,
+        'Workspace'::text as display_name,
+        9::integer as display_name_original_chars,
+        ${SESSION_ANCESTRY_LIMIT + 1}::integer as depth
+      from targets target
+      where ${workspace.workspaceState === "paused"}
+        and not exists (
+          select 1
+          from path
+          where path.target_id = target.id
+            and path.subtree_run_override_revision is not null
+            and path.subtree_run_override_revision > ${workspacePauseRevision}
+        )
+    ),
+    blockers as (
+      select * from session_blockers
+      union all
+      select * from workspace_blockers
+    ),
+    primary_blockers as (
+      select distinct on (blockers.target_id)
+        blockers.target_id,
+        blockers.kind,
+        blockers.session_id,
+        blockers.display_name,
+        blockers.display_name_original_chars
+      from blockers
+      order by blockers.target_id, blockers.depth
+    ),
+    blocker_counts as (
+      select blockers.target_id, count(*)::integer as blocker_count
+      from blockers
+      group by blockers.target_id
+    ),
+    ancestry_metadata as (
+      select
+        ancestry.target_id,
+        count(*)::integer as ancestry_count,
+        bool_or(ancestry.parent_session_id is null) as reached_root,
+        max(ancestry.depth)::integer as max_depth
+      from ancestry
+      group by ancestry.target_id
+    )
+    select
+      target.id as "targetId",
+      coalesce(metadata.ancestry_count, 0)::integer as "ancestryCount",
+      coalesce(metadata.reached_root, false) as "reachedRoot",
+      metadata.max_depth as "maxDepth",
+      coalesce(counts.blocker_count, 0)::integer as "blockerCount",
+      primary_blocker.kind as "primaryKind",
+      primary_blocker.session_id as "primarySessionId",
+      primary_blocker.display_name as "primaryDisplayName",
+      primary_blocker.display_name_original_chars as "primaryDisplayNameOriginalChars"
+    from targets target
+    left join ancestry_metadata metadata on metadata.target_id = target.id
+    left join blocker_counts counts on counts.target_id = target.id
+    left join primary_blockers primary_blocker on primary_blocker.target_id = target.id
+    order by target.id
+  `);
+  const result = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const ancestryCount = Number(row.ancestryCount);
+    const maxDepth = row.maxDepth === null ? null : Number(row.maxDepth);
+    if (ancestryCount === 0) {
+      throw new SessionControlInvariantError(
+        `Session ${row.targetId} does not exist in its workspace`
+      );
+    }
+    if (!row.reachedRoot) {
+      throw new SessionControlInvariantError(
+        maxDepth !== null && maxDepth >= SESSION_ANCESTRY_LIMIT ? `Session ${row.targetId} ancestry exceeds ${SESSION_ANCESTRY_LIMIT}` : `Session ${row.targetId} has a missing ancestor`
+      );
+    }
+    const blockerCount = Number(row.blockerCount);
+    const primaryBlocker = row.primaryKind ? {
+      kind: row.primaryKind,
+      ...row.primarySessionId ? { sessionId: row.primarySessionId } : {},
+      displayName: row.primaryDisplayName ?? (row.primaryKind === "workspace" ? "Workspace" : "Untitled session"),
+      displayNameOriginalChars: Number(
+        row.primaryDisplayNameOriginalChars ?? (row.primaryKind === "workspace" ? 9 : "Untitled session".length)
+      )
+    } : null;
+    if (blockerCount > 0 !== (primaryBlocker !== null)) {
+      throw new SessionControlInvariantError(
+        `Session ${row.targetId} discovery blocker aggregate is inconsistent`
+      );
+    }
+    result.set(row.targetId, {
+      state: blockerCount > 0 ? "paused" : "active",
+      primaryBlocker,
+      additionalBlockerCount: Math.max(0, blockerCount - 1)
+    });
+  }
+  if (result.size !== uniqueIds.length) {
+    throw new SessionControlInvariantError("Session discovery control projection is incomplete");
+  }
+  return result;
+}
+async function evaluateSessionControl(db, workspaceId, sessionId, options = {}) {
+  return (await evaluateSessionControls(db, workspaceId, [sessionId], options)).get(sessionId);
+}
+async function findCommandReceipt(db, input) {
+  const actorSubjectId = input.actor.type === "agent_attempt" ? null : input.actor.subjectId;
+  const actorAttemptId = input.actor.type === "agent_attempt" ? input.actor.attemptId : null;
+  const identity = input.identityScope === "target_operation" ? and3(
+    eq3(sessionCommandReceipts.workspaceId, input.workspaceId),
+    eq3(sessionCommandReceipts.actorType, "agent_attempt"),
+    eq3(sessionCommandReceipts.action, input.action),
+    eq3(sessionCommandReceipts.targetSessionId, input.targetSessionId),
+    sql3`${sessionCommandReceipts.targetTurnId} is null`,
+    eq3(sessionCommandReceipts.operationKey, input.operationKey)
+  ) : and3(
+    eq3(sessionCommandReceipts.workspaceId, input.workspaceId),
+    eq3(sessionCommandReceipts.actorType, input.actor.type),
+    sql3`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
+    sql3`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
+    eq3(sessionCommandReceipts.action, input.action),
+    sql3`${sessionCommandReceipts.targetSessionId} is not distinct from ${input.targetSessionId}::uuid`,
+    sql3`${sessionCommandReceipts.targetTurnId} is not distinct from ${input.targetTurnId}::uuid`,
+    eq3(sessionCommandReceipts.operationKey, input.operationKey)
+  );
+  const rows = await db.select().from(sessionCommandReceipts).where(identity).for("update");
+  return rows[0] ?? null;
+}
+async function findPromptCommandReceipts(db, input) {
+  const actorSubjectId = input.actor.type === "agent_attempt" ? null : input.actor.subjectId;
+  const actorAttemptId = input.actor.type === "agent_attempt" ? input.actor.attemptId : null;
+  const query = db.select().from(sessionCommandReceipts).where(
+    and3(
+      eq3(sessionCommandReceipts.workspaceId, input.workspaceId),
+      eq3(sessionCommandReceipts.actorType, input.actor.type),
+      sql3`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
+      sql3`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
+      inArray2(sessionCommandReceipts.action, ["prompt.send", "prompt.steer"]),
+      eq3(sessionCommandReceipts.operationKey, input.operationKey)
+    )
+  );
+  const rows = input.lock === "update" ? await query.for("update") : await query;
+  return rows;
+}
+function fingerprintedPromptCommandReceipt(receipts) {
+  const fingerprinted = receipts.filter(
+    (receipt) => typeof receipt.result.boundaryRequestHash === "string"
+  );
+  if (fingerprinted.length > 1) {
+    throw new SessionControlInvariantError(
+      "Prompt operation key resolved to multiple fingerprinted receipts"
+    );
+  }
+  return fingerprinted[0] ?? null;
+}
+function assertPromptCommandReceiptIdentity(receipt, input) {
+  if (receipt.action !== input.action || receipt.targetSessionId !== input.targetSessionId || receipt.targetTurnId !== null || typeof receipt.result.boundaryRequestHash === "string" && receipt.result.boundaryRequestHash !== input.boundaryRequestHash) {
+    throw new SessionCommandIdempotencyError();
+  }
+}
+async function reserveSessionPromptCommandReceipt(db, input) {
+  await lockSessionPromptCommandOperation(db, input);
+  const existingReceipts = await findPromptCommandReceipts(db, {
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    operationKey: input.operationKey,
+    lock: "update"
+  });
+  const fingerprinted = fingerprintedPromptCommandReceipt(existingReceipts);
+  if (fingerprinted) {
+    assertPromptCommandReceiptIdentity(fingerprinted, input);
+    return { receipt: fingerprinted, replay: true };
+  }
+  const legacyExact = existingReceipts.find(
+    (receipt) => receipt.action === input.action && receipt.targetSessionId === input.targetSessionId && receipt.targetTurnId === null
+  );
+  if (legacyExact) {
+    if (legacyExact.canonicalRequestHash !== input.canonicalRequestHash) {
+      throw new SessionCommandIdempotencyError();
+    }
+    return { receipt: legacyExact, replay: true };
+  }
+  return await reserveSessionCommandReceipt(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    action: input.action,
+    targetSessionId: input.targetSessionId,
+    targetTurnId: null,
+    operationKey: input.operationKey,
+    canonicalRequestHash: input.canonicalRequestHash,
+    ...existingReceipts.length === 0 ? { initialResult: { boundaryRequestHash: input.boundaryRequestHash } } : {}
+  });
+}
+async function lockSessionPromptCommandOperation(db, input) {
+  const actorIdentity = input.actor.type === "agent_attempt" ? `attempt:${input.actor.attemptId}` : `${input.actor.type}:${input.actor.subjectId}`;
+  await db.execute(
+    sql3`select pg_advisory_xact_lock(hashtextextended(${`session-prompt:${input.workspaceId}:${actorIdentity}:${input.operationKey}`}, 0))`
+  );
+}
+async function getCompletedSessionPromptCommandReceipt(db, input) {
+  const receipt = fingerprintedPromptCommandReceipt(
+    await findPromptCommandReceipts(db, {
+      workspaceId: input.workspaceId,
+      actor: input.actor,
+      operationKey: input.operationKey
+    })
+  );
+  if (!receipt) return null;
+  assertPromptCommandReceiptIdentity(receipt, input);
+  if (typeof receipt.result.boundaryRequestHash !== "string" || receipt.appliedQueueVersion === null) {
+    return null;
+  }
+  return receipt;
+}
+async function reserveSessionCommandReceipt(db, input) {
+  if (!input.operationKey.trim()) throw new Error("operationKey must not be empty");
+  const identityScope = input.identityScope ?? "actor";
+  if (identityScope === "target_operation" && (input.actor.type !== "agent_attempt" || !["goal.update", "goal.progress", "session.wait_for_input"].includes(input.action) || input.targetSessionId === null || input.targetTurnId !== null)) {
+    throw new SessionControlInvariantError(
+      "Target-scoped receipt identity is reserved for agent self commands"
+    );
+  }
+  const actorSubjectId = input.actor.type === "agent_attempt" ? null : input.actor.subjectId;
+  const actorAttemptId = input.actor.type === "agent_attempt" ? input.actor.attemptId : null;
+  const [inserted] = await db.insert(sessionCommandReceipts).values({
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    actorType: input.actor.type,
+    actorSubjectId,
+    actorAttemptId,
+    action: input.action,
+    targetSessionId: input.targetSessionId,
+    targetTurnId: input.targetTurnId,
+    operationKey: input.operationKey,
+    canonicalRequestHash: input.canonicalRequestHash,
+    result: input.initialResult ?? {}
+  }).onConflictDoNothing().returning();
+  const receipt = inserted ?? await findCommandReceipt(db, {
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    action: input.action,
+    targetSessionId: input.targetSessionId,
+    targetTurnId: input.targetTurnId,
+    operationKey: input.operationKey,
+    identityScope
+  });
+  if (!receipt) throw new SessionControlInvariantError("Command receipt conflict was not readable");
+  if (receipt.canonicalRequestHash !== input.canonicalRequestHash) {
+    throw new SessionCommandIdempotencyError();
+  }
+  return { receipt, replay: !inserted };
+}
+function nextRevision(workspace) {
+  const current = asSafeRevision(workspace.revision, "workspace control revision");
+  if (current >= Number.MAX_SAFE_INTEGER) {
+    throw new SessionControlInvariantError("Workspace control revision is exhausted");
+  }
+  return current + 1;
+}
+async function advanceWorkspaceRevision(db, workspaceId, revision) {
+  const rows = await db.update(workspaceInferenceControls).set({ revision, updatedAt: /* @__PURE__ */ new Date() }).where(
+    and3(
+      eq3(workspaceInferenceControls.workspaceId, workspaceId),
+      eq3(workspaceInferenceControls.revision, revision - 1)
+    )
+  ).returning({ workspaceId: workspaceInferenceControls.workspaceId });
+  if (rows.length !== 1) {
+    throw new SessionControlInvariantError(
+      "Workspace control revision did not advance exactly once"
+    );
+  }
+}
+async function registerContinuableWakes(db, input) {
+  const rows = await db.execute(sql3`
+    with eligible as (
+      select *
+      from opengeni_private.list_continuable_sessions(
+        ${input.workspaceId}::uuid,
+        ${input.rootSessionId}::uuid
+      )
+    ), upserted as (
+      insert into ${sessionWorkflowWakeOutbox} (
+        session_id, account_id, workspace_id, temporal_workflow_id, reason
+      )
+      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}
+      from eligible
+      on conflict (session_id) do update set
+        wake_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        temporal_workflow_id = excluded.temporal_workflow_id,
+        reason = excluded.reason,
+        attempts = 0,
+        next_attempt_at = now(),
+        last_error = null,
+        updated_at = now()
+      returning session_id
+    )
+    select count(*)::bigint as "wakeCount" from upserted
+  `);
+  return Number(rows[0]?.wakeCount ?? 0);
+}
+async function registerDescendantWakes(db, input) {
+  return await registerContinuableWakes(db, {
+    workspaceId: input.workspaceId,
+    rootSessionId: input.sessionId,
+    reason: input.reason
+  });
+}
+async function registerWorkspaceWakes(db, input) {
+  return await registerContinuableWakes(db, {
+    workspaceId: input.workspaceId,
+    rootSessionId: null,
+    reason: input.reason
+  });
+}
+async function registerInterruptionWakes(db, input) {
+  const rows = await db.execute(sql3`
+    with eligible as (
+      select distinct
+        session.id as session_id,
+        session.account_id,
+        session.workspace_id,
+        coalesce(session.temporal_workflow_id, 'session-' || session.id::text)
+          as temporal_workflow_id
+      from ${sessionAttemptInterruptions} interruption
+      join ${sessions} session
+        on session.workspace_id = interruption.workspace_id
+       and session.id = interruption.session_id
+      where interruption.operation_id = ${input.operationId}::uuid
+        and interruption.state in ('pending', 'delivered', 'acknowledged')
+    ), upserted as (
+      insert into ${sessionWorkflowWakeOutbox} (
+        session_id, account_id, workspace_id, temporal_workflow_id, reason
+      )
+      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}
+      from eligible
+      on conflict (session_id) do update set
+        wake_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        temporal_workflow_id = excluded.temporal_workflow_id,
+        reason = excluded.reason,
+        attempts = 0,
+        next_attempt_at = now(),
+        last_error = null,
+        updated_at = now()
+      returning session_id
+    )
+    select count(*)::bigint as "wakeCount" from upserted
+  `);
+  return Number(rows[0]?.wakeCount ?? 0);
+}
+async function registerCancellationWakes(db, input) {
+  if (input.sessionIds.length === 0) return 0;
+  const sessionIds = sql3.join(
+    input.sessionIds.map((id) => sql3`${id}::uuid`),
+    sql3`, `
+  );
+  const rows = await db.execute(sql3`
+    with eligible as (
+      select
+        session.id as session_id,
+        session.account_id,
+        session.workspace_id,
+        coalesce(session.temporal_workflow_id, 'session-' || session.id::text)
+          as temporal_workflow_id
+      from ${sessions} session
+      where session.workspace_id = ${input.workspaceId}
+        and session.id in (${sessionIds})
+    ), upserted as (
+      insert into ${sessionWorkflowWakeOutbox} (
+        session_id, account_id, workspace_id, temporal_workflow_id, reason, control_revision
+      )
+      select session_id, account_id, workspace_id, temporal_workflow_id, 'session_cancelled', 1
+      from eligible
+      on conflict (session_id) do update set
+        wake_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        control_revision = ${sessionWorkflowWakeOutbox}.wake_revision + 1,
+        temporal_workflow_id = excluded.temporal_workflow_id,
+        reason = excluded.reason,
+        attempts = 0,
+        next_attempt_at = now(),
+        last_error = null,
+        updated_at = now()
+      returning session_id
+    )
+    select count(*)::bigint as "wakeCount" from upserted
+  `);
+  return Number(rows[0]?.wakeCount ?? 0);
+}
+async function registerSessionWorkflowWakeInTransaction(db, input) {
+  const [row] = await db.insert(sessionWorkflowWakeOutbox).values({
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    temporalWorkflowId: input.temporalWorkflowId,
+    controlRevision: input.controlRequested ? 1 : 0,
+    reason: input.reason
+  }).onConflictDoUpdate({
+    target: sessionWorkflowWakeOutbox.sessionId,
+    set: {
+      temporalWorkflowId: input.temporalWorkflowId,
+      wakeRevision: sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
+      controlRevision: input.controlRequested ? sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1` : sql3`${sessionWorkflowWakeOutbox.controlRevision}`,
+      reason: input.reason,
+      attempts: 0,
+      nextAttemptAt: /* @__PURE__ */ new Date(),
+      lastError: null,
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  }).returning({ wakeRevision: sessionWorkflowWakeOutbox.wakeRevision });
+  if (!row) {
+    throw new SessionControlInvariantError(`Failed to register wake for ${input.sessionId}`);
+  }
+  return Number(row.wakeRevision);
+}
+async function registerInternalUpdateWakeInTransaction(db, input) {
+  const [existing] = await db.select().from(sessionWorkflowWakeOutbox).where(
+    and3(
+      eq3(sessionWorkflowWakeOutbox.workspaceId, input.workspaceId),
+      eq3(sessionWorkflowWakeOutbox.sessionId, input.sessionId)
+    )
+  ).for("update").limit(1);
+  if (existing && existing.wakeRevision > existing.deliveredRevision) {
+    await db.update(sessionWorkflowWakeOutbox).set({
+      temporalWorkflowId: input.temporalWorkflowId,
+      reason: "internal_update_batch",
+      nextAttemptAt: /* @__PURE__ */ new Date(),
+      lastError: null,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(eq3(sessionWorkflowWakeOutbox.sessionId, input.sessionId));
+    return { wakeRevision: existing.wakeRevision, shouldSignal: false };
+  }
+  return {
+    wakeRevision: await registerSessionWorkflowWakeInTransaction(db, {
+      ...input,
+      reason: "internal_update_batch"
+    }),
+    shouldSignal: true
+  };
+}
+async function interruptDescendantAttempts(db, input) {
+  const rows = await db.execute(sql3`
+    with recursive live_attempts as (
+      select attempt.id, attempt.account_id, attempt.workspace_id, attempt.session_id
+      from ${sessionTurnAttempts} attempt
+      where attempt.workspace_id = ${input.workspaceId}
+        and attempt.state in ('claimed', 'running')
+    ), attempt_ancestry(attempt_id, account_id, workspace_id, session_id, ancestor_id, depth, path) as (
+      select
+        attempt.id,
+        attempt.account_id,
+        attempt.workspace_id,
+        attempt.session_id,
+        attempt.session_id,
+        0::integer,
+        array[attempt.session_id]::uuid[]
+      from live_attempts attempt
+      union all
+      select
+        ancestry.attempt_id,
+        ancestry.account_id,
+        ancestry.workspace_id,
+        ancestry.session_id,
+        current.parent_session_id,
+        ancestry.depth + 1,
+        ancestry.path || current.parent_session_id
+      from attempt_ancestry ancestry
+      join ${sessions} current
+        on current.workspace_id = ${input.workspaceId} and current.id = ancestry.ancestor_id
+      where current.parent_session_id is not null
+        and not current.parent_session_id = any(ancestry.path)
+        and ancestry.depth < ${SESSION_ANCESTRY_LIMIT}
+    ), inserted as (
+      insert into ${sessionAttemptInterruptions} (
+        account_id, workspace_id, session_id, operation_id, attempt_id,
+        kind, control_revision
+      )
+      select ancestry.account_id, ancestry.workspace_id, ancestry.session_id,
+             ${input.operationId}::uuid, ancestry.attempt_id, ${input.kind}, ${input.controlRevision}
+      from attempt_ancestry ancestry
+      where ancestry.ancestor_id = ${input.sessionId}
+      on conflict (operation_id, attempt_id) do nothing
+      returning id
+    )
+    select count(*)::integer as count from inserted
+  `);
+  return Number(rows[0]?.count ?? 0);
+}
+async function interruptWorkspaceAttempts(db, input) {
+  const rows = await db.execute(sql3`
+    with inserted as (
+      insert into ${sessionAttemptInterruptions} (
+        account_id, workspace_id, session_id, operation_id, attempt_id,
+        kind, control_revision
+      )
+      select attempt.account_id, attempt.workspace_id, attempt.session_id,
+             ${input.operationId}::uuid, attempt.id, 'workspace_pause',
+             ${input.controlRevision}
+      from ${sessionTurnAttempts} attempt
+      where attempt.workspace_id = ${input.workspaceId}
+        and attempt.state in ('claimed', 'running')
+      on conflict (operation_id, attempt_id) do nothing
+      returning id
+    )
+    select count(*)::integer as count from inserted
+  `);
+  return Number(rows[0]?.count ?? 0);
+}
+async function updateSessionCommandReceiptResult(db, receiptId, input) {
+  const [receipt] = await db.update(sessionCommandReceipts).set({
+    ...input.controlRevision !== void 0 ? { appliedControlRevision: input.controlRevision } : {},
+    ...input.queueVersion !== void 0 ? { appliedQueueVersion: input.queueVersion } : {},
+    ...input.turnVersion !== void 0 ? { appliedTurnVersion: input.turnVersion } : {},
+    ...input.draftRevision !== void 0 ? { appliedDraftRevision: input.draftRevision } : {},
+    result: input.result,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(eq3(sessionCommandReceipts.id, receiptId)).returning();
+  if (!receipt) throw new SessionControlInvariantError("Command receipt disappeared");
+  return receipt;
+}
+async function pendingSessionControlWorkflowWake(db, workspaceId, sessionId, wakeCount) {
+  if (wakeCount === 0) return null;
+  const [wake] = await db.select({
+    accountId: sessionWorkflowWakeOutbox.accountId,
+    workspaceId: sessionWorkflowWakeOutbox.workspaceId,
+    sessionId: sessionWorkflowWakeOutbox.sessionId,
+    temporalWorkflowId: sessionWorkflowWakeOutbox.temporalWorkflowId,
+    wakeRevision: sessionWorkflowWakeOutbox.wakeRevision,
+    deliveredRevision: sessionWorkflowWakeOutbox.deliveredRevision
+  }).from(sessionWorkflowWakeOutbox).where(
+    and3(
+      eq3(sessionWorkflowWakeOutbox.workspaceId, workspaceId),
+      eq3(sessionWorkflowWakeOutbox.sessionId, sessionId)
+    )
+  ).limit(1);
+  if (!wake || wake.wakeRevision <= wake.deliveredRevision) return null;
+  return {
+    accountId: wake.accountId,
+    workspaceId: wake.workspaceId,
+    sessionId: wake.sessionId,
+    temporalWorkflowId: wake.temporalWorkflowId,
+    wakeRevision: wake.wakeRevision
+  };
+}
+async function sessionPauseEffectsNeeded(db, input) {
+  const rows = await db.execute(sql3`
+    with recursive subtree(id, path, cycle) as (
+      select session.id, array[session.id]::uuid[], false
+      from ${sessions} session
+      where session.workspace_id = ${input.workspaceId}
+        and session.id = ${input.sessionId}
+      union all
+      select child.id, parent.path || child.id, child.id = any(parent.path)
+      from subtree parent
+      join ${sessions} child
+        on child.workspace_id = ${input.workspaceId}
+       and child.parent_session_id = parent.id
+      where not parent.cycle
+        and cardinality(parent.path) <= ${SESSION_ANCESTRY_LIMIT}
+    ), scoped_sessions as (
+      select session.id, session.subtree_run_override_revision
+      from subtree
+      join ${sessions} session
+        on session.workspace_id = ${input.workspaceId}
+       and session.id = subtree.id
+      where not subtree.cycle
+    )
+    select exists (
+      select 1
+      from scoped_sessions session
+      where session.subtree_run_override_revision > ${input.directPauseRevision}
+      union all
+      select 1
+      from ${sessionTurnAttempts} attempt
+      join scoped_sessions session on session.id = attempt.session_id
+      where attempt.workspace_id = ${input.workspaceId}
+        and attempt.state in ('claimed', 'running')
+        and not exists (
+          select 1
+          from ${sessionAttemptInterruptions} interruption
+          where interruption.workspace_id = attempt.workspace_id
+            and interruption.attempt_id = attempt.id
+            and interruption.kind in ('session_pause', 'workspace_pause')
+            and interruption.state in ('pending', 'delivered', 'acknowledged')
+        )
+      union all
+      select 1
+      from ${sessionBackgroundCommands} command
+      join scoped_sessions session on session.id = command.session_id
+      where command.workspace_id = ${input.workspaceId}
+        and command.state = 'running'
+    ) as needed
+  `);
+  return rows[0]?.needed ?? false;
+}
+async function workspacePauseEffectsNeeded(db, input) {
+  const rows = await db.execute(sql3`
+    select exists (
+      select 1
+      from ${sessions} session
+      where session.workspace_id = ${input.workspaceId}
+        and session.subtree_run_override_revision > ${input.workspacePauseRevision}
+      union all
+      select 1
+      from ${sessionTurnAttempts} attempt
+      where attempt.workspace_id = ${input.workspaceId}
+        and attempt.state in ('claimed', 'running')
+        and not exists (
+          select 1
+          from ${sessionAttemptInterruptions} interruption
+          where interruption.workspace_id = attempt.workspace_id
+            and interruption.attempt_id = attempt.id
+            and interruption.kind in ('session_pause', 'workspace_pause')
+            and interruption.state in ('pending', 'delivered', 'acknowledged')
+        )
+      union all
+      select 1
+      from ${sessionBackgroundCommands} command
+      where command.workspace_id = ${input.workspaceId}
+        and command.state = 'running'
+    ) as needed
+  `);
+  return rows[0]?.needed ?? false;
+}
+async function continuableWakeRepairNeeded(db, input) {
+  const rows = await db.execute(sql3`
+    select exists (
+      select 1
+      from opengeni_private.list_continuable_sessions(
+        ${input.workspaceId}::uuid,
+        ${input.rootSessionId}::uuid
+      ) eligible
+      left join ${sessionWorkflowWakeOutbox} wake
+        on wake.workspace_id = eligible.workspace_id
+       and wake.session_id = eligible.session_id
+      where wake.session_id is null
+        or wake.wake_revision <= wake.delivered_revision
+    ) as needed
+  `);
+  return rows[0]?.needed ?? false;
+}
+async function loadSessionSubtreeIds(db, workspaceId, rootSessionId) {
+  const rows = await db.execute(sql3`
+    with recursive subtree(id, root_parent_session_id, depth, path, cycle) as (
+      select session.id, session.parent_session_id, 0::integer, array[session.id]::uuid[], false
+      from ${sessions} session
+      where session.workspace_id = ${workspaceId} and session.id = ${rootSessionId}
+      union all
+      select child.id, parent.root_parent_session_id, parent.depth + 1,
+             parent.path || child.id, child.id = any(parent.path)
+      from subtree parent
+      join ${sessions} child
+        on child.workspace_id = ${workspaceId} and child.parent_session_id = parent.id
+      where parent.depth < ${SESSION_ANCESTRY_LIMIT} and not parent.cycle
+    )
+    select id, root_parent_session_id as "rootParentSessionId", depth, cycle
+    from subtree
+    order by id
+  `);
+  if (rows.length === 0) {
+    throw new SessionControlInvariantError(`Session ${rootSessionId} does not exist`);
+  }
+  if (rows.some((row) => row.cycle || Number(row.depth) >= SESSION_ANCESTRY_LIMIT)) {
+    throw new SessionControlInvariantError(`Session ${rootSessionId} subtree is invalid`);
+  }
+  return {
+    sessionIds: rows.map((row) => row.id),
+    rootParentSessionId: rows[0]?.rootParentSessionId ?? null
+  };
+}
+var TERMINAL_CANCELLATION_LIVE_TURN_STATUSES = [
+  "queued",
+  "running",
+  "requires_action",
+  "recovering",
+  "waiting_capacity"
+];
+async function loadCancellationTurnIds(db, workspaceId, sessionIds) {
+  const rows = await db.select({ id: sessionTurns.id }).from(sessionTurns).where(
+    and3(
+      eq3(sessionTurns.workspaceId, workspaceId),
+      inArray2(sessionTurns.sessionId, sessionIds),
+      inArray2(sessionTurns.status, TERMINAL_CANCELLATION_LIVE_TURN_STATUSES)
+    )
+  ).orderBy(sessionTurns.id);
+  return rows.map((row) => row.id);
+}
+async function loadParentSessionId(db, workspaceId, sessionId) {
+  const [row] = await db.select({ parentSessionId: sessions.parentSessionId }).from(sessions).where(and3(eq3(sessions.workspaceId, workspaceId), eq3(sessions.id, sessionId))).limit(1);
+  return row?.parentSessionId ?? null;
+}
+async function insertChildOutboxRowInTransaction(db, input) {
+  const parentSessionId = input.childSession.parentSessionId;
+  if (!parentSessionId) return;
+  if (!input.parentSession || input.parentSession.id !== parentSessionId) {
+    throw new SessionControlInvariantError(
+      `Parent session ${parentSessionId} was not locked with child ${input.childSession.id}`
+    );
+  }
+  if (input.parentSession.status === "cancelled") return;
+  if (input.payload.type !== input.kind) {
+    throw new SessionControlInvariantError(
+      `Child outbox ${input.kind} payload discriminator mismatch`
+    );
+  }
+  let personalConnectionDelegations = [];
+  if (input.childSession.parentTurnId) {
+    const [parentTurn] = await db.select({
+      delegations: sessionTurns.personalConnectionDelegations
+    }).from(sessionTurns).where(
+      and3(
+        eq3(sessionTurns.workspaceId, input.workspaceId),
+        eq3(sessionTurns.sessionId, parentSessionId),
+        eq3(sessionTurns.id, input.childSession.parentTurnId)
+      )
+    ).limit(1);
+    if (parentTurn) {
+      const parsed = McpPersonalConnectionDelegations.safeParse(parentTurn.delegations);
+      if (!parsed.success) {
+        throw new SessionControlInvariantError(
+          `Invalid personal MCP delegation snapshot at session_turns:${input.workspaceId}:${parentSessionId}:${input.childSession.parentTurnId}`
+        );
+      }
+      personalConnectionDelegations = parsed.data.map((delegation) => ({
+        ...delegation
+      }));
+    }
+  }
+  await db.insert(sessionSystemUpdateOutbox).values(
+    withLosslessContentWriteVersion(
+      withLosslessContentWriteVersion(
+        {
+          accountId: input.childSession.accountId,
+          workspaceId: input.workspaceId,
+          sourceSessionId: input.childSession.id,
+          targetSessionId: parentSessionId,
+          dedupeKey: input.dedupeKey,
+          kind: input.kind,
+          classification: input.classification,
+          sourceId: input.childSession.id,
+          summary: input.summary,
+          payload: input.payload,
+          lineage: {
+            childSessionId: input.childSession.id,
+            parentSessionId,
+            ...input.childSession.parentTurnId ? { parentTurnId: input.childSession.parentTurnId } : {},
+            ...input.lineage ?? {}
+          },
+          personalConnectionDelegations
+        },
+        "summary",
+        "summaryCodecVersion"
+      ),
+      "payload",
+      "payloadCodecVersion"
+    )
+  ).onConflictDoNothing({
+    target: [
+      sessionSystemUpdateOutbox.workspaceId,
+      sessionSystemUpdateOutbox.dedupeKey
+    ]
+  });
+}
+async function enqueueCancelledChildOutboxInTransaction(db, input) {
+  await insertChildOutboxRowInTransaction(db, {
+    workspaceId: input.workspaceId,
+    childSession: input.rootSession,
+    parentSession: input.parentSession,
+    dedupeKey: `child-completion:${input.rootSession.id}:cancelled`,
+    kind: "child_terminal_result",
+    classification: "info",
+    summary: "Child session was terminally cancelled.",
+    payload: {
+      type: "child_terminal_result",
+      childSessionId: input.rootSession.id,
+      status: "cancelled"
+    }
+  });
+}
+async function enqueueChildPausedOutboxInTransaction(db, input) {
+  if (!childLifecycleNoticesEnabled()) return;
+  const payload = {
+    type: "child_paused",
+    childSessionId: input.childSession.id,
+    operationId: input.operationId,
+    actorKind: input.actorKind,
+    reason: boundedChildPausedReason(input.reason)
+  };
+  await insertChildOutboxRowInTransaction(db, {
+    workspaceId: input.workspaceId,
+    childSession: input.childSession,
+    parentSession: input.parentSession,
+    dedupeKey: childPausedDedupeKey({
+      childSessionId: input.childSession.id,
+      receiptId: input.operationId
+    }),
+    kind: "child_paused",
+    classification: childPausedClassification(input.actorKind),
+    summary: childPausedSummary(input.childSession.id, payload),
+    payload
+  });
+}
+async function enqueueCancelledChildRequiresActionResolvedOutboxInTransaction(db, input) {
+  if (!childLifecycleNoticesEnabled() || !input.parentSession) return;
+  for (const humanInput of input.cancelledHumanInputs) {
+    if (humanInput.sessionId !== input.rootSession.id) continue;
+    const payload = {
+      type: "child_requires_action_resolved",
+      childSessionId: input.rootSession.id,
+      childTurnId: humanInput.turnId,
+      childTurnGeneration: humanInput.turnGeneration,
+      requestId: humanInput.id,
+      approvalId: null,
+      outcome: "cancelled",
+      respondedByKind: "system"
+    };
+    await insertChildOutboxRowInTransaction(db, {
+      workspaceId: input.workspaceId,
+      childSession: input.rootSession,
+      parentSession: input.parentSession,
+      dedupeKey: childRequiresActionResolvedDedupeKey({
+        childSessionId: input.rootSession.id,
+        turnId: humanInput.turnId,
+        turnGeneration: humanInput.turnGeneration,
+        requestId: humanInput.id,
+        approvalId: null
+      }),
+      kind: "child_requires_action_resolved",
+      classification: "info",
+      summary: childRequiresActionResolvedSummary(input.rootSession.id, payload),
+      payload,
+      lineage: { turnId: humanInput.turnId }
+    });
+  }
+}
+async function assertSessionBranchIsNotCancelled(db, workspaceId, sessionId) {
+  const rows = await db.execute(sql3`
+    with recursive ancestry(id, parent_id, status, depth, path, cycle) as (
+      select session.id, session.parent_session_id, session.status, 0::integer,
+             array[session.id]::uuid[], false
+      from ${sessions} session
+      where session.workspace_id = ${workspaceId} and session.id = ${sessionId}
+      union all
+      select parent.id, parent.parent_session_id, parent.status, child.depth + 1,
+             child.path || parent.id, parent.id = any(child.path)
+      from ancestry child
+      join ${sessions} parent
+        on parent.workspace_id = ${workspaceId} and parent.id = child.parent_id
+      where child.depth < ${SESSION_ANCESTRY_LIMIT} and not child.cycle
+    )
+    select
+      coalesce(bool_or(status = 'cancelled'), false) as cancelled,
+      count(*) = 0 or coalesce(bool_or(cycle), false)
+        or coalesce(max(depth), 0) >= ${SESSION_ANCESTRY_LIMIT} as invalid
+    from ancestry
+  `);
+  if (rows[0]?.invalid) {
+    throw new SessionControlInvariantError(`Session ${sessionId} ancestry is invalid`);
+  }
+  if (rows[0]?.cancelled) {
+    throw new SessionControlConflictError("Cancelled session subtree cannot accept work");
+  }
+}
+async function cancelSessionSubtreeInTransaction(db, input) {
+  const candidateTurnIdSet = new Set(input.candidateTurnIds);
+  const candidateTurns = input.lockedTurns.filter((turn) => candidateTurnIdSet.has(turn.id));
+  if (candidateTurns.length !== candidateTurnIdSet.size) {
+    throw new SessionControlInvariantError("Cancellation candidate turns changed while locking");
+  }
+  const suffixLocks = await lockSessionEventWriteRows(db, {
+    workspaceId: input.workspaceId,
+    controlLock: "already_locked",
+    workspaceLock: "already_locked",
+    sessionIds: input.lockedSessions.map((session) => session.id),
+    turnIds: input.candidateTurnIds
+  });
+  if (suffixLocks.sessions.length !== input.lockedSessions.length || suffixLocks.turns.length !== candidateTurnIdSet.size) {
+    throw new SessionControlInvariantError("Cancellation rows changed under canonical locks");
+  }
+  const sessionIdSet = new Set(input.sessionIds);
+  const rootSession = input.lockedSessions.find((session) => session.id === input.rootSessionId);
+  if (!rootSession) {
+    throw new SessionControlInvariantError(
+      `Cancellation root ${input.rootSessionId} was not locked with its subtree`
+    );
+  }
+  const rootParentSession = rootSession.parentSessionId ? input.lockedSessions.find((session) => session.id === rootSession.parentSessionId) ?? null : null;
+  const candidateTurnById = new Map(candidateTurns.map((turn) => [turn.id, turn]));
+  const liveTurnIds = new Set(
+    input.lockedSessions.filter((session) => session.activeTurnId !== null).flatMap((session) => {
+      const turn = session.activeTurnId ? candidateTurnById.get(session.activeTurnId) : void 0;
+      if (turn?.activeAttemptId === null) return [];
+      return turn ? [turn.id] : [];
+    })
+  );
+  const immediatelyCancelledTurns = candidateTurns.filter((turn) => !liveTurnIds.has(turn.id));
+  const cancelledTurnsBySession = /* @__PURE__ */ new Map();
+  for (const turn of immediatelyCancelledTurns) {
+    const turns = cancelledTurnsBySession.get(turn.sessionId);
+    if (turns) turns.push(turn);
+    else cancelledTurnsBySession.set(turn.sessionId, [turn]);
+  }
+  const immediatelyCancelledTurnIds = immediatelyCancelledTurns.map((turn) => turn.id);
+  const now = /* @__PURE__ */ new Date();
+  let cancelledHumanInputs = [];
+  if (immediatelyCancelledTurnIds.length > 0) {
+    await db.update(sessionTurns).set({
+      status: "cancelled",
+      activeAttemptId: null,
+      cancelledBy: input.actor,
+      cancelReason: input.reason ?? "session_cancelled",
+      version: sql3`${sessionTurns.version} + 1`,
+      finishedAt: now,
+      updatedAt: now
+    }).where(inArray2(sessionTurns.id, immediatelyCancelledTurnIds));
+    cancelledHumanInputs = await db.update(sessionHumanInputRequests).set({
+      status: "cancelled",
+      response: { outcome: "cancelled" },
+      respondedBy: input.actor,
+      respondedAt: now,
+      updatedAt: now
+    }).where(
+      and3(
+        eq3(sessionHumanInputRequests.workspaceId, input.workspaceId),
+        inArray2(sessionHumanInputRequests.turnId, immediatelyCancelledTurnIds),
+        eq3(sessionHumanInputRequests.status, "pending")
+      )
+    ).returning({
+      id: sessionHumanInputRequests.id,
+      sessionId: sessionHumanInputRequests.sessionId,
+      turnId: sessionHumanInputRequests.turnId,
+      turnGeneration: sessionHumanInputRequests.turnGeneration,
+      questions: sessionHumanInputRequests.questions
+    });
+    await db.update(codexCapacityWaiters).set({
+      status: "superseded",
+      lastWakeReason: "session_cancelled",
+      updatedAt: now
+    }).where(
+      and3(
+        eq3(codexCapacityWaiters.workspaceId, input.workspaceId),
+        inArray2(codexCapacityWaiters.blockedTurnId, immediatelyCancelledTurnIds),
+        eq3(codexCapacityWaiters.status, "waiting")
+      )
+    );
+  }
+  const cancelledSystemUpdates = await db.update(sessionSystemUpdates).set({ state: "cancelled" }).where(
+    and3(
+      eq3(sessionSystemUpdates.workspaceId, input.workspaceId),
+      inArray2(sessionSystemUpdates.sessionId, input.sessionIds),
+      eq3(sessionSystemUpdates.state, "pending")
+    )
+  ).returning({
+    id: sessionSystemUpdates.id,
+    sessionId: sessionSystemUpdates.sessionId
+  });
+  const humanInputsByTurn = /* @__PURE__ */ new Map();
+  for (const humanInput of cancelledHumanInputs) {
+    const inputs = humanInputsByTurn.get(humanInput.turnId);
+    if (inputs) inputs.push(humanInput);
+    else humanInputsByTurn.set(humanInput.turnId, [humanInput]);
+  }
+  const systemUpdatesBySession = /* @__PURE__ */ new Map();
+  for (const update of cancelledSystemUpdates) {
+    const updates = systemUpdatesBySession.get(update.sessionId);
+    if (updates) updates.push(update);
+    else systemUpdatesBySession.set(update.sessionId, [update]);
+  }
+  const affectedSessionEvents = [];
+  for (const session of input.lockedSessions) {
+    if (!sessionIdSet.has(session.id)) continue;
+    let sequence = session.lastSequence + (session.id === input.rootSessionId ? 1 : 0);
+    const cancelledTurns = cancelledTurnsBySession.get(session.id) ?? [];
+    const preinsertedEvents = [];
+    const eventValues = [];
+    for (const update of (systemUpdatesBySession.get(session.id) ?? []).sort(
+      (left, right) => left.id.localeCompare(right.id)
+    )) {
+      eventValues.push({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: session.id,
+        sequence: ++sequence,
+        type: "system.update.cancelled",
+        payload: { updateId: update.id, reason: "session_cancelled" },
+        occurredAt: now
+      });
+    }
+    for (const turn of cancelledTurns) {
+      const closedTools = await closePendingSessionToolCallsInTransaction(db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: session.id,
+        turnId: turn.id,
+        reason: "session_cancelled",
+        sequence,
+        now
+      });
+      sequence = closedTools.sequence;
+      preinsertedEvents.push(
+        ...closedTools.events.map((event) => ({
+          id: event.id,
+          sequence: event.sequence
+        }))
+      );
+      for (const humanInput of (humanInputsByTurn.get(turn.id) ?? []).sort(
+        (left, right) => left.id.localeCompare(right.id)
+      )) {
+        eventValues.push({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: session.id,
+          sequence: ++sequence,
+          type: "user.humanInputResponse",
+          turnId: turn.id,
+          turnGeneration: turn.executionGeneration,
+          ...turn.id === session.activeTurnId ? { turnAssociation: "current" } : {},
+          payload: {
+            requestId: humanInput.id,
+            response: { outcome: "cancelled" }
+          },
+          occurredAt: now
+        });
+      }
+      eventValues.push({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: session.id,
+        sequence: ++sequence,
+        type: "turn.cancelled",
+        turnId: turn.id,
+        turnGeneration: turn.executionGeneration,
+        ...turn.id === session.activeTurnId ? { turnAssociation: "current" } : {},
+        payload: {
+          reason: input.reason ?? "session_cancelled",
+          operationId: input.operationId
+        },
+        occurredAt: now
+      });
+    }
+    if (session.status !== "cancelled") {
+      eventValues.push({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: session.id,
+        sequence: ++sequence,
+        type: "session.status.changed",
+        payload: {
+          status: "cancelled",
+          reason: input.reason ?? "session_cancelled",
+          operationId: input.operationId
+        },
+        occurredAt: now
+      });
+    }
+    const inserted = eventValues.length > 0 ? await db.insert(sessionEvents).values(withLosslessContentWriteVersion(eventValues, "payload", "payloadCodecVersion")).returning({
+      id: sessionEvents.id,
+      sequence: sessionEvents.sequence,
+      type: sessionEvents.type,
+      turnId: sessionEvents.turnId,
+      payload: sessionEvents.payload
+    }) : [];
+    const cancelledHumanInputsById = new Map(
+      cancelledHumanInputs.filter((request) => request.sessionId === session.id).map((request) => [request.id, request])
+    );
+    for (const event of inserted) {
+      if (event.type !== "user.humanInputResponse") continue;
+      const payload = event.payload;
+      const request = typeof payload.requestId === "string" ? cancelledHumanInputsById.get(payload.requestId) : null;
+      if (!request) continue;
+      await mirrorSessionRealtimeContextInTransaction(db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: session.id,
+        sourceKind: "human_input_response",
+        sourceId: event.id,
+        turnId: event.turnId,
+        channel: null,
+        text: renderRealtimeHumanInputResponseContext({
+          requestId: request.id,
+          questions: request.questions,
+          response: { outcome: "cancelled" }
+        }),
+        payload: {
+          requestId: request.id,
+          outcome: "cancelled",
+          sourceEventId: event.id
+        },
+        now
+      });
+    }
+    const liveTurnId = session.activeTurnId && liveTurnIds.has(session.activeTurnId) ? session.activeTurnId : null;
+    await db.update(sessions).set({
+      status: "cancelled",
+      activeTurnId: liveTurnId,
+      queueVersion: sql3`${sessions.queueVersion} + 1`,
+      queueHeadPosition: 0,
+      queueTailPosition: 0,
+      lastSequence: sequence,
+      updatedAt: now
+    }).where(
+      and3(eq3(sessions.workspaceId, input.workspaceId), eq3(sessions.id, session.id))
+    );
+    const eventIds = [...preinsertedEvents, ...inserted].sort((left, right) => left.sequence - right.sequence).map((event) => event.id);
+    if (session.id === input.rootSessionId) eventIds.unshift(input.rootControlEventId);
+    if (eventIds.length > 0) affectedSessionEvents.push({ sessionId: session.id, eventIds });
+  }
+  await enqueueCancelledChildRequiresActionResolvedOutboxInTransaction(db, {
+    workspaceId: input.workspaceId,
+    rootSession,
+    parentSession: rootParentSession,
+    cancelledHumanInputs
+  });
+  await enqueueCancelledChildOutboxInTransaction(db, {
+    workspaceId: input.workspaceId,
+    rootSession,
+    parentSession: rootParentSession
+  });
+  return {
+    cancelledSessionCount: input.sessionIds.length,
+    cancelledTurnCount: candidateTurns.length,
+    affectedSessionEvents
+  };
+}
+async function mutateSessionControlInTransaction(db, input) {
+  const workspace = await lockWorkspaceInferenceControl(db, input.workspaceId, "update", {
+    ...input.controlLockTimeoutMs !== void 0 ? { lockTimeoutMs: input.controlLockTimeoutMs } : {}
+  });
+  const cancellationSubtree = input.action === "cancel" ? await loadSessionSubtreeIds(db, input.workspaceId, input.sessionId) : { sessionIds: [input.sessionId], rootParentSessionId: null };
+  const cancellationSessionIds = cancellationSubtree.sessionIds;
+  const cancellationTurnIds = input.action === "cancel" ? await loadCancellationTurnIds(db, input.workspaceId, cancellationSessionIds) : [];
+  const pauseParentSessionId = input.action === "pause" && childLifecycleNoticesEnabled() ? await loadParentSessionId(db, input.workspaceId, input.sessionId) : null;
+  const lineageParentSessionId = cancellationSubtree.rootParentSessionId ?? pauseParentSessionId;
+  const locks = await lockSessionEventWriteRows(db, {
+    workspaceId: input.workspaceId,
+    controlLock: "already_locked",
+    sessionIds: input.actor.type === "agent_attempt" ? [
+      input.actor.sessionId,
+      ...cancellationSessionIds,
+      ...lineageParentSessionId ? [lineageParentSessionId] : []
+    ] : [...cancellationSessionIds, ...lineageParentSessionId ? [lineageParentSessionId] : []],
+    turnIds: input.actor.type === "agent_attempt" ? [input.actor.turnId, ...cancellationTurnIds] : cancellationTurnIds,
+    attemptIds: input.actor.type === "agent_attempt" ? [input.actor.attemptId] : []
+  });
+  if (input.action === "cancel" || pauseParentSessionId !== null) {
+    const rootSession = locks.sessions.find((session) => session.id === input.sessionId);
+    if (!rootSession || rootSession.parentSessionId !== lineageParentSessionId) {
+      throw new SessionControlInvariantError(
+        `Session ${input.sessionId} parent changed while establishing ${input.action} locks`
+      );
+    }
+  }
+  const hash = canonicalSessionCommandHash({
+    action: input.action,
+    reason: input.reason ?? null,
+    expectedControlEtag: input.expectedControlEtag ?? null
+  });
+  const reserved = await reserveSessionCommandReceipt(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    action: `session.${input.action}`,
+    targetSessionId: input.sessionId,
+    targetTurnId: null,
+    operationKey: input.operationKey,
+    canonicalRequestHash: hash
+  });
+  if (reserved.replay) {
+    const storedOutcome = reserved.receipt.result.outcome;
+    const unchanged = storedOutcome === "unchanged" && reserved.receipt.appliedControlRevision === null;
+    if (!unchanged && reserved.receipt.appliedControlRevision === null) {
+      throw new SessionControlInvariantError(
+        "Replayed session control receipt has no applied control revision"
+      );
+    }
+    const workspaceControlEventId2 = unchanged ? null : String(reserved.receipt.result.workspaceControlEventId ?? "");
+    if (!unchanged && !workspaceControlEventId2) {
+      throw new SessionControlInvariantError("Replayed session control receipt has no event");
+    }
+    const sessionControlEventId = unchanged ? null : String(reserved.receipt.result.eventId ?? "");
+    if (!unchanged && !sessionControlEventId) {
+      throw new SessionControlInvariantError(
+        "Replayed session control receipt has no session event"
+      );
+    }
+    const wakeCount2 = Number(reserved.receipt.result.wakeCount ?? 0);
+    return {
+      receipt: reserved.receipt,
+      control: await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
+        workspaceControl: workspace
+      }),
+      sessionControlEventId,
+      workspaceControlEventId: workspaceControlEventId2,
+      interruptionCount: Number(reserved.receipt.result.interruptionCount ?? 0),
+      backgroundCommandCount: Number(reserved.receipt.result.backgroundCommandCount ?? 0),
+      wakeCount: wakeCount2,
+      cancelledSessionCount: Number(reserved.receipt.result.cancelledSessionCount ?? 0),
+      cancelledTurnCount: Number(reserved.receipt.result.cancelledTurnCount ?? 0),
+      affectedSessionEvents: Array.isArray(reserved.receipt.result.affectedSessionEvents) ? reserved.receipt.result.affectedSessionEvents : sessionControlEventId ? [{ sessionId: input.sessionId, eventIds: [sessionControlEventId] }] : [],
+      workflowWake: await pendingSessionControlWorkflowWake(
+        db,
+        input.workspaceId,
+        input.sessionId,
+        wakeCount2
+      ),
+      outcome: "replayed",
+      replay: true
+    };
+  }
+  if (input.actor.type === "agent_attempt") {
+    await assertAgentCommandAuthorityInTransaction(db, {
+      workspaceId: input.workspaceId,
+      actor: input.actor,
+      targetSessionId: input.sessionId,
+      action: input.action === "cancel" ? "pause" : input.action
+    });
+  }
+  if (input.action === "resume") {
+    await assertSessionBranchIsNotCancelled(db, input.workspaceId, input.sessionId);
+  }
+  const before = await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
+    workspaceControl: workspace
+  });
+  if (input.expectedControlEtag && input.expectedControlEtag !== before.controlEtag) {
+    throw new SessionControlConflictError();
+  }
+  if (input.action !== "cancel") {
+    const targetSession2 = locks.sessions.find((session) => session.id === input.sessionId);
+    if (!targetSession2) {
+      throw new SessionControlInvariantError(`Session ${input.sessionId} disappeared`);
+    }
+    const directPauseRevision = asSafeRevision(
+      targetSession2.directPauseRevision,
+      "direct pause revision"
+    );
+    const changed = input.action === "pause" ? targetSession2.directControlState !== "paused" || directPauseRevision === null || await sessionPauseEffectsNeeded(db, {
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      directPauseRevision
+    }) : before.state === "paused" || await continuableWakeRepairNeeded(db, {
+      workspaceId: input.workspaceId,
+      rootSessionId: input.sessionId
+    });
+    if (!changed) {
+      const [quiescence] = input.action === "pause" ? await db.execute(sql3`
+            select exists (
+              select 1 from ${sessionTurnAttempts} attempt
+              where attempt.workspace_id = ${input.workspaceId}
+                and attempt.session_id = ${input.sessionId}
+                and attempt.state = 'closed'
+                and attempt.quiesced_at is null
+                and exists (
+                  select 1 from ${sessionAttemptInterruptions} interruption
+                  where interruption.workspace_id = attempt.workspace_id
+                    and interruption.session_id = attempt.session_id
+                    and interruption.attempt_id = attempt.id
+                    and interruption.state in ('settled', 'rejected_stale')
+                )
+            ) as needed
+          `) : [];
+      const wakeCount2 = quiescence?.needed ? 1 : 0;
+      if (wakeCount2 > 0) {
+        await registerSessionWorkflowWakeInTransaction(db, {
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          temporalWorkflowId: targetSession2.temporalWorkflowId ?? `session-${input.sessionId}`,
+          reason: "session_pause_quiescence_reconciliation"
+        });
+      }
+      const receipt2 = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
+        result: {
+          outcome: "unchanged",
+          interruptionCount: 0,
+          backgroundCommandCount: 0,
+          wakeCount: wakeCount2,
+          cancelledSessionCount: 0,
+          cancelledTurnCount: 0,
+          affectedSessionEvents: []
+        }
+      });
+      return {
+        receipt: receipt2,
+        control: before,
+        sessionControlEventId: null,
+        workspaceControlEventId: null,
+        interruptionCount: 0,
+        backgroundCommandCount: 0,
+        wakeCount: wakeCount2,
+        cancelledSessionCount: 0,
+        cancelledTurnCount: 0,
+        affectedSessionEvents: [],
+        workflowWake: await pendingSessionControlWorkflowWake(
+          db,
+          input.workspaceId,
+          input.sessionId,
+          wakeCount2
+        ),
+        outcome: "unchanged",
+        replay: false
+      };
+    }
+  }
+  const targetSession = locks.sessions.find((session) => session.id === input.sessionId);
+  if (!targetSession) {
+    throw new SessionControlInvariantError(`Session ${input.sessionId} disappeared`);
+  }
+  const revision = nextRevision(workspace);
+  await advanceWorkspaceRevision(db, input.workspaceId, revision);
+  const updatedRows = await db.update(sessions).set(
+    input.action === "pause" || input.action === "cancel" ? {
+      directControlState: "paused",
+      directPauseRevision: revision,
+      controlVersion: revision,
+      directControlReason: input.reason ?? null,
+      directControlChangedBy: input.actor.type === "agent_attempt" ? `attempt:${input.actor.attemptId}` : input.actor.subjectId,
+      directControlChangedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    } : {
+      directControlState: "active",
+      directPauseRevision: null,
+      subtreeRunOverrideRevision: revision,
+      controlVersion: revision,
+      directControlReason: input.reason ?? null,
+      directControlChangedBy: input.actor.type === "agent_attempt" ? `attempt:${input.actor.attemptId}` : input.actor.subjectId,
+      directControlChangedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  ).where(
+    and3(
+      eq3(sessions.workspaceId, input.workspaceId),
+      input.action === "cancel" ? inArray2(sessions.id, cancellationSessionIds) : eq3(sessions.id, input.sessionId)
+    )
+  ).returning({ id: sessions.id });
+  const updated = updatedRows.find((row) => row.id === input.sessionId);
+  if (!updated) throw new SessionControlInvariantError(`Session ${input.sessionId} disappeared`);
+  const actor = input.actor.type === "agent_attempt" ? `attempt:${input.actor.attemptId}` : input.actor.subjectId;
+  const backgroundCommandCount = input.action === "pause" || input.action === "cancel" ? await requestSessionBackgroundCommandCancellationsInTransaction(db, {
+    workspaceId: input.workspaceId,
+    rootSessionIds: [input.sessionId],
+    subjectId: actor
+  }) : 0;
+  const workspaceControlEventId = await insertWorkspaceControlEventInTransaction(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    revision,
+    scope: "session",
+    rootSessionId: input.sessionId,
+    action: input.action === "cancel" ? "pause" : input.action,
+    automatic: false,
+    reason: input.reason ?? null,
+    actor
+  });
+  const interruptionCount = input.action === "pause" || input.action === "cancel" ? await interruptDescendantAttempts(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    operationId: reserved.receipt.id,
+    kind: "session_pause",
+    controlRevision: revision
+  }) : 0;
+  const wakeCount = input.action === "cancel" ? await registerCancellationWakes(db, {
+    workspaceId: input.workspaceId,
+    sessionIds: cancellationSessionIds
+  }) : input.action === "pause" ? await registerInterruptionWakes(db, {
+    operationId: reserved.receipt.id,
+    reason: "session_pause_interruption"
+  }) : await registerDescendantWakes(db, {
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    reason: "session_resume"
+  });
+  const [controlEvent] = await db.insert(sessionEvents).values(
+    withLosslessContentWriteVersion(
+      {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        sequence: targetSession.lastSequence + 1,
+        type: input.action === "pause" || input.action === "cancel" ? "session.control.paused" : "session.control.resumed",
+        payload: {
+          operationId: reserved.receipt.id,
+          revision,
+          actor,
+          ...input.reason ? { reason: input.reason } : {},
+          ...input.action === "cancel" ? { terminal: true } : {},
+          interruptionCount
+        },
+        occurredAt: /* @__PURE__ */ new Date()
+      },
+      "payload",
+      "payloadCodecVersion"
+    )
+  ).returning({ id: sessionEvents.id });
+  if (!controlEvent)
+    throw new SessionControlInvariantError("Session control event was not inserted");
+  await db.update(sessions).set({ lastSequence: targetSession.lastSequence + 1, updatedAt: /* @__PURE__ */ new Date() }).where(eq3(sessions.id, input.sessionId));
+  await db.insert(auditEvents).values(
+    withLosslessContentWriteVersion(
+      {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        subjectId: actor,
+        action: `session.control.${input.action}`,
+        targetType: "session",
+        targetId: input.sessionId,
+        metadata: {
+          operationId: reserved.receipt.id,
+          revision,
+          interruptionCount,
+          ...input.actor.type === "agent_attempt" ? {
+            callerSessionId: input.actor.sessionId,
+            callerTurnId: input.actor.turnId,
+            callerAttemptId: input.actor.attemptId,
+            callerExecutionGeneration: input.actor.executionGeneration
+          } : {}
+        }
+      },
+      "metadata",
+      "metadataCodecVersion"
+    )
+  );
+  const cancellation = input.action === "cancel" ? await cancelSessionSubtreeInTransaction(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    rootSessionId: input.sessionId,
+    sessionIds: cancellationSessionIds,
+    lockedSessions: locks.sessions,
+    candidateTurnIds: cancellationTurnIds,
+    lockedTurns: locks.turns,
+    actor,
+    reason: input.reason ?? null,
+    operationId: reserved.receipt.id,
+    rootControlEventId: controlEvent.id
+  }) : {
+    cancelledSessionCount: 0,
+    cancelledTurnCount: 0,
+    affectedSessionEvents: [{ sessionId: input.sessionId, eventIds: [controlEvent.id] }]
+  };
+  if (input.action === "pause" && pauseParentSessionId !== null) {
+    const pausedSession = locks.sessions.find((session) => session.id === input.sessionId);
+    const parentSession = locks.sessions.find((session) => session.id === pauseParentSessionId);
+    const issuedByParentAttempt = input.actor.type === "agent_attempt" && input.actor.sessionId === pauseParentSessionId;
+    if (pausedSession && parentSession && !issuedByParentAttempt) {
+      await enqueueChildPausedOutboxInTransaction(db, {
+        workspaceId: input.workspaceId,
+        childSession: pausedSession,
+        parentSession,
+        operationId: reserved.receipt.id,
+        actorKind: input.actor.type === "agent_attempt" ? "agent" : input.actor.type === "service" ? "api" : "human",
+        reason: input.reason ?? null
+      });
+    }
+  }
+  const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
+    controlRevision: revision,
+    result: {
+      outcome: "changed",
+      interruptionCount,
+      backgroundCommandCount,
+      wakeCount,
+      eventId: controlEvent.id,
+      workspaceControlEventId,
+      cancelledSessionCount: cancellation.cancelledSessionCount,
+      cancelledTurnCount: cancellation.cancelledTurnCount,
+      affectedSessionEvents: cancellation.affectedSessionEvents
+    }
+  });
+  const control = await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
+    lock: "share"
+  });
+  return {
+    receipt,
+    control,
+    sessionControlEventId: controlEvent.id,
+    workspaceControlEventId,
+    interruptionCount,
+    backgroundCommandCount,
+    wakeCount,
+    cancelledSessionCount: cancellation.cancelledSessionCount,
+    cancelledTurnCount: cancellation.cancelledTurnCount,
+    affectedSessionEvents: cancellation.affectedSessionEvents,
+    workflowWake: await pendingSessionControlWorkflowWake(
+      db,
+      input.workspaceId,
+      input.sessionId,
+      wakeCount
+    ),
+    outcome: "changed",
+    replay: false
+  };
+}
+async function autoResumeSessionBranchInTransaction(db, input) {
+  const workspace = input.admission?.control ?? await lockWorkspaceInferenceControl(db, input.workspaceId, "update");
+  await assertSessionBranchIsNotCancelled(db, input.workspaceId, input.sessionId);
+  const before = await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
+    workspaceControl: workspace
+  });
+  if (input.observedControlEtag && input.observedControlEtag !== before.controlEtag) {
+    throw new SessionControlConflictError();
+  }
+  if (before.state === "active") {
+    return {
+      revision: asSafeRevision(workspace.revision, "workspace control revision"),
+      control: before,
+      changed: false,
+      workspaceControlEventId: null
+    };
+  }
+  if (input.admission?.mode === "share") {
+    throw new SessionControlInvariantError(
+      `Session ${input.sessionId} became paused under a shared workspace control lock`
+    );
+  }
+  const revision = nextRevision(workspace);
+  await advanceWorkspaceRevision(db, input.workspaceId, revision);
+  await db.update(sessions).set({
+    directControlState: "active",
+    directPauseRevision: null,
+    subtreeRunOverrideRevision: revision,
+    controlVersion: revision,
+    directControlReason: input.reason,
+    directControlChangedBy: input.actor,
+    directControlChangedAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and3(
+      eq3(sessions.workspaceId, input.workspaceId),
+      eq3(sessions.id, input.sessionId)
+    )
+  );
+  const workspaceControlEventId = await insertWorkspaceControlEventInTransaction(db, {
+    accountId: workspace.accountId,
+    workspaceId: input.workspaceId,
+    revision,
+    scope: "session",
+    rootSessionId: input.sessionId,
+    action: "resume",
+    automatic: true,
+    reason: input.reason,
+    actor: input.actor
+  });
+  return {
+    revision,
+    control: await evaluateSessionControl(db, input.workspaceId, input.sessionId, {
+      lock: "share"
+    }),
+    changed: true,
+    workspaceControlEventId
+  };
+}
+async function mutateWorkspaceControlInTransaction(db, input) {
+  const workspace = await lockWorkspaceInferenceControl(db, input.workspaceId, "update", {
+    ...input.controlLockTimeoutMs !== void 0 ? { lockTimeoutMs: input.controlLockTimeoutMs } : {}
+  });
+  const currentRevision = asSafeRevision(workspace.revision, "workspace control revision");
+  const hash = canonicalSessionCommandHash({
+    action: input.action,
+    reason: input.reason ?? null,
+    expectedRevision: input.expectedRevision ?? null
+  });
+  const reserved = await reserveSessionCommandReceipt(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    action: `workspace.${input.action}`,
+    targetSessionId: null,
+    targetTurnId: null,
+    operationKey: input.operationKey,
+    canonicalRequestHash: hash
+  });
+  if (reserved.replay) {
+    const storedOutcome = reserved.receipt.result.outcome;
+    const unchanged = storedOutcome === "unchanged" && reserved.receipt.appliedControlRevision === null;
+    if (!unchanged && reserved.receipt.appliedControlRevision === null) {
+      throw new SessionControlInvariantError(
+        "Replayed workspace control receipt has no applied control revision"
+      );
+    }
+    const workspaceControlEventId2 = unchanged ? null : String(reserved.receipt.result.workspaceControlEventId ?? "");
+    if (!unchanged && !workspaceControlEventId2) {
+      throw new SessionControlInvariantError("Replayed workspace control receipt has no event");
+    }
+    return {
+      receipt: reserved.receipt,
+      revision: reserved.receipt.appliedControlRevision === null ? currentRevision : Number(reserved.receipt.appliedControlRevision),
+      workspaceControlEventId: workspaceControlEventId2 || null,
+      workspaceState: workspace.workspaceState === "paused" ? "paused" : "active",
+      interruptionCount: Number(reserved.receipt.result.interruptionCount ?? 0),
+      backgroundCommandCount: Number(reserved.receipt.result.backgroundCommandCount ?? 0),
+      wakeCount: Number(reserved.receipt.result.wakeCount ?? 0),
+      outcome: "replayed",
+      replay: true
+    };
+  }
+  if (input.expectedRevision !== null && input.expectedRevision !== void 0) {
+    if (input.expectedRevision !== currentRevision) throw new SessionControlConflictError();
+  }
+  const workspacePauseRevision = asSafeRevision(
+    workspace.workspacePauseRevision,
+    "workspace pause revision"
+  );
+  const changed = input.action === "pause" ? workspace.workspaceState !== "paused" || workspacePauseRevision === null || await workspacePauseEffectsNeeded(db, {
+    workspaceId: input.workspaceId,
+    workspacePauseRevision
+  }) : workspace.workspaceState !== "active" || await continuableWakeRepairNeeded(db, {
+    workspaceId: input.workspaceId,
+    rootSessionId: null
+  });
+  if (!changed) {
+    const receipt2 = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
+      result: {
+        outcome: "unchanged",
+        interruptionCount: 0,
+        backgroundCommandCount: 0,
+        wakeCount: 0
+      }
+    });
+    return {
+      receipt: receipt2,
+      revision: currentRevision,
+      workspaceControlEventId: null,
+      workspaceState: workspace.workspaceState === "paused" ? "paused" : "active",
+      interruptionCount: 0,
+      backgroundCommandCount: 0,
+      wakeCount: 0,
+      outcome: "unchanged",
+      replay: false
+    };
+  }
+  const revision = nextRevision(workspace);
+  const actor = input.actor.type === "agent_attempt" ? `attempt:${input.actor.attemptId}` : input.actor.subjectId;
+  const backgroundCommandCount = input.action === "pause" ? await requestWorkspaceBackgroundCommandCancellationsInTransaction(db, {
+    workspaceId: input.workspaceId,
+    subjectId: actor
+  }) : 0;
+  const [updated] = await db.update(workspaceInferenceControls).set({
+    revision,
+    workspaceState: input.action === "pause" ? "paused" : "active",
+    workspacePauseRevision: input.action === "pause" ? revision : null,
+    reason: input.reason ?? null,
+    changedBy: actor,
+    changedAt: /* @__PURE__ */ new Date(),
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and3(
+      eq3(workspaceInferenceControls.workspaceId, input.workspaceId),
+      eq3(workspaceInferenceControls.revision, currentRevision)
+    )
+  ).returning({ workspaceId: workspaceInferenceControls.workspaceId });
+  if (!updated) {
+    throw new SessionControlInvariantError("Workspace control did not mutate exactly once");
+  }
+  const workspaceControlEventId = await insertWorkspaceControlEventInTransaction(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    revision,
+    scope: "workspace",
+    rootSessionId: null,
+    action: input.action,
+    automatic: false,
+    reason: input.reason ?? null,
+    actor
+  });
+  const interruptionCount = input.action === "pause" ? await interruptWorkspaceAttempts(db, {
+    workspaceId: input.workspaceId,
+    operationId: reserved.receipt.id,
+    controlRevision: revision
+  }) : 0;
+  const wakeCount = input.action === "pause" ? await registerInterruptionWakes(db, {
+    operationId: reserved.receipt.id,
+    reason: "workspace_pause_interruption"
+  }) : await registerWorkspaceWakes(db, {
+    workspaceId: input.workspaceId,
+    reason: "workspace_resume"
+  });
+  const receipt = await updateSessionCommandReceiptResult(db, reserved.receipt.id, {
+    controlRevision: revision,
+    result: {
+      outcome: "changed",
+      interruptionCount,
+      backgroundCommandCount,
+      wakeCount,
+      workspaceControlEventId
+    }
+  });
+  return {
+    receipt,
+    revision,
+    workspaceControlEventId,
+    workspaceState: input.action === "pause" ? "paused" : "active",
+    interruptionCount,
+    backgroundCommandCount,
+    wakeCount,
+    outcome: "changed",
+    replay: false
+  };
+}
+async function insertWorkspaceControlEventInTransaction(db, input) {
+  const projected = boundWorkspaceControlEvent(
+    {
+      id: crypto.randomUUID(),
+      workspaceId: input.workspaceId,
+      sequence: input.revision,
+      revision: input.revision,
+      type: "workspace.control.changed",
+      scope: input.scope,
+      rootSessionId: input.rootSessionId,
+      action: input.action,
+      automatic: input.automatic,
+      reason: input.reason,
+      actor: input.actor,
+      occurredAt: (/* @__PURE__ */ new Date(0)).toISOString()
+    },
+    { surface: "durable_control" }
+  );
+  const field = (name) => projected.truncation?.fields.find((candidate) => candidate.field === name);
+  const [event] = await db.insert(workspaceControlEvents).values({
+    ...input,
+    reason: projected.reason,
+    reasonOriginalBytes: input.reason === null ? null : field("reason")?.originalBytes ?? workspaceControlUtf8Bytes(projected.reason),
+    actor: projected.actor,
+    actorOriginalBytes: field("actor")?.originalBytes ?? workspaceControlUtf8Bytes(projected.actor)
+  }).returning({ id: workspaceControlEvents.id });
+  if (!event) {
+    throw new SessionControlInvariantError("Workspace control event was not inserted");
+  }
+  return event.id;
+}
+
+// src/session-background-commands.ts
+var SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES = 512;
+function boundedSessionBackgroundCommandReason(value, label) {
+  const normalized = value.trim();
+  let bounded = "";
+  let bytes = 0;
+  for (const character of normalized) {
+    const characterBytes = Buffer.byteLength(character, "utf8");
+    if (bytes + characterBytes > SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES) break;
+    bounded += character;
+    bytes += characterBytes;
+  }
+  if (!bounded) throw new Error(`${label} must not be empty`);
+  return bounded;
+}
+function commandPreview(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return Array.from(normalized).slice(0, 512).join("");
+}
+function mapCommand(row) {
+  const terminal = row.state === "exited" || row.state === "lost";
+  const legacyFailureCode = row.provider === "connected_machine" ? /^op_failure_([A-Za-z0-9_-]{1,128})$/.exec(row.settlementReason ?? "")?.[1] : void 0;
+  const storedFailure = row.runnerFailure ? SessionCommandFailure.safeParse(row.runnerFailure) : null;
+  const failure = !terminal ? void 0 : row.runnerFailure ? storedFailure?.success ? storedFailure.data : {
+    code: /^[A-Za-z0-9_-]{1,128}$/.test(row.runnerFailure.code) ? row.runnerFailure.code : "INVALID_RUNNER_FAILURE",
+    detail: {
+      metadata_error: "Stored runner failure details do not match the retained contract."
+    },
+    retryable: false
+  } : legacyFailureCode ? { code: legacyFailureCode, retryable: false } : void 0;
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    sessionId: row.sessionId,
+    provider: row.provider,
+    state: row.state,
+    commandPreview: row.commandPreview,
+    cancelRequestedAt: row.cancelRequestedAt?.toISOString() ?? null,
+    exitCode: row.exitCode ?? null,
+    settlementReason: row.settlementReason ?? null,
+    ...failure ? { failure } : {},
+    startedAt: row.startedAt.toISOString(),
+    settledAt: row.settledAt?.toISOString() ?? null,
+    completionObservedAt: row.completionObservedAt?.toISOString() ?? null,
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+async function backgroundCommandActivityForSessions(db, input) {
+  if (input.sessionIds.length === 0) return /* @__PURE__ */ new Map();
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.select({
+        sessionId: sessionBackgroundCommands.sessionId,
+        count: sql4`count(*)::int`,
+        stoppingCount: sql4`count(*) filter (where ${sessionBackgroundCommands.state} = 'stopping')::int`
+      }).from(sessionBackgroundCommands).where(
+        and4(
+          eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          inArray3(sessionBackgroundCommands.sessionId, input.sessionIds),
+          inArray3(sessionBackgroundCommands.state, ["running", "stopping"])
+        )
+      ).groupBy(sessionBackgroundCommands.sessionId);
+      return new Map(
+        rows.map((row) => [
+          row.sessionId,
+          {
+            state: Number(row.stoppingCount) > 0 ? "stopping" : "running",
+            count: Number(row.count)
+          }
+        ])
+      );
+    }
+  );
+}
+async function listSessionBackgroundCommands(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.select().from(sessionBackgroundCommands).where(
+        and4(
+          eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq4(sessionBackgroundCommands.sessionId, input.sessionId),
+          ...input.activeOnly ? [inArray3(sessionBackgroundCommands.state, ["running", "stopping"])] : []
+        )
+      ).orderBy(
+        desc2(sessionBackgroundCommands.startedAt),
+        desc2(sessionBackgroundCommands.id)
+      ).limit(1e3);
+      return rows.map(mapCommand);
+    }
+  );
+}
+async function insertManagedSessionBackgroundCommandInTransaction(db, input) {
+  const [process] = await db.select({
+    accountId: sandboxRetainedProcesses.accountId,
+    workspaceId: sandboxRetainedProcesses.workspaceId,
+    sessionId: sandboxRetainedProcesses.sessionId,
+    state: sandboxRetainedProcesses.state,
+    ownerActorKind: sandboxRetainedProcesses.ownerActorKind,
+    ownerActorId: sandboxRetainedProcesses.ownerActorId,
+    ownerTurnId: sandboxRetainedProcesses.ownerTurnId,
+    ownerAttemptId: sandboxRetainedProcesses.ownerAttemptId,
+    ownerExecutionGeneration: sandboxRetainedProcesses.ownerExecutionGeneration
+  }).from(sandboxRetainedProcesses).where(eq4(sandboxRetainedProcesses.id, input.retainedProcessId)).for("update").limit(1);
+  if (!process || process.accountId !== input.accountId || process.workspaceId !== input.workspaceId || process.sessionId !== input.sessionId || process.state !== "active") {
+    throw new Error("Managed background command requires its exact active retained process");
+  }
+  const [row] = await db.insert(sessionBackgroundCommands).values({
+    id: input.commandId,
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    provider: "managed",
+    state: "running",
+    retainedProcessId: input.retainedProcessId,
+    commandPreview: commandPreview(input.command),
+    launchTurnId: input.turnId ?? null,
+    launchAttemptId: input.attemptId ?? null,
+    launchExecutionGeneration: input.executionGeneration ?? null
+  }).onConflictDoUpdate({
+    target: sessionBackgroundCommands.retainedProcessId,
+    targetWhere: sql4`${sessionBackgroundCommands.retainedProcessId} is not null`,
+    set: { updatedAt: /* @__PURE__ */ new Date() }
+  }).returning();
+  if (!row) throw new Error("Managed background command adoption returned no row");
+  const legacyReplayMatches = row.launchTurnId === null && row.launchAttemptId === null && row.launchExecutionGeneration === null && process.ownerActorKind === "turn" && process.ownerActorId === input.attemptId && process.ownerTurnId === input.turnId && process.ownerAttemptId === input.attemptId && process.ownerExecutionGeneration === input.executionGeneration;
+  if (row.accountId !== input.accountId || row.workspaceId !== input.workspaceId || row.sessionId !== input.sessionId || !legacyReplayMatches && (row.launchTurnId !== (input.turnId ?? null) || row.launchAttemptId !== (input.attemptId ?? null) || row.launchExecutionGeneration !== (input.executionGeneration ?? null)) || row.provider !== "managed" || row.retainedProcessId !== input.retainedProcessId) {
+    throw new Error("Managed background command adoption conflicted with another identity");
+  }
+  return mapCommand(row);
+}
+async function insertConnectedMachineSessionBackgroundCommandInTransaction(db, input) {
+  const [row] = await db.insert(sessionBackgroundCommands).values({
+    id: input.commandId,
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    provider: "connected_machine",
+    state: "running",
+    controlWorkspaceId: input.controlWorkspaceId,
+    enrollmentId: input.enrollmentId,
+    connectionInstanceId: input.connectionInstanceId,
+    opId: input.opId,
+    commandPreview: commandPreview(input.command),
+    launchTurnId: input.turnId ?? null,
+    launchAttemptId: input.attemptId ?? null,
+    launchExecutionGeneration: input.executionGeneration ?? null
+  }).onConflictDoUpdate({
+    target: [
+      sessionBackgroundCommands.controlWorkspaceId,
+      sessionBackgroundCommands.enrollmentId,
+      sessionBackgroundCommands.connectionInstanceId,
+      sessionBackgroundCommands.opId
+    ],
+    targetWhere: sql4`${sessionBackgroundCommands.provider} = 'connected_machine'`,
+    set: { updatedAt: /* @__PURE__ */ new Date() }
+  }).returning();
+  if (!row) throw new Error("Connected Machine background command adoption returned no row");
+  if (row.accountId !== input.accountId || row.workspaceId !== input.workspaceId || row.sessionId !== input.sessionId || row.launchTurnId !== (input.turnId ?? null) || row.launchAttemptId !== (input.attemptId ?? null) || row.launchExecutionGeneration !== (input.executionGeneration ?? null) || row.provider !== "connected_machine" || row.controlWorkspaceId !== input.controlWorkspaceId || row.enrollmentId !== input.enrollmentId || row.connectionInstanceId !== input.connectionInstanceId || row.opId !== input.opId) {
+    throw new Error(
+      "Connected Machine background command adoption conflicted with another identity"
+    );
+  }
+  return mapCommand(row);
+}
+async function claimConnectedMachineSessionBackgroundCommands(db, input) {
+  if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100) {
+    throw new Error("Connected command reconciliation limit must be between 1 and 100");
+  }
+  if (!Number.isSafeInteger(input.claimTtlMs) || input.claimTtlMs < 0 || input.claimTtlMs > 36e5) {
+    throw new Error("Connected command reconciliation claim TTL is invalid");
+  }
+  const rows = await db.execute(sql4`
+    select account_id as "accountId",
+      workspace_id as "workspaceId",
+      session_id as "sessionId",
+      command_id as "commandId",
+      claim_id as "claimId",
+      command_state as "commandState",
+      control_workspace_id as "controlWorkspaceId",
+      enrollment_id as "enrollmentId",
+      connection_instance_id as "connectionInstanceId",
+      op_id as "opId",
+      reconcile_attempts as "reconcileAttempts",
+      reconcile_proof_outcome as "reconcileProofOutcome",
+      reconcile_proof_exit_code as "reconcileProofExitCode",
+      reconcile_proof_reason as "reconcileProofReason",
+      reconcile_proof_observed_at as "reconcileProofObservedAt"
+    from opengeni_private.claim_connected_machine_background_commands(
+      ${input.claimId}::uuid, ${input.limit}::integer, ${input.claimTtlMs}::bigint,
+      ${(input.dueBefore ?? /* @__PURE__ */ new Date()).toISOString()}::timestamptz
+    )
+  `);
+  return rows.map((row) => {
+    if (row.commandState !== "running" && row.commandState !== "stopping") {
+      throw new Error(`Connected command claim returned invalid state ${row.commandState}`);
+    }
+    const proof = row.reconcileProofOutcome === null ? null : row.reconcileProofOutcome === "exited" || row.reconcileProofOutcome === "lost" ? {
+      outcome: row.reconcileProofOutcome,
+      exitCode: row.reconcileProofExitCode === null ? null : Number(row.reconcileProofExitCode),
+      reason: row.reconcileProofReason,
+      observedAt: row.reconcileProofObservedAt instanceof Date ? row.reconcileProofObservedAt : new Date(row.reconcileProofObservedAt)
+    } : (() => {
+      throw new Error(
+        `Connected command claim returned invalid proof ${row.reconcileProofOutcome}`
+      );
+    })();
+    return {
+      commandId: row.commandId,
+      accountId: row.accountId,
+      workspaceId: row.workspaceId,
+      sessionId: row.sessionId,
+      claimId: row.claimId,
+      state: row.commandState,
+      controlWorkspaceId: row.controlWorkspaceId,
+      enrollmentId: row.enrollmentId,
+      connectionInstanceId: row.connectionInstanceId,
+      opId: row.opId,
+      reconcileAttempts: Number(row.reconcileAttempts),
+      proof
+    };
+  });
+}
+function connectedClaimIdentityWhere(claim) {
+  return and4(
+    eq4(sessionBackgroundCommands.id, claim.commandId),
+    eq4(sessionBackgroundCommands.accountId, claim.accountId),
+    eq4(sessionBackgroundCommands.workspaceId, claim.workspaceId),
+    eq4(sessionBackgroundCommands.sessionId, claim.sessionId),
+    eq4(sessionBackgroundCommands.provider, "connected_machine"),
+    eq4(sessionBackgroundCommands.controlWorkspaceId, claim.controlWorkspaceId),
+    eq4(sessionBackgroundCommands.enrollmentId, claim.enrollmentId),
+    eq4(sessionBackgroundCommands.connectionInstanceId, claim.connectionInstanceId),
+    eq4(sessionBackgroundCommands.opId, claim.opId),
+    eq4(sessionBackgroundCommands.reconcileClaimId, claim.claimId),
+    inArray3(sessionBackgroundCommands.state, ["running", "stopping"])
+  );
+}
+async function recordConnectedMachineBackgroundCommandProof(db, input) {
+  const failure = input.proof.failure ? SessionCommandFailure.parse(input.proof.failure) : null;
+  const reason = boundedSessionBackgroundCommandReason(
+    input.proof.reason,
+    "Connected command proof reason"
+  );
+  if (failure && reason !== `op_failure_${failure.code}`)
+    throw new Error("Connected command failure code conflicts with proof reason");
+  if (input.proof.outcome === "exited" && input.proof.exitCode === null) {
+    throw new Error("Connected command exit proof requires an exit code");
+  }
+  if (input.proof.outcome === "lost" && input.proof.exitCode !== null) {
+    throw new Error("Connected command loss proof cannot carry an exit code");
+  }
+  await withRlsContext(
+    db,
+    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
+    async (scopedDb) => {
+      const [current] = await scopedDb.select().from(sessionBackgroundCommands).where(connectedClaimIdentityWhere(input.claim)).for("update").limit(1);
+      if (!current) throw new Error("Connected command proof was fenced by newer lifecycle state");
+      if (current.reconcileProofOutcome !== null) {
+        const observedAt = current.reconcileProofObservedAt?.getTime() ?? null;
+        if (current.reconcileProofOutcome !== input.proof.outcome || current.reconcileProofExitCode !== input.proof.exitCode || current.reconcileProofReason !== reason || !isDeepStrictEqual(current.runnerFailure, failure) || observedAt !== input.proof.observedAt.getTime()) {
+          throw new Error("Connected command reconciliation proof conflicts with durable proof");
+        }
+        return;
+      }
+      const rows = await scopedDb.update(sessionBackgroundCommands).set({
+        reconcileProofOutcome: input.proof.outcome,
+        reconcileProofExitCode: input.proof.exitCode,
+        reconcileProofReason: reason,
+        runnerFailure: failure,
+        reconcileProofObservedAt: input.proof.observedAt,
+        lastReconcileOutcome: `proof_${input.proof.outcome}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(connectedClaimIdentityWhere(input.claim)).returning({ id: sessionBackgroundCommands.id });
+      if (rows.length !== 1) {
+        throw new Error("Connected command proof lost its exact claim during checkpoint");
+      }
+    }
+  );
+}
+async function deferConnectedMachineBackgroundCommandReconciliation(db, input) {
+  if (!Number.isSafeInteger(input.retryAfterMs) || input.retryAfterMs < 0) {
+    throw new Error("Connected command reconciliation retry delay is invalid");
+  }
+  const outcome = input.outcome.trim().slice(0, 64);
+  if (!outcome) throw new Error("Connected command reconciliation outcome must not be empty");
+  return await withRlsContext(
+    db,
+    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.update(sessionBackgroundCommands).set({
+        reconcileAfter: new Date(Date.now() + input.retryAfterMs),
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        lastReconcileOutcome: outcome,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(connectedClaimIdentityWhere(input.claim)).returning({ id: sessionBackgroundCommands.id });
+      return rows.length === 1;
+    }
+  );
+}
+async function settleClaimedConnectedMachineBackgroundCommandWithMutation(db, input, mutateTerminal) {
+  return await withSessionActivityRlsContext(
+    db,
+    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
+    async (tx) => {
+      await mutateTerminal.prepare(tx);
+      const rows = await tx.execute(sql4`
+          update ${sessionBackgroundCommands} command set
+            state = command.reconcile_proof_outcome,
+            exit_code = case
+              when command.reconcile_proof_outcome = 'exited'
+                then command.reconcile_proof_exit_code
+              else null
+            end,
+            settlement_reason = command.reconcile_proof_reason,
+            settled_at = command.reconcile_proof_observed_at,
+            reconcile_claim_id = null,
+            reconcile_claimed_at = null,
+            last_reconcile_outcome = 'settled_' || command.reconcile_proof_outcome,
+            updated_at = clock_timestamp()
+          where command.id = ${input.claim.commandId}
+            and command.account_id = ${input.claim.accountId}
+            and command.workspace_id = ${input.claim.workspaceId}
+            and command.session_id = ${input.claim.sessionId}
+            and command.provider = 'connected_machine'
+            and command.control_workspace_id = ${input.claim.controlWorkspaceId}
+            and command.enrollment_id = ${input.claim.enrollmentId}
+            and command.connection_instance_id = ${input.claim.connectionInstanceId}
+            and command.op_id = ${input.claim.opId}
+            and command.reconcile_claim_id = ${input.claim.claimId}
+            and command.state in ('running', 'stopping')
+            and command.reconcile_proof_outcome in ('exited', 'lost')
+            and command.reconcile_proof_observed_at is not null
+          returning command.id
+        `);
+      if (rows.length !== 1) return false;
+      const [row] = await tx.select().from(sessionBackgroundCommands).where(eq4(sessionBackgroundCommands.id, input.claim.commandId)).limit(1);
+      if (!row) throw new Error("Settled Connected Machine command disappeared");
+      await mutateTerminal.commit(tx, mapCommand(row));
+      return true;
+    }
+  );
+}
+async function requestSessionBackgroundCommandCancellation(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (tx) => {
+      const [current] = await tx.select().from(sessionBackgroundCommands).where(
+        and4(
+          eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq4(sessionBackgroundCommands.sessionId, input.sessionId),
+          eq4(sessionBackgroundCommands.id, input.commandId)
+        )
+      ).for("update").limit(1);
+      if (!current) return { command: null, accepted: false };
+      if (current.state !== "running") {
+        return { command: mapCommand(current), accepted: false };
+      }
+      const [updated] = await tx.update(sessionBackgroundCommands).set({
+        state: "stopping",
+        cancelRequestedAt: /* @__PURE__ */ new Date(),
+        cancelRequestedBy: input.subjectId.slice(0, 1024),
+        reconcileAfter: /* @__PURE__ */ new Date(),
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(eq4(sessionBackgroundCommands.id, current.id)).returning();
+      if (current.retainedProcessId) {
+        await tx.update(sandboxRetainedProcesses).set({ reconcileAfter: /* @__PURE__ */ new Date(), lastReconcileOutcome: "cancel_requested" }).where(
+          and4(
+            eq4(sandboxRetainedProcesses.id, current.retainedProcessId),
+            eq4(sandboxRetainedProcesses.state, "active"),
+            sql4`${sandboxRetainedProcesses.reconcileClaimId} is null`
+          )
+        );
+      }
+      return { command: mapCommand(updated), accepted: true };
+    })
+  );
+}
+async function requestSessionBackgroundCommandCancellationsInTransaction(db, input) {
+  const rootSessionIds = [...new Set(input.rootSessionIds)];
+  if (rootSessionIds.length === 0) return 0;
+  const rows = await db.execute(sql4`
+    with recursive roots(id) as (
+      values ${sql4.join(
+    rootSessionIds.map((sessionId) => sql4`(${sessionId}::uuid)`),
+    sql4`, `
+  )}
+    ), subtree(id, path, cycle) as (
+      select session.id, array[session.id]::uuid[], false
+      from roots root
+      join ${sessions} session
+        on session.workspace_id = ${input.workspaceId}
+       and session.id = root.id
+      union all
+      select child.id, parent.path || child.id, child.id = any(parent.path)
+      from subtree parent
+      join ${sessions} child
+        on child.workspace_id = ${input.workspaceId}
+       and child.parent_session_id = parent.id
+      where not parent.cycle
+    ), stopped as (
+      update ${sessionBackgroundCommands} command set
+        state = 'stopping',
+        cancel_requested_at = clock_timestamp(),
+        cancel_requested_by = left(${input.subjectId}, 1024),
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        updated_at = clock_timestamp()
+      where command.workspace_id = ${input.workspaceId}
+        and command.session_id in (select id from subtree where not cycle)
+        and command.state = 'running'
+      returning command.retained_process_id
+    ), nudged as (
+      update ${sandboxRetainedProcesses} process set
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        last_reconcile_outcome = 'cancel_requested'
+      where process.id in (
+        select stopped.retained_process_id
+        from stopped
+        where stopped.retained_process_id is not null
+      )
+        and process.state = 'active'
+      returning process.id
+    )
+    select count(*)::integer as "commandCount" from stopped
+  `);
+  return Number(rows[0]?.commandCount ?? 0);
+}
+async function requestWorkspaceBackgroundCommandCancellationsInTransaction(db, input) {
+  const rows = await db.execute(sql4`
+    with stopped as (
+      update ${sessionBackgroundCommands} command set
+        state = 'stopping',
+        cancel_requested_at = clock_timestamp(),
+        cancel_requested_by = left(${input.subjectId}, 1024),
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        updated_at = clock_timestamp()
+      where command.workspace_id = ${input.workspaceId}
+        and command.state = 'running'
+      returning command.retained_process_id
+    ), nudged as (
+      update ${sandboxRetainedProcesses} process set
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        last_reconcile_outcome = 'cancel_requested'
+      where process.id in (
+        select stopped.retained_process_id
+        from stopped
+        where stopped.retained_process_id is not null
+      )
+        and process.state = 'active'
+      returning process.id
+    )
+    select count(*)::integer as "commandCount" from stopped
+  `);
+  return Number(rows[0]?.commandCount ?? 0);
+}
+async function settleSessionBackgroundCommandForRetainedProcessInTransaction(tx, input, mutateTerminal) {
+  const reason = boundedSessionBackgroundCommandReason(
+    input.reason,
+    "Managed command settlement reason"
+  );
+  await mutateTerminal.prepare(tx);
+  const [updatedRow] = await tx.update(sessionBackgroundCommands).set({
+    state: input.outcome,
+    exitCode: input.outcome === "exited" ? input.exitCode : null,
+    settlementReason: reason,
+    settledAt: /* @__PURE__ */ new Date(),
+    reconcileClaimId: null,
+    reconcileClaimedAt: null,
+    lastReconcileOutcome: `settled_${input.outcome}`,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and4(
+      eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+      eq4(sessionBackgroundCommands.sessionId, input.sessionId),
+      eq4(sessionBackgroundCommands.retainedProcessId, input.retainedProcessId),
+      inArray3(sessionBackgroundCommands.state, ["running", "stopping"])
+    )
+  ).returning();
+  let row = updatedRow;
+  if (!row) {
+    const [current] = await tx.select().from(sessionBackgroundCommands).where(
+      and4(
+        eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+        eq4(sessionBackgroundCommands.sessionId, input.sessionId),
+        eq4(sessionBackgroundCommands.retainedProcessId, input.retainedProcessId)
+      )
+    ).for("update").limit(1);
+    if (!current) return null;
+    if (current.state !== input.outcome || current.exitCode !== (input.outcome === "exited" ? input.exitCode : null)) {
+      throw new Error("Managed background command terminal state conflicts with process proof");
+    }
+    const [existingEvent] = await tx.select({ id: sessionEvents.id }).from(sessionEvents).where(
+      and4(
+        eq4(sessionEvents.workspaceId, input.workspaceId),
+        eq4(sessionEvents.sessionId, input.sessionId),
+        eq4(sessionEvents.type, "session.command.finished"),
+        sql4`${sessionEvents.payload} ->> 'commandId' = ${current.id}`
+      )
+    ).limit(1);
+    if (existingEvent) return mapCommand(current);
+    row = current;
+  }
+  const command = mapCommand(row);
+  await mutateTerminal.commit(tx, command);
+  return command;
+}
+async function settleConnectedMachineSessionBackgroundCommandWithMutation(db, input, mutateTerminal) {
+  const failure = input.failure ? SessionCommandFailure.parse(input.failure) : null;
+  const reason = boundedSessionBackgroundCommandReason(
+    input.reason,
+    "Connected command settlement reason"
+  );
+  if (failure && reason !== `op_failure_${failure.code}`)
+    throw new Error("Connected command failure code conflicts with settlement reason");
+  if (input.outcome === "exited" && input.exitCode === null) {
+    throw new Error("Connected command exit settlement requires an exit code");
+  }
+  if (input.outcome === "lost" && input.exitCode !== null) {
+    throw new Error("Connected command loss settlement cannot carry an exit code");
+  }
+  return await withSessionActivityRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (tx) => {
+      await mutateTerminal.prepare(tx);
+      const settledAt = /* @__PURE__ */ new Date();
+      const [row] = await tx.update(sessionBackgroundCommands).set({
+        state: input.outcome,
+        exitCode: input.outcome === "exited" ? input.exitCode : null,
+        settlementReason: reason,
+        runnerFailure: failure,
+        settledAt,
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        reconcileProofOutcome: input.outcome,
+        reconcileProofExitCode: input.outcome === "exited" ? input.exitCode : null,
+        reconcileProofReason: reason,
+        reconcileProofObservedAt: settledAt,
+        lastReconcileOutcome: `settled_${input.outcome}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(
+        and4(
+          eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq4(sessionBackgroundCommands.sessionId, input.sessionId),
+          eq4(sessionBackgroundCommands.id, input.commandId),
+          eq4(sessionBackgroundCommands.provider, "connected_machine"),
+          eq4(sessionBackgroundCommands.controlWorkspaceId, input.controlWorkspaceId),
+          eq4(sessionBackgroundCommands.enrollmentId, input.enrollmentId),
+          eq4(sessionBackgroundCommands.connectionInstanceId, input.connectionInstanceId),
+          eq4(sessionBackgroundCommands.opId, input.opId),
+          // A fast owner settlement cannot erase or replace metadata already
+          // checkpointed by the reconciler under the exact command identity.
+          sql4`(${sessionBackgroundCommands.runnerFailure} is null or
+              ${sessionBackgroundCommands.runnerFailure} = ${failure ? JSON.stringify(failure) : null}::jsonb)`,
+          inArray3(sessionBackgroundCommands.state, ["running", "stopping"])
+        )
+      ).returning();
+      if (!row) return null;
+      const command = mapCommand(row);
+      await mutateTerminal.commit(tx, command);
+      return command;
+    }
+  );
+}
+async function getSessionBackgroundCommand(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [row] = await scopedDb.select().from(sessionBackgroundCommands).where(
+        and4(
+          eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq4(sessionBackgroundCommands.sessionId, input.sessionId),
+          eq4(sessionBackgroundCommands.id, input.commandId)
+        )
+      ).limit(1);
+      return row ? mapCommand(row) : null;
+    }
+  );
+}
+async function observeSessionBackgroundCommandCompletion(db, input) {
+  return await withSessionActivityRlsContext(db, input, async (tx) => {
+    const locks = await lockSessionEventWriteRows(tx, {
+      workspaceId: input.workspaceId,
+      controlLock: "share",
+      sessionIds: [input.sessionId]
+    });
+    if (locks.sessions[0]?.accountId !== input.accountId) return null;
+    const identity = and4(
+      eq4(sessionBackgroundCommands.accountId, input.accountId),
+      eq4(sessionBackgroundCommands.workspaceId, input.workspaceId),
+      eq4(sessionBackgroundCommands.sessionId, input.sessionId),
+      eq4(sessionBackgroundCommands.id, input.commandId)
+    );
+    const [command] = await tx.select().from(sessionBackgroundCommands).where(identity).for("update").limit(1);
+    if (!command) return null;
+    if (command.state !== "exited" && command.state !== "lost") return mapCommand(command);
+    const observedAt = command.completionObservedAt ?? /* @__PURE__ */ new Date();
+    await tx.update(sessionBackgroundCommands).set({ completionObservedAt: observedAt }).where(identity);
+    await tx.update(sessionSystemUpdates).set({ state: "superseded" }).where(
+      and4(
+        eq4(sessionSystemUpdates.accountId, input.accountId),
+        eq4(sessionSystemUpdates.workspaceId, input.workspaceId),
+        eq4(sessionSystemUpdates.sessionId, input.sessionId),
+        eq4(sessionSystemUpdates.kind, "background_command_result"),
+        eq4(sessionSystemUpdates.sourceId, input.commandId),
+        eq4(sessionSystemUpdates.dedupeKey, `background-command-result:${input.commandId}`),
+        eq4(sessionSystemUpdates.state, "pending")
+      )
+    );
+    return mapCommand({ ...command, completionObservedAt: observedAt });
+  });
+}
+var COMMAND_OUTPUT_DEFAULT_BYTES = 16384;
+var COMMAND_OUTPUT_MAX_BYTES = 65536;
+var COMMAND_OUTPUT_PAGE_ROWS = 64;
+function parseCommandOutputCursor(cursor, commandId) {
+  if (cursor === void 0) return { sequence: 0, offset: 0 };
+  if (cursor.length > 128) throw new Error("Invalid command output cursor");
+  const parts = cursor.split(":");
+  if (parts.length !== 3 || parts[0] !== commandId || !/^\d+$/.test(parts[1]) || !/^\d+$/.test(parts[2])) {
+    throw new Error("Invalid command output cursor");
+  }
+  const sequence = Number(parts[1]);
+  const offset = Number(parts[2]);
+  if (!Number.isSafeInteger(sequence) || !Number.isSafeInteger(offset))
+    throw new Error("Invalid command output cursor");
+  return { sequence, offset };
+}
+function projectCommandOutputPage(input) {
+  const start = parseCommandOutputCursor(input.cursor, input.commandId);
+  const budget = input.maxOutputBytes ?? COMMAND_OUTPUT_DEFAULT_BYTES;
+  if (!Number.isSafeInteger(budget) || budget < 4 || budget > COMMAND_OUTPUT_MAX_BYTES)
+    throw new Error("maxOutputBytes must be between 4 and 65536");
+  let remaining = budget;
+  let sequence = start.sequence;
+  let offset = start.offset;
+  const chunks = [];
+  const gaps = [];
+  if (start.offset > 0 && input.rows[0]?.sequence !== start.sequence)
+    gaps.push("cursor_output_no_longer_retained");
+  let consumed = 0;
+  for (const row of input.rows.slice(0, COMMAND_OUTPUT_PAGE_ROWS)) {
+    const payload = fromPostgresLosslessJson(row.payload, row.payloadCodecVersion);
+    const text = typeof payload?.chunk === "string" ? payload.chunk : "";
+    if (typeof payload?.chunk !== "string") gaps.push("retained_event_has_no_output_chunk");
+    if (payload?.commandReadProjectionGap === true) gaps.push("retained_event_exceeds_read_limit");
+    if (payload?.truncation && typeof payload.truncation === "object")
+      gaps.push("output_truncated_at_retention_boundary");
+    const begin = row.sequence === start.sequence ? start.offset : 0;
+    if (begin > 0 && begin < text.length && text.charCodeAt(begin - 1) >= 55296 && text.charCodeAt(begin - 1) <= 56319 && text.charCodeAt(begin) >= 56320 && text.charCodeAt(begin) <= 57343) {
+      throw new Error("Invalid command output cursor: offset splits a Unicode code point");
+    }
+    if (begin > text.length) gaps.push("cursor_output_no_longer_retained");
+    let end = Math.min(begin, text.length);
+    for (const character of text.slice(end)) {
+      const bytes = Buffer.byteLength(character, "utf8");
+      if (bytes > remaining) break;
+      remaining -= bytes;
+      end += character.length;
+    }
+    if (end > begin)
+      chunks.push({
+        sequence: row.sequence,
+        stream: payload.stream === "stderr" ? "stderr" : "stdout",
+        streamFidelity: payload.streamFidelity === "merged" ? "merged" : payload.streamFidelity === "separate" ? "separate" : "unknown",
+        chunk: text.slice(begin, end)
+      });
+    if (end < text.length) {
+      sequence = row.sequence;
+      offset = end;
+      break;
+    }
+    sequence = row.sequence + 1;
+    offset = 0;
+    consumed++;
+  }
+  return {
+    chunks,
+    nextCursor: `${input.commandId}:${sequence}:${offset}`,
+    hasMore: consumed < input.rows.length,
+    retention: {
+      source: "retained_session_events",
+      completeness: "unknown",
+      gaps: [...new Set(gaps)]
+    }
+  };
+}
+async function readSessionBackgroundCommandOutput(db, input) {
+  const cursor = parseCommandOutputCursor(input.cursor, input.commandId);
+  projectCommandOutputPage({ ...input, rows: [] });
+  const command = await getSessionBackgroundCommand(db, input);
+  if (!command) throw new Error("Background command not found in this session");
+  const rows = await withRlsContext(
+    db,
+    input,
+    async (tx) => await tx.select({
+      sequence: sessionEvents.sequence,
+      // Bound legacy payloads in SQL too: LIMIT alone cannot bound one old event.
+      // Oversized historical rows carry explicit loss rather than allocating an
+      // unbounded JSON value in the API process.
+      payload: sql4`case when octet_length(${sessionEvents.payload}::text) <= 262144
+      then ${sessionEvents.payload}
+      else jsonb_build_object('commandReadProjectionGap', true) end`,
+      payloadCodecVersion: sessionEvents.payloadCodecVersion
+    }).from(sessionEvents).where(
+      and4(
+        eq4(sessionEvents.workspaceId, input.workspaceId),
+        eq4(sessionEvents.sessionId, input.sessionId),
+        eq4(sessionEvents.type, "sandbox.command.output.delta"),
+        sql4`${sessionEvents.payload} ->> 'commandId' = ${input.commandId}`,
+        gte(sessionEvents.sequence, cursor.sequence)
+      )
+    ).orderBy(asc2(sessionEvents.sequence)).limit(COMMAND_OUTPUT_PAGE_ROWS + 1)
+  );
+  const page = projectCommandOutputPage({ ...input, rows });
+  const terminal = command.state === "exited" || command.state === "lost";
+  const observed = terminal ? await observeSessionBackgroundCommandCompletion(db, input) : command;
+  return {
+    commandId: command.id,
+    state: command.state,
+    exitCode: command.exitCode,
+    settlementReason: command.settlementReason,
+    ...command.failure ? { failure: command.failure } : {},
+    terminal,
+    completionObservedAt: observed?.completionObservedAt ?? null,
+    ...page
+  };
+}
+
+export {
+  TOOL_RESULT_TYPE_BY_CALL_TYPE,
+  historyCallId,
+  historyItemType,
+  interruptedToolCallResult,
+  closePendingSessionToolCallsInTransaction,
+  configureChildLifecycleNotices,
+  childLifecycleNoticesEnabled,
+  boundedChildNoticeText,
+  CHILD_LIFECYCLE_DEDUPE_PREFIX,
+  childRequiresActionDedupeKey,
+  childRequiresActionResolvedDedupeKey,
+  childPausedDedupeKey,
+  childWaitingCapacityDedupeKey,
+  childProgressDedupeKey,
+  buildChildRequiresActionPayload,
+  childRequiresActionSummary,
+  childRequiresActionResolvedSummary,
+  childPausedSummary,
+  childWaitingCapacitySummary,
+  childProgressSummary,
+  boundedChildPausedReason,
+  boundedChildProgressNote,
+  mirrorSessionRealtimeContextInTransaction,
+  renderRealtimeHumanInputContext,
+  renderRealtimeHumanInputRequestContext,
+  renderRealtimeHumanInputResponseContext,
+  SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES,
+  boundedSessionBackgroundCommandReason,
+  backgroundCommandActivityForSessions,
+  listSessionBackgroundCommands,
+  insertManagedSessionBackgroundCommandInTransaction,
+  insertConnectedMachineSessionBackgroundCommandInTransaction,
+  claimConnectedMachineSessionBackgroundCommands,
+  recordConnectedMachineBackgroundCommandProof,
+  deferConnectedMachineBackgroundCommandReconciliation,
+  settleClaimedConnectedMachineBackgroundCommandWithMutation,
+  requestSessionBackgroundCommandCancellation,
+  requestSessionBackgroundCommandCancellationsInTransaction,
+  requestWorkspaceBackgroundCommandCancellationsInTransaction,
+  settleSessionBackgroundCommandForRetainedProcessInTransaction,
+  settleConnectedMachineSessionBackgroundCommandWithMutation,
+  getSessionBackgroundCommand,
+  observeSessionBackgroundCommandCompletion,
+  COMMAND_OUTPUT_DEFAULT_BYTES,
+  COMMAND_OUTPUT_MAX_BYTES,
+  COMMAND_OUTPUT_PAGE_ROWS,
+  parseCommandOutputCursor,
+  projectCommandOutputPage,
+  readSessionBackgroundCommandOutput,
+  SESSION_ANCESTRY_LIMIT,
+  SESSION_DISCOVERY_CONTROL_TITLE_MAX_CHARS,
+  SESSION_DISCOVERY_CONTROL_TARGET_LIMIT,
+  serializeEffectiveSessionControl,
+  SessionControlInvariantError,
+  SessionControlConflictError,
+  SessionCommandIdempotencyError,
+  AgentCommandAuthorityError,
+  assertAgentCommandAuthorityInTransaction,
+  canonicalSessionCommandHash,
+  WORKSPACE_CONTROL_REQUEST_LOCK_TIMEOUT_MS,
+  configureWorkspaceControlRequestLockTimeoutMs,
+  workspaceControlRequestLockTimeoutMs,
+  WorkspaceControlBusyError,
+  workspaceControlLockBudget,
+  lockWorkspaceInferenceControl,
+  lockWorkspaceInferenceControlForAdmission,
+  lockSessionEventWriteRows,
+  registerSessionTurnAttemptClaim,
+  assertSessionAuthoritySnapshot,
+  sessionAuthoritySnapshotMatchesSession,
+  sessionAuthoritySnapshotsEqual,
+  closeSessionTurnAttemptInTransaction,
+  evaluateSessionControls,
+  evaluateSessionWriteAdmissionControl,
+  evaluateSessionDiscoveryControls,
+  evaluateSessionControl,
+  reserveSessionPromptCommandReceipt,
+  lockSessionPromptCommandOperation,
+  getCompletedSessionPromptCommandReceipt,
+  reserveSessionCommandReceipt,
+  registerSessionWorkflowWakeInTransaction,
+  registerInternalUpdateWakeInTransaction,
+  updateSessionCommandReceiptResult,
+  mutateSessionControlInTransaction,
+  autoResumeSessionBranchInTransaction,
+  mutateWorkspaceControlInTransaction
+};
+//# sourceMappingURL=chunk-DUB3LUVM.js.map