@opengeni/db 0.23.0 → 0.26.0

package/dist/index.js

@@ -11,6 +11,7 @@ import {
   codexRotationSettings,
   codexSubscriptionCredentials,
   composerDrafts,
+  connectionDisconnectOperations,
   connections,
   connectorActionPolicies,
   connectorActionRequests,
@@ -104,6 +105,7 @@ import {
   workspaceInstructionPolicyActivationEvents,
   workspaceInstructionPolicyHeads,
   workspaceInstructionPolicyRevisions,
+  workspaceInstructionPolicySnapshots,
   workspaceMemberships,
   workspaceModelPolicies,
   workspacePacks,
@@ -111,7 +113,7 @@ import {
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces
-} from "./chunk-3UCHDMKG.js";
+} from "./chunk-7WTDI7Y3.js";
 import {
   migrate,
   runMigrations
@@ -131,7 +133,7 @@ import {
   inspectRuntimeDatabasePosture,
   provisionRoles,
   runtimeDatabaseReadyCheck
-} from "./chunk-L6ADMZHE.js";
+} from "./chunk-KW6U54V2.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/index.ts
@@ -144,7 +146,8 @@ import {
   canonicalModalCheckpointProviderBinding,
   decodeNativeSnapshotRef,
   parseWorkspaceArchiveDescriptor,
-  stableJson as stableJson3
+  stableJson as stableJson3,
+  MODEL_ATTACHMENT_REFS_FIELD
 } from "@opengeni/contracts";
 import {
   approvalIdentifier,
@@ -191,17 +194,17 @@ import {
   desc as desc8,
   eq as eq17,
   getTableColumns,
-  gt as gt4,
+  gt as gt5,
   gte as gte2,
   inArray as inArray11,
   isNotNull,
   ilike,
-  isNull as isNull5,
+  isNull as isNull6,
   lt as lt4,
   lte as lte2,
   ne,
   notInArray,
-  or as or4,
+  or as or6,
   sql as sql14
 } from "drizzle-orm";
 
@@ -1162,13 +1165,199 @@ async function closePendingSessionToolCallsInTransaction(tx, input) {
 }
 
 // src/session-control.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import {
   boundWorkspaceControlEvent,
   McpPersonalConnectionDelegations,
   workspaceControlUtf8Bytes
 } from "@opengeni/contracts";
-import { and as and4, eq as eq4, inArray, sql as sql2 } from "drizzle-orm";
+import { and as and5, eq as eq5, inArray, sql as sql3 } from "drizzle-orm";
+
+// src/session-realtime-mirror.ts
+import { createHash } from "crypto";
+import { and as and4, desc, eq as eq4, 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 = sanitizeEventPayload(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(
+    and4(
+      eq4(sessionRealtimeModes.accountId, input.accountId),
+      eq4(sessionRealtimeModes.workspaceId, input.workspaceId),
+      eq4(sessionRealtimeModes.sessionId, input.sessionId),
+      eq4(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(
+    and4(
+      eq4(sessionRealtimeEntries.realtimeId, mode.id),
+      eq4(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(eq4(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),
+    payload,
+    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.allowOther)}</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,
@@ -1239,7 +1428,7 @@ async function assertAgentCommandAuthorityInTransaction(db, input) {
   if (!lockedSessions.some((row) => row.id === input.targetSessionId)) {
     throw new SessionControlInvariantError(`Target session not found: ${input.targetSessionId}`);
   }
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     select
       attempt.id as "attemptId",
       attempt.state as "attemptState",
@@ -1281,7 +1470,7 @@ async function assertAgentCommandAuthorityInTransaction(db, input) {
     throw new AgentCommandAuthorityError("SELF_STEER", "An agent cannot steer its own session");
   }
   if (input.action !== "pause") return;
-  const ancestry = await db.execute(sql2`
+  const ancestry = await db.execute(sql3`
     with recursive caller_ancestry(id, parent_id, depth, path, cycle) as (
       select session.id, session.parent_session_id, 0, array[session.id], false
       from ${sessions} session
@@ -1333,17 +1522,17 @@ function canonicalize(value) {
   return value;
 }
 function canonicalSessionCommandHash(value) {
-  return createHash("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
+  return createHash2("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
 }
 function controlEtag(value) {
   return `sc1:${canonicalSessionCommandHash(value)}`;
 }
 function lockClause(mode) {
-  if (mode === "none") return sql2.empty();
-  return mode === "update" ? sql2.raw("for update") : sql2.raw("for share");
+  if (mode === "none") return sql3.empty();
+  return mode === "update" ? sql3.raw("for update") : sql3.raw("for share");
 }
 async function lockWorkspaceInferenceControl(db, workspaceId, mode) {
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     select
       workspace_id as "workspaceId",
       account_id as "accountId",
@@ -1370,27 +1559,27 @@ async function lockSessionEventWriteRows(db, input) {
   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(eq4(workspaces.id, input.workspaceId)).for("key share").limit(1);
+    const [lockedWorkspace] = await db.select().from(workspaces).where(eq5(workspaces.id, input.workspaceId)).for("key share").limit(1);
     workspace = lockedWorkspace ?? null;
   }
   const sessionIds = [...new Set(input.sessionIds ?? [])].sort();
   const sessions2 = sessionIds.length > 0 ? await db.select().from(sessions).where(
-    and4(
-      eq4(sessions.workspaceId, input.workspaceId),
+    and5(
+      eq5(sessions.workspaceId, input.workspaceId),
       inArray(sessions.id, sessionIds)
     )
   ).orderBy(sessions.id).for("update") : [];
   const turnIds = [...new Set(input.turnIds ?? [])].sort();
   const turns = turnIds.length > 0 ? await db.select().from(sessionTurns).where(
-    and4(
-      eq4(sessionTurns.workspaceId, input.workspaceId),
+    and5(
+      eq5(sessionTurns.workspaceId, input.workspaceId),
       inArray(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(
-    and4(
-      eq4(sessionTurnAttempts.workspaceId, input.workspaceId),
+    and5(
+      eq5(sessionTurnAttempts.workspaceId, input.workspaceId),
       inArray(sessionTurnAttempts.id, attemptIds)
     )
   ).orderBy(sessionTurnAttempts.id).for("update") : [];
@@ -1403,9 +1592,9 @@ async function registerSessionTurnAttemptClaim(db, input) {
   }).onConflictDoNothing({ target: sessionTurnAttempts.id }).returning();
   if (inserted) return inserted;
   const [existing] = await db.select().from(sessionTurnAttempts).where(
-    and4(
-      eq4(sessionTurnAttempts.workspaceId, input.workspaceId),
-      eq4(sessionTurnAttempts.id, input.id)
+    and5(
+      eq5(sessionTurnAttempts.workspaceId, input.workspaceId),
+      eq5(sessionTurnAttempts.id, input.id)
     )
   ).for("update").limit(1);
   if (!existing || existing.accountId !== input.accountId || existing.sessionId !== input.sessionId || existing.turnId !== input.turnId || existing.executionGeneration !== input.executionGeneration || existing.temporalWorkflowId !== input.temporalWorkflowId || existing.temporalWorkflowRunId !== input.temporalWorkflowRunId || existing.temporalActivityId !== input.temporalActivityId || JSON.stringify(existing.connectorActionPolicies) !== JSON.stringify(input.connectorActionPolicies) || existing.state === "closed") {
@@ -1417,9 +1606,9 @@ async function registerSessionTurnAttemptClaim(db, input) {
 }
 async function closeSessionTurnAttemptInTransaction(db, input) {
   const [attempt] = await db.select().from(sessionTurnAttempts).where(
-    and4(
-      eq4(sessionTurnAttempts.workspaceId, input.workspaceId),
-      eq4(sessionTurnAttempts.id, input.id)
+    and5(
+      eq5(sessionTurnAttempts.workspaceId, input.workspaceId),
+      eq5(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) {
@@ -1450,10 +1639,10 @@ async function closeSessionTurnAttemptInTransaction(db, input) {
     closedAt: now,
     updatedAt: now
   }).where(
-    and4(
-      eq4(sessionTurnAttempts.workspaceId, input.workspaceId),
-      eq4(sessionTurnAttempts.id, input.id),
-      sql2`${sessionTurnAttempts.state} in ('claimed', 'running')`
+    and5(
+      eq5(sessionTurnAttempts.workspaceId, input.workspaceId),
+      eq5(sessionTurnAttempts.id, input.id),
+      sql3`${sessionTurnAttempts.state} in ('claimed', 'running')`
     )
   ).returning({ id: sessionTurnAttempts.id });
   if (!closed) {
@@ -1465,14 +1654,14 @@ function targetValues(sessionIds) {
   if (sessionIds.length === 0) {
     throw new SessionControlInvariantError("At least one target session is required");
   }
-  return sql2.join(
-    sessionIds.map((id) => sql2`(${id}::uuid)`),
-    sql2`, `
+  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(sql2`
+  return await db.execute(sql3`
     with recursive targets(id) as (values ${targetValues(sessionIds)}),
     ancestry as (
       select
@@ -1535,7 +1724,7 @@ async function loadTargetAncestryRows(db, workspaceId, sessionIds) {
   `);
 }
 async function loadAncestryNodes(db, workspaceId, sessionIds) {
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     with recursive targets(id) as (values ${targetValues(sessionIds)}),
     ancestry_ids(id) as (
       select session.id
@@ -1728,7 +1917,7 @@ function projectEffectiveControl(workspace, targetId, rows, settlementAttempts)
   };
 }
 async function settlementAttemptCounts(db, workspaceId, sessionIds) {
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     with recursive targets(id) as (values ${targetValues(sessionIds)}),
     interruptions as (
       select
@@ -1875,7 +2064,7 @@ async function evaluateSessionDiscoveryControls(db, workspaceId, sessionIds) {
   if (workspace.workspaceState === "paused" && workspacePauseRevision === null) {
     throw new SessionControlInvariantError("Paused workspace is missing its pause revision");
   }
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     with recursive targets(id) as (values ${targetValues(uniqueIds)}),
     ancestry as (
       select
@@ -2042,22 +2231,22 @@ async function evaluateSessionControl(db, workspaceId, sessionId, options = {})
 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 === "goal_operation" ? and4(
-    eq4(sessionCommandReceipts.workspaceId, input.workspaceId),
-    eq4(sessionCommandReceipts.actorType, "agent_attempt"),
-    eq4(sessionCommandReceipts.action, input.action),
-    eq4(sessionCommandReceipts.targetSessionId, input.targetSessionId),
-    sql2`${sessionCommandReceipts.targetTurnId} is null`,
-    eq4(sessionCommandReceipts.operationKey, input.operationKey)
-  ) : and4(
-    eq4(sessionCommandReceipts.workspaceId, input.workspaceId),
-    eq4(sessionCommandReceipts.actorType, input.actor.type),
-    sql2`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
-    sql2`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
-    eq4(sessionCommandReceipts.action, input.action),
-    sql2`${sessionCommandReceipts.targetSessionId} is not distinct from ${input.targetSessionId}::uuid`,
-    sql2`${sessionCommandReceipts.targetTurnId} is not distinct from ${input.targetTurnId}::uuid`,
-    eq4(sessionCommandReceipts.operationKey, input.operationKey)
+  const identity = input.identityScope === "goal_operation" ? and5(
+    eq5(sessionCommandReceipts.workspaceId, input.workspaceId),
+    eq5(sessionCommandReceipts.actorType, "agent_attempt"),
+    eq5(sessionCommandReceipts.action, input.action),
+    eq5(sessionCommandReceipts.targetSessionId, input.targetSessionId),
+    sql3`${sessionCommandReceipts.targetTurnId} is null`,
+    eq5(sessionCommandReceipts.operationKey, input.operationKey)
+  ) : and5(
+    eq5(sessionCommandReceipts.workspaceId, input.workspaceId),
+    eq5(sessionCommandReceipts.actorType, input.actor.type),
+    sql3`${sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
+    sql3`${sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
+    eq5(sessionCommandReceipts.action, input.action),
+    sql3`${sessionCommandReceipts.targetSessionId} is not distinct from ${input.targetSessionId}::uuid`,
+    sql3`${sessionCommandReceipts.targetTurnId} is not distinct from ${input.targetTurnId}::uuid`,
+    eq5(sessionCommandReceipts.operationKey, input.operationKey)
   );
   const rows = await db.select().from(sessionCommandReceipts).where(identity).for("update");
   return rows[0] ?? null;
@@ -2108,9 +2297,9 @@ function nextRevision(workspace) {
 }
 async function advanceWorkspaceRevision(db, workspaceId, revision) {
   const rows = await db.update(workspaceInferenceControls).set({ revision, updatedAt: /* @__PURE__ */ new Date() }).where(
-    and4(
-      eq4(workspaceInferenceControls.workspaceId, workspaceId),
-      eq4(workspaceInferenceControls.revision, revision - 1)
+    and5(
+      eq5(workspaceInferenceControls.workspaceId, workspaceId),
+      eq5(workspaceInferenceControls.revision, revision - 1)
     )
   ).returning({ workspaceId: workspaceInferenceControls.workspaceId });
   if (rows.length !== 1) {
@@ -2120,7 +2309,7 @@ async function advanceWorkspaceRevision(db, workspaceId, revision) {
   }
 }
 async function registerContinuableWakes(db, input) {
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     with eligible as (
       select *
       from opengeni_private.list_continuable_sessions(
@@ -2162,7 +2351,7 @@ async function registerWorkspaceWakes(db, input) {
   });
 }
 async function registerInterruptionWakes(db, input) {
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     with eligible as (
       select distinct
         session.id as session_id,
@@ -2198,11 +2387,11 @@ async function registerInterruptionWakes(db, input) {
 }
 async function registerCancellationWakes(db, input) {
   if (input.sessionIds.length === 0) return 0;
-  const sessionIds = sql2.join(
-    input.sessionIds.map((id) => sql2`${id}::uuid`),
-    sql2`, `
+  const sessionIds = sql3.join(
+    input.sessionIds.map((id) => sql3`${id}::uuid`),
+    sql3`, `
   );
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     with eligible as (
       select
         session.id as session_id,
@@ -2244,7 +2433,7 @@ async function registerSessionWorkflowWakeInTransaction(db, input) {
     target: sessionWorkflowWakeOutbox.sessionId,
     set: {
       temporalWorkflowId: input.temporalWorkflowId,
-      wakeRevision: sql2`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
+      wakeRevision: sql3`${sessionWorkflowWakeOutbox.wakeRevision} + 1`,
       reason: input.reason,
       attempts: 0,
       nextAttemptAt: /* @__PURE__ */ new Date(),
@@ -2259,9 +2448,9 @@ async function registerSessionWorkflowWakeInTransaction(db, input) {
 }
 async function registerInternalUpdateWakeInTransaction(db, input) {
   const [existing] = await db.select().from(sessionWorkflowWakeOutbox).where(
-    and4(
-      eq4(sessionWorkflowWakeOutbox.workspaceId, input.workspaceId),
-      eq4(sessionWorkflowWakeOutbox.sessionId, input.sessionId)
+    and5(
+      eq5(sessionWorkflowWakeOutbox.workspaceId, input.workspaceId),
+      eq5(sessionWorkflowWakeOutbox.sessionId, input.sessionId)
     )
   ).for("update").limit(1);
   if (existing && existing.wakeRevision > existing.deliveredRevision) {
@@ -2271,7 +2460,7 @@ async function registerInternalUpdateWakeInTransaction(db, input) {
       nextAttemptAt: /* @__PURE__ */ new Date(),
       lastError: null,
       updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq4(sessionWorkflowWakeOutbox.sessionId, input.sessionId));
+    }).where(eq5(sessionWorkflowWakeOutbox.sessionId, input.sessionId));
     return { wakeRevision: existing.wakeRevision, shouldSignal: false };
   }
   return {
@@ -2283,7 +2472,7 @@ async function registerInternalUpdateWakeInTransaction(db, input) {
   };
 }
 async function interruptDescendantAttempts(db, input) {
-  const rows = await db.execute(sql2`
+  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
@@ -2331,7 +2520,7 @@ async function interruptDescendantAttempts(db, input) {
   return Number(rows[0]?.count ?? 0);
 }
 async function interruptWorkspaceAttempts(db, input) {
-  const rows = await db.execute(sql2`
+  const rows = await db.execute(sql3`
     with inserted as (
       insert into ${sessionAttemptInterruptions} (
         account_id, workspace_id, session_id, operation_id, attempt_id,
@@ -2358,12 +2547,12 @@ async function updateSessionCommandReceiptResult(db, receiptId, input) {
     ...input.draftRevision !== void 0 ? { appliedDraftRevision: input.draftRevision } : {},
     result: input.result,
     updatedAt: /* @__PURE__ */ new Date()
-  }).where(eq4(sessionCommandReceipts.id, receiptId)).returning();
+  }).where(eq5(sessionCommandReceipts.id, receiptId)).returning();
   if (!receipt) throw new SessionControlInvariantError("Command receipt disappeared");
   return receipt;
 }
 async function loadSessionSubtreeIds(db, workspaceId, rootSessionId) {
-  const rows = await db.execute(sql2`
+  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
@@ -2400,8 +2589,8 @@ var TERMINAL_CANCELLATION_LIVE_TURN_STATUSES = [
 ];
 async function loadCancellationTurnIds(db, workspaceId, sessionIds) {
   const rows = await db.select({ id: sessionTurns.id }).from(sessionTurns).where(
-    and4(
-      eq4(sessionTurns.workspaceId, workspaceId),
+    and5(
+      eq5(sessionTurns.workspaceId, workspaceId),
       inArray(sessionTurns.sessionId, sessionIds),
       inArray(sessionTurns.status, TERMINAL_CANCELLATION_LIVE_TURN_STATUSES)
     )
@@ -2420,10 +2609,10 @@ async function enqueueCancelledChildOutboxInTransaction(db, input) {
   let personalConnectionDelegations = [];
   if (input.rootSession.parentTurnId) {
     const [parentTurn] = await db.select({ delegations: sessionTurns.personalConnectionDelegations }).from(sessionTurns).where(
-      and4(
-        eq4(sessionTurns.workspaceId, input.workspaceId),
-        eq4(sessionTurns.sessionId, parentSessionId),
-        eq4(sessionTurns.id, input.rootSession.parentTurnId)
+      and5(
+        eq5(sessionTurns.workspaceId, input.workspaceId),
+        eq5(sessionTurns.sessionId, parentSessionId),
+        eq5(sessionTurns.id, input.rootSession.parentTurnId)
       )
     ).limit(1);
     if (parentTurn) {
@@ -2465,7 +2654,7 @@ async function enqueueCancelledChildOutboxInTransaction(db, input) {
   });
 }
 async function assertSessionBranchIsNotCancelled(db, workspaceId, sessionId) {
-  const rows = await db.execute(sql2`
+  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
@@ -2540,7 +2729,7 @@ async function cancelSessionSubtreeInTransaction(db, input) {
       activeAttemptId: null,
       cancelledBy: input.actor,
       cancelReason: input.reason ?? "session_cancelled",
-      version: sql2`${sessionTurns.version} + 1`,
+      version: sql3`${sessionTurns.version} + 1`,
       finishedAt: now,
       updatedAt: now
     }).where(inArray(sessionTurns.id, immediatelyCancelledTurnIds));
@@ -2551,29 +2740,30 @@ async function cancelSessionSubtreeInTransaction(db, input) {
       respondedAt: now,
       updatedAt: now
     }).where(
-      and4(
-        eq4(sessionHumanInputRequests.workspaceId, input.workspaceId),
+      and5(
+        eq5(sessionHumanInputRequests.workspaceId, input.workspaceId),
         inArray(sessionHumanInputRequests.turnId, immediatelyCancelledTurnIds),
-        eq4(sessionHumanInputRequests.status, "pending")
+        eq5(sessionHumanInputRequests.status, "pending")
       )
     ).returning({
       id: sessionHumanInputRequests.id,
       sessionId: sessionHumanInputRequests.sessionId,
-      turnId: sessionHumanInputRequests.turnId
+      turnId: sessionHumanInputRequests.turnId,
+      questions: sessionHumanInputRequests.questions
     });
     await db.update(codexCapacityWaiters).set({ status: "superseded", lastWakeReason: "session_cancelled", updatedAt: now }).where(
-      and4(
-        eq4(codexCapacityWaiters.workspaceId, input.workspaceId),
+      and5(
+        eq5(codexCapacityWaiters.workspaceId, input.workspaceId),
         inArray(codexCapacityWaiters.blockedTurnId, immediatelyCancelledTurnIds),
-        eq4(codexCapacityWaiters.status, "waiting")
+        eq5(codexCapacityWaiters.status, "waiting")
       )
     );
   }
   const cancelledSystemUpdates = await db.update(sessionSystemUpdates).set({ state: "cancelled" }).where(
-    and4(
-      eq4(sessionSystemUpdates.workspaceId, input.workspaceId),
+    and5(
+      eq5(sessionSystemUpdates.workspaceId, input.workspaceId),
       inArray(sessionSystemUpdates.sessionId, input.sessionIds),
-      eq4(sessionSystemUpdates.state, "pending")
+      eq5(sessionSystemUpdates.state, "pending")
     )
   ).returning({
     id: sessionSystemUpdates.id,
@@ -2674,19 +2864,51 @@ async function cancelSessionSubtreeInTransaction(db, input) {
     }
     const inserted = eventValues.length > 0 ? await db.insert(sessionEvents).values(eventValues).returning({
       id: sessionEvents.id,
-      sequence: sessionEvents.sequence
+      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: sql2`${sessions.queueVersion} + 1`,
+      queueVersion: sql3`${sessions.queueVersion} + 1`,
       queueHeadPosition: 0,
       queueTailPosition: 0,
       lastSequence: sequence,
       updatedAt: now
     }).where(
-      and4(eq4(sessions.workspaceId, input.workspaceId), eq4(sessions.id, session.id))
+      and5(eq5(sessions.workspaceId, input.workspaceId), eq5(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);
@@ -2810,9 +3032,9 @@ async function mutateSessionControlInTransaction(db, input) {
       updatedAt: /* @__PURE__ */ new Date()
     }
   ).where(
-    and4(
-      eq4(sessions.workspaceId, input.workspaceId),
-      input.action === "cancel" ? inArray(sessions.id, cancellationSessionIds) : eq4(sessions.id, input.sessionId)
+    and5(
+      eq5(sessions.workspaceId, input.workspaceId),
+      input.action === "cancel" ? inArray(sessions.id, cancellationSessionIds) : eq5(sessions.id, input.sessionId)
     )
   ).returning({
     id: sessions.id,
@@ -2869,7 +3091,7 @@ async function mutateSessionControlInTransaction(db, input) {
   }).returning({ id: sessionEvents.id });
   if (!controlEvent)
     throw new SessionControlInvariantError("Session control event was not inserted");
-  await db.update(sessions).set({ lastSequence: updated.lastSequence + 1, updatedAt: /* @__PURE__ */ new Date() }).where(eq4(sessions.id, input.sessionId));
+  await db.update(sessions).set({ lastSequence: updated.lastSequence + 1, updatedAt: /* @__PURE__ */ new Date() }).where(eq5(sessions.id, input.sessionId));
   await db.insert(auditEvents).values({
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -2963,9 +3185,9 @@ async function autoResumeSessionBranchInTransaction(db, input) {
     directControlChangedAt: /* @__PURE__ */ new Date(),
     updatedAt: /* @__PURE__ */ new Date()
   }).where(
-    and4(
-      eq4(sessions.workspaceId, input.workspaceId),
-      eq4(sessions.id, input.sessionId)
+    and5(
+      eq5(sessions.workspaceId, input.workspaceId),
+      eq5(sessions.id, input.sessionId)
     )
   );
   const workspaceControlEventId = await insertWorkspaceControlEventInTransaction(db, {
@@ -3035,9 +3257,9 @@ async function mutateWorkspaceControlInTransaction(db, input) {
     changedAt: /* @__PURE__ */ new Date(),
     updatedAt: /* @__PURE__ */ new Date()
   }).where(
-    and4(
-      eq4(workspaceInferenceControls.workspaceId, input.workspaceId),
-      eq4(workspaceInferenceControls.revision, currentRevision)
+    and5(
+      eq5(workspaceInferenceControls.workspaceId, input.workspaceId),
+      eq5(workspaceInferenceControls.revision, currentRevision)
     )
   ).returning({ workspaceId: workspaceInferenceControls.workspaceId });
   if (!updated) {
@@ -3114,7 +3336,7 @@ async function insertWorkspaceControlEventInTransaction(db, input) {
 
 // src/session-realtime.ts
 import { createHash as createHash4, timingSafeEqual } from "crypto";
-import { and as and9, asc as asc4, eq as eq9, inArray as inArray4 } from "drizzle-orm";
+import { and as and9, asc as asc4, eq as eq9, gt as gt3, inArray as inArray4, isNull as isNull2, or } from "drizzle-orm";
 
 // src/session-realtime-context.ts
 import { createHash as createHash3 } from "crypto";
@@ -3134,115 +3356,17 @@ import {
 import { and as and7, asc as asc2, eq as eq7, inArray as inArray2, sql as sql4 } from "drizzle-orm";
 
 // src/session-realtime-state.ts
-import { and as and5, eq as eq5, gt } from "drizzle-orm";
+import { and as and6, eq as eq6, gt as gt2 } from "drizzle-orm";
 async function sessionRealtimeIsActiveInTransaction(db, workspaceId, sessionId, now = /* @__PURE__ */ new Date()) {
   const [row] = await db.select({ id: sessionRealtimeModes.id }).from(sessionRealtimeModes).where(
-    and5(
-      eq5(sessionRealtimeModes.workspaceId, workspaceId),
-      eq5(sessionRealtimeModes.sessionId, sessionId),
-      eq5(sessionRealtimeModes.state, "active"),
-      gt(sessionRealtimeModes.leaseExpiresAt, now)
-    )
-  ).limit(1);
-  return Boolean(row);
-}
-
-// src/session-realtime-mirror.ts
-import { createHash as createHash2 } from "crypto";
-import { and as and6, desc, eq as eq6, gt as gt2, sql as sql3 } 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 = createHash2("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 = sanitizeEventPayload(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(
     and6(
-      eq6(sessionRealtimeModes.accountId, input.accountId),
-      eq6(sessionRealtimeModes.workspaceId, input.workspaceId),
-      eq6(sessionRealtimeModes.sessionId, input.sessionId),
+      eq6(sessionRealtimeModes.workspaceId, workspaceId),
+      eq6(sessionRealtimeModes.sessionId, sessionId),
       eq6(sessionRealtimeModes.state, "active"),
       gt2(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(
-    and6(
-      eq6(sessionRealtimeEntries.realtimeId, mode.id),
-      eq6(sessionRealtimeEntries.operationId, operationId)
-    )
   ).limit(1);
-  if (existing) return { entry: existing, replay: true };
-  const [sequenceRow] = await db.select({ next: sql3`coalesce(max(${sessionRealtimeEntries.sequence}), 0) + 1` }).from(sessionRealtimeEntries).where(eq6(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),
-    payload,
-    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 escapeXmlText(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+  return Boolean(row);
 }
 
 // src/session-queue-commands.ts
@@ -3370,10 +3494,13 @@ async function supersedeSessionCurrentDirectionInTransaction(db, input) {
       eq7(sessionHumanInputRequests.turnId, current.id),
       eq7(sessionHumanInputRequests.status, "pending")
     )
-  ).returning({ id: sessionHumanInputRequests.id });
+  ).returning({
+    id: sessionHumanInputRequests.id,
+    questions: sessionHumanInputRequests.questions
+  });
   let lastSequence = closedTools.sequence;
   if (cancelledHumanInputs.length > 0) {
-    await db.insert(sessionEvents).values(
+    const cancelledHumanInputEvents = await db.insert(sessionEvents).values(
       cancelledHumanInputs.map((request) => ({
         accountId: input.accountId,
         workspaceId: input.workspaceId,
@@ -3386,7 +3513,33 @@ async function supersedeSessionCurrentDirectionInTransaction(db, input) {
         payload: { requestId: request.id, response: { outcome: "cancelled" } },
         occurredAt: now
       }))
-    );
+    ).returning();
+    const requestsById = new Map(cancelledHumanInputs.map((request) => [request.id, request]));
+    for (const event of cancelledHumanInputEvents) {
+      const payload = event.payload;
+      const request = typeof payload.requestId === "string" ? requestsById.get(payload.requestId) : null;
+      if (!request) continue;
+      await mirrorSessionRealtimeContextInTransaction(db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        sourceKind: "human_input_response",
+        sourceId: event.id,
+        turnId: current.id,
+        channel: null,
+        text: renderRealtimeHumanInputResponseContext({
+          requestId: request.id,
+          questions: request.questions,
+          response: { outcome: "cancelled" }
+        }),
+        payload: {
+          requestId: request.id,
+          outcome: "cancelled",
+          sourceEventId: event.id
+        },
+        now
+      });
+    }
   }
   await db.update(sessionTurns).set({
     status: "superseded",
@@ -5435,6 +5588,46 @@ async function beginSessionRealtimeInTransaction(db, input) {
     now
   );
   eventIds.push(event.id);
+  const pendingHumanInputs = await db.select({
+    id: sessionHumanInputRequests.id,
+    turnId: sessionHumanInputRequests.turnId,
+    questions: sessionHumanInputRequests.questions,
+    allowSkip: sessionHumanInputRequests.allowSkip,
+    expiresAt: sessionHumanInputRequests.expiresAt
+  }).from(sessionHumanInputRequests).where(
+    and9(
+      eq9(sessionHumanInputRequests.accountId, input.accountId),
+      eq9(sessionHumanInputRequests.workspaceId, input.workspaceId),
+      eq9(sessionHumanInputRequests.sessionId, input.sessionId),
+      eq9(sessionHumanInputRequests.status, "pending"),
+      or(
+        isNull2(sessionHumanInputRequests.expiresAt),
+        gt3(sessionHumanInputRequests.expiresAt, now)
+      )
+    )
+  ).orderBy(
+    asc4(sessionHumanInputRequests.createdAt),
+    asc4(sessionHumanInputRequests.id)
+  );
+  if (pendingHumanInputs.length > 0) {
+    const sourceTurnIds = new Set(pendingHumanInputs.map((request) => request.turnId));
+    await mirrorSessionRealtimeContextInTransaction(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      sourceKind: "human_input_request",
+      sourceId: `startup:${pendingHumanInputs.map((request) => request.id).join(":")}`,
+      turnId: sourceTurnIds.size === 1 ? pendingHumanInputs[0].turnId : null,
+      channel: "speakable",
+      text: renderRealtimeHumanInputRequestContext({ requests: pendingHumanInputs }),
+      payload: {
+        status: "waiting_for_user",
+        requestIds: pendingHumanInputs.map((request) => request.id),
+        trigger: "realtime_start"
+      },
+      now
+    });
+  }
   return {
     mode: mapRealtimeMode(row),
     replay: false,
@@ -5566,7 +5759,7 @@ async function settleExpiredSessionRealtimeInTransaction(db, session, now = /* @
 // src/session-realtime-ledger.ts
 import { createHash as createHash6 } from "crypto";
 import { LatencyMode, ReasoningEffort as ReasoningEffort2 } from "@opengeni/contracts";
-import { and as and11, asc as asc5, desc as desc3, eq as eq11, inArray as inArray6, isNull as isNull2, or, sql as sql7 } from "drizzle-orm";
+import { and as and11, asc as asc5, desc as desc3, eq as eq11, inArray as inArray6, isNull as isNull3, or as or2, sql as sql7 } from "drizzle-orm";
 
 // src/session-realtime-terminal.ts
 import { createHash as createHash5 } from "crypto";
@@ -6016,7 +6209,7 @@ async function claimSessionRealtimeConnectionInTransaction(db, input) {
     and11(
       eq11(sessionRealtimeEntries.realtimeId, input.realtimeId),
       eq11(sessionRealtimeEntries.direction, "provider_out"),
-      isNull2(sessionRealtimeEntries.providerAckedAt)
+      isNull3(sessionRealtimeEntries.providerAckedAt)
     )
   ).orderBy(asc5(sessionRealtimeEntries.sequence)).limit(SESSION_REALTIME_STARTUP_MAX_ENTRIES);
   const startupFenceSequence = startupEntries.at(-1)?.sequence ?? 0;
@@ -6048,7 +6241,7 @@ async function startupEntriesForConnection(db, connection) {
     and11(
       eq11(sessionRealtimeEntries.realtimeId, connection.realtimeId),
       eq11(sessionRealtimeEntries.direction, "provider_out"),
-      isNull2(sessionRealtimeEntries.providerAckedAt),
+      isNull3(sessionRealtimeEntries.providerAckedAt),
       sql7`${sessionRealtimeEntries.sequence} <= ${connection.startupFenceSequence}`
     )
   ).orderBy(asc5(sessionRealtimeEntries.sequence)).limit(SESSION_REALTIME_STARTUP_MAX_ENTRIES);
@@ -6470,7 +6663,7 @@ async function materializeRealtimeUpdates(db, input, accountId, allocateSequence
       eq11(sessionSystemUpdates.sessionId, input.sessionId),
       inArray6(sessionSystemUpdates.state, ["pending", "deferred"]),
       inArray6(sessionSystemUpdates.kind, ["agent_message", "child_terminal_result"]),
-      isNull2(sessionRealtimeEntries.id)
+      isNull3(sessionRealtimeEntries.id)
     )
   ).orderBy(asc5(sessionSystemUpdates.createdAt), asc5(sessionSystemUpdates.id)).limit(SESSION_REALTIME_LEDGER_MAX_OUTBOUND);
   const updates = rows.map(({ update }) => update);
@@ -6579,7 +6772,7 @@ async function syncSessionRealtimeLedgerInTransaction(db, input, hooks = {}) {
       }).where(
         and11(
           eq11(sessionRealtimeConnections.id, connection.id),
-          isNull2(sessionRealtimeConnections.startupAcknowledgedAt)
+          isNull3(sessionRealtimeConnections.startupAcknowledgedAt)
         )
       ).returning({ id: sessionRealtimeConnections.id });
       if (!acknowledged) {
@@ -6616,7 +6809,7 @@ async function syncSessionRealtimeLedgerInTransaction(db, input, hooks = {}) {
     const [existing] = await db.select().from(sessionRealtimeEntries).where(
       and11(
         eq11(sessionRealtimeEntries.realtimeId, input.realtimeId),
-        incoming.kind === "delegation_call" && incoming.delegationItemId ? or(
+        incoming.kind === "delegation_call" && incoming.delegationItemId ? or2(
           eq11(sessionRealtimeEntries.operationId, incoming.operationId),
           and11(
             eq11(sessionRealtimeEntries.kind, "delegation_call"),
@@ -6695,7 +6888,7 @@ async function syncSessionRealtimeLedgerInTransaction(db, input, hooks = {}) {
         eq11(sessionRealtimeEntries.sessionId, input.sessionId),
         eq11(sessionRealtimeEntries.realtimeId, input.realtimeId),
         eq11(sessionRealtimeEntries.direction, "provider_out"),
-        isNull2(sessionRealtimeEntries.clientAckedAt),
+        isNull3(sessionRealtimeEntries.clientAckedAt),
         sql7`${sessionRealtimeEntries.sequence} <= ${clientAck}`
       )
     );
@@ -6730,7 +6923,7 @@ async function syncSessionRealtimeLedgerInTransaction(db, input, hooks = {}) {
           sessionRealtimeEntries.id,
           ackable.map((entry) => entry.id)
         ),
-        isNull2(sessionRealtimeEntries.providerAckedAt)
+        isNull3(sessionRealtimeEntries.providerAckedAt)
       )
     );
   }
@@ -6740,7 +6933,7 @@ async function syncSessionRealtimeLedgerInTransaction(db, input, hooks = {}) {
       eq11(sessionRealtimeEntries.sessionId, input.sessionId),
       eq11(sessionRealtimeEntries.realtimeId, input.realtimeId),
       eq11(sessionRealtimeEntries.direction, "provider_out"),
-      isNull2(sessionRealtimeEntries.providerAckedAt)
+      isNull3(sessionRealtimeEntries.providerAckedAt)
     )
   ).orderBy(
     sql7`case when ${sessionRealtimeEntries.clientAckedAt} is null then 0 else 1 end`,
@@ -7300,13 +7493,14 @@ function renderMemoryEntry(record) {
 import { sql as sql15 } from "drizzle-orm";
 
 // src/workspace-instruction-policies.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash8, randomUUID } from "crypto";
 import {
+  PreferenceRegistrySnapshot,
   ResolvedWorkspaceInstructionPolicySnapshot,
   WORKSPACE_INSTRUCTION_POLICY_CONTENT_MAX_CHARS,
   WorkspaceInstructionPolicySnapshot
 } from "@opengeni/contracts";
-import { and as and12, asc as asc6, desc as desc4, eq as eq12, inArray as inArray7, isNull as isNull3, lt, sql as sql8 } from "drizzle-orm";
+import { and as and12, asc as asc6, desc as desc4, eq as eq12, inArray as inArray7, isNull as isNull4, lt, or as or3, sql as sql8 } from "drizzle-orm";
 var WorkspaceInstructionPolicyConflictError = class extends Error {
   constructor(currentHead) {
     super("The active workspace instruction policy changed in another request");
@@ -7315,6 +7509,13 @@ var WorkspaceInstructionPolicyConflictError = class extends Error {
   name = "WorkspaceInstructionPolicyConflictError";
   code = "WORKSPACE_INSTRUCTION_POLICY_CONFLICT";
 };
+var WorkspaceInstructionPolicyOperationReuseError = class extends Error {
+  name = "WorkspaceInstructionPolicyOperationReuseError";
+  code = "WORKSPACE_INSTRUCTION_POLICY_OPERATION_REUSED";
+  constructor() {
+    super("The workspace instruction-policy operation id was already used for another request");
+  }
+};
 var WorkspaceInstructionPolicyNotFoundError = class extends Error {
   name = "WorkspaceInstructionPolicyNotFoundError";
   constructor(message = "Workspace instruction-policy revision was not found") {
@@ -7336,12 +7537,169 @@ var WorkspaceInstructionPolicySnapshotAuthorityError = class extends Error {
 function contentHash(content) {
   return createHash8("sha256").update(content, "utf8").digest("hex");
 }
+function hasOwnField(value, field) {
+  return Object.prototype.hasOwnProperty.call(value, field);
+}
+function operationRequestFingerprint(operation, fields) {
+  const canonicalRequest = JSON.stringify([
+    "workspace_instruction_policy_operation",
+    1,
+    operation,
+    fields
+  ]);
+  return createHash8("sha256").update(canonicalRequest, "utf8").digest("hex");
+}
+function draftRequestFingerprint(input) {
+  return operationRequestFingerprint("create_draft", [
+    ["accountId", true, input.accountId],
+    ["workspaceId", true, input.workspaceId],
+    ["kind", true, input.kind],
+    ["scope", true, input.scope],
+    ["roleKey", true, input.roleKey],
+    ["content", true, input.content],
+    ["provenanceSource", true, input.provenanceSource],
+    ["provenanceSourceId", true, input.provenanceSourceId],
+    ["supersedesRevisionId", true, input.supersedesRevisionId],
+    ["createdBySubjectId", true, input.createdBySubjectId]
+  ]);
+}
+function importLegacyRequestFingerprint(input) {
+  return operationRequestFingerprint("import_legacy", [
+    ["accountId", true, input.accountId],
+    ["workspaceId", true, input.workspaceId],
+    ["createdBySubjectId", true, input.createdBySubjectId],
+    ["supersedesRevisionId", true, input.supersedesRevisionId]
+  ]);
+}
+function activeRevisionRequestFingerprint(input) {
+  const expectedCurrentRevisionIdPresent = hasOwnField(input, "expectedCurrentRevisionId");
+  const expectedActivationVersionPresent = hasOwnField(input, "expectedActivationVersion");
+  return operationRequestFingerprint(`change_active_revision:${input.type}`, [
+    ["accountId", true, input.accountId],
+    ["workspaceId", true, input.workspaceId],
+    ["targetRevisionId", true, input.targetRevisionId],
+    [
+      "expectedCurrentRevisionId",
+      expectedCurrentRevisionIdPresent,
+      input.expectedCurrentRevisionId ?? null
+    ],
+    [
+      "expectedActivationVersion",
+      expectedActivationVersionPresent,
+      input.expectedActivationVersion ?? null
+    ],
+    ["actorSubjectId", true, input.actorSubjectId],
+    ["reason", true, input.reason]
+  ]);
+}
 function iso(value) {
   return (value instanceof Date ? value : new Date(value)).toISOString();
 }
+async function getWorkspaceStateAcceptedAttemptGovernance(db, input) {
+  return await withWorkspaceSubjectRls(db, input.workspaceId, input.subjectId, async (scopedDb) => {
+    const initiatingSubject = sql8`coalesce(
+        ${sessionTurns.initiatingHumanSubjectId},
+        case when ${sessionTurns.initiatorKind} = 'subject'
+          then ${sessionTurns.initiatorSubjectId}
+        end
+      )`;
+    const [attempt] = await scopedDb.select({
+      attemptId: sessionTurnAttempts.id,
+      executionGeneration: sessionTurnAttempts.executionGeneration,
+      acceptedAt: sessionTurns.createdAt
+    }).from(sessionTurnAttempts).innerJoin(
+      sessionTurns,
+      and12(
+        eq12(sessionTurns.accountId, sessionTurnAttempts.accountId),
+        eq12(sessionTurns.workspaceId, sessionTurnAttempts.workspaceId),
+        eq12(sessionTurns.sessionId, sessionTurnAttempts.sessionId),
+        eq12(sessionTurns.id, sessionTurnAttempts.turnId)
+      )
+    ).where(
+      and12(
+        eq12(sessionTurnAttempts.accountId, input.accountId),
+        eq12(sessionTurnAttempts.workspaceId, input.workspaceId),
+        eq12(sessionTurnAttempts.id, input.attemptId),
+        eq12(initiatingSubject, input.subjectId)
+      )
+    ).limit(1);
+    if (!attempt) return null;
+    const [policyRows, preferenceRows] = await Promise.all([
+      scopedDb.select().from(workspaceInstructionPolicySnapshots).where(
+        and12(
+          eq12(workspaceInstructionPolicySnapshots.accountId, input.accountId),
+          eq12(workspaceInstructionPolicySnapshots.workspaceId, input.workspaceId),
+          eq12(workspaceInstructionPolicySnapshots.attemptId, input.attemptId),
+          eq12(
+            workspaceInstructionPolicySnapshots.executionGeneration,
+            attempt.executionGeneration
+          )
+        )
+      ).limit(1),
+      scopedDb.select().from(preferenceRegistrySnapshots).where(
+        and12(
+          eq12(preferenceRegistrySnapshots.accountId, input.accountId),
+          eq12(preferenceRegistrySnapshots.workspaceId, input.workspaceId),
+          eq12(preferenceRegistrySnapshots.attemptId, input.attemptId),
+          eq12(preferenceRegistrySnapshots.executionGeneration, attempt.executionGeneration),
+          eq12(preferenceRegistrySnapshots.initiatingHumanSubjectId, input.subjectId)
+        )
+      ).limit(1)
+    ]);
+    const policyRow = policyRows[0] ?? null;
+    const preferenceRow = preferenceRows[0] ?? null;
+    return {
+      attemptId: attempt.attemptId,
+      executionGeneration: attempt.executionGeneration,
+      acceptedAt: iso(attempt.acceptedAt),
+      policySnapshot: policyRow ? WorkspaceInstructionPolicySnapshot.parse({
+        id: policyRow.id,
+        workspaceId: policyRow.workspaceId,
+        sessionId: policyRow.sessionId,
+        turnId: policyRow.turnId,
+        attemptId: policyRow.attemptId,
+        executionGeneration: policyRow.executionGeneration,
+        policyRole: policyRow.policyRole,
+        roleSource: policyRow.roleSource,
+        entries: policyRow.entries,
+        entryHash: policyRow.entryHash,
+        createdAt: iso(policyRow.createdAt)
+      }) : null,
+      preferenceSnapshot: preferenceRow ? (() => {
+        const snapshot = PreferenceRegistrySnapshot.parse({
+          id: preferenceRow.id,
+          workspaceId: preferenceRow.workspaceId,
+          sessionId: preferenceRow.sessionId,
+          turnId: preferenceRow.turnId,
+          attemptId: preferenceRow.attemptId,
+          executionGeneration: preferenceRow.executionGeneration,
+          initiatingHumanSubjectId: preferenceRow.initiatingHumanSubjectId,
+          descriptorHash: preferenceRow.descriptorHash,
+          descriptors: preferenceRow.descriptors,
+          truncated: preferenceRow.truncated,
+          createdAt: iso(preferenceRow.createdAt)
+        });
+        return {
+          id: snapshot.id,
+          descriptorHash: snapshot.descriptorHash,
+          descriptors: snapshot.descriptors.map((descriptor) => ({
+            id: descriptor.id,
+            revisionId: descriptor.revisionId,
+            contentHash: descriptor.contentHash,
+            activeVersion: descriptor.activeVersion,
+            scope: descriptor.scope
+          })),
+          truncated: snapshot.truncated,
+          createdAt: snapshot.createdAt
+        };
+      })() : null
+    };
+  });
+}
 function revisionFromRow(row) {
   return {
     id: row.id,
+    operationId: row.operationId ?? row.id,
     accountId: row.accountId,
     workspaceId: row.workspaceId,
     revision: row.revision,
@@ -7375,6 +7733,7 @@ function headFromRow(row) {
 function eventFromRow(row) {
   return {
     id: row.id,
+    operationId: row.operationId ?? row.id,
     accountId: row.accountId,
     workspaceId: row.workspaceId,
     kind: row.kind,
@@ -7397,12 +7756,25 @@ function eventFromRow(row) {
     createdAt: iso(row.createdAt)
   };
 }
+function headFromEventRow(row) {
+  return {
+    workspaceId: row.workspaceId,
+    kind: row.kind,
+    scope: row.scope,
+    roleKey: row.roleKey,
+    revisionId: row.newRevisionId,
+    revision: row.newRevision,
+    contentHash: row.newContentHash,
+    activationVersion: row.activationVersion,
+    activatedAt: iso(row.createdAt)
+  };
+}
 function headTargetConditions(workspaceId, target) {
   return [
     eq12(workspaceInstructionPolicyHeads.workspaceId, workspaceId),
     eq12(workspaceInstructionPolicyHeads.kind, target.kind),
     eq12(workspaceInstructionPolicyHeads.scope, target.scope),
-    target.roleKey === null ? isNull3(workspaceInstructionPolicyHeads.roleKey) : eq12(workspaceInstructionPolicyHeads.roleKey, target.roleKey)
+    target.roleKey === null ? isNull4(workspaceInstructionPolicyHeads.roleKey) : eq12(workspaceInstructionPolicyHeads.roleKey, target.roleKey)
   ];
 }
 function eventTargetConditions(workspaceId, target) {
@@ -7410,7 +7782,7 @@ function eventTargetConditions(workspaceId, target) {
     eq12(workspaceInstructionPolicyActivationEvents.workspaceId, workspaceId),
     eq12(workspaceInstructionPolicyActivationEvents.kind, target.kind),
     eq12(workspaceInstructionPolicyActivationEvents.scope, target.scope),
-    target.roleKey === null ? isNull3(workspaceInstructionPolicyActivationEvents.roleKey) : eq12(workspaceInstructionPolicyActivationEvents.roleKey, target.roleKey)
+    target.roleKey === null ? isNull4(workspaceInstructionPolicyActivationEvents.roleKey) : eq12(workspaceInstructionPolicyActivationEvents.roleKey, target.roleKey)
   ];
 }
 async function lockWorkspace(db, input) {
@@ -7434,6 +7806,36 @@ async function getRevisionInTransaction(db, workspaceId, revisionId) {
   ).limit(1);
   return row ?? null;
 }
+async function getRevisionByOperationInTransaction(db, workspaceId, operationId) {
+  const [row] = await db.select().from(workspaceInstructionPolicyRevisions).where(
+    and12(
+      eq12(workspaceInstructionPolicyRevisions.workspaceId, workspaceId),
+      or3(
+        eq12(workspaceInstructionPolicyRevisions.operationId, operationId),
+        and12(
+          isNull4(workspaceInstructionPolicyRevisions.operationId),
+          eq12(workspaceInstructionPolicyRevisions.id, operationId)
+        )
+      )
+    )
+  ).limit(1);
+  return row ?? null;
+}
+async function getEventByOperationInTransaction(db, workspaceId, operationId) {
+  const [row] = await db.select().from(workspaceInstructionPolicyActivationEvents).where(
+    and12(
+      eq12(workspaceInstructionPolicyActivationEvents.workspaceId, workspaceId),
+      or3(
+        eq12(workspaceInstructionPolicyActivationEvents.operationId, operationId),
+        and12(
+          isNull4(workspaceInstructionPolicyActivationEvents.operationId),
+          eq12(workspaceInstructionPolicyActivationEvents.id, operationId)
+        )
+      )
+    )
+  ).limit(1);
+  return row ?? null;
+}
 async function getHeadInTransaction(db, workspaceId, target) {
   const [row] = await db.select().from(workspaceInstructionPolicyHeads).where(and12(...headTargetConditions(workspaceId, target))).for("update").limit(1);
   return row ?? null;
@@ -7441,7 +7843,24 @@ async function getHeadInTransaction(db, workspaceId, target) {
 function sameTarget(left, right) {
   return left.kind === right.kind && left.scope === right.scope && left.roleKey === right.roleKey;
 }
+function draftReceiptMatches(row, input) {
+  return row.createdBySubjectId === input.createdBySubjectId && row.kind === input.kind && row.scope === input.scope && row.roleKey === input.roleKey && row.content === input.content && row.provenanceSource === input.provenanceSource && row.provenanceSourceId === input.provenanceSourceId && row.supersedesRevisionId === input.supersedesRevisionId;
+}
 async function createDraftInTransaction(db, input) {
+  if (await getEventByOperationInTransaction(db, input.workspaceId, input.operationId)) {
+    throw new WorkspaceInstructionPolicyOperationReuseError();
+  }
+  const existing = await getRevisionByOperationInTransaction(
+    db,
+    input.workspaceId,
+    input.operationId
+  );
+  if (existing) {
+    if (existing.requestFingerprint === null ? !draftReceiptMatches(existing, input) : existing.requestFingerprint !== input.requestFingerprint) {
+      throw new WorkspaceInstructionPolicyOperationReuseError();
+    }
+    return revisionFromRow(existing);
+  }
   if (input.supersedesRevisionId !== null) {
     const superseded = await getRevisionInTransaction(
       db,
@@ -7455,6 +7874,8 @@ async function createDraftInTransaction(db, input) {
     }
   }
   const [created] = await db.insert(workspaceInstructionPolicyRevisions).values({
+    operationId: input.operationId,
+    requestFingerprint: input.requestFingerprint,
     accountId: input.accountId,
     workspaceId: input.workspaceId,
     kind: input.kind,
@@ -7471,21 +7892,42 @@ async function createDraftInTransaction(db, input) {
   return revisionFromRow(created);
 }
 async function createWorkspaceInstructionPolicyDraft(db, input) {
+  const request = { ...input, operationId: input.operationId ?? randomUUID() };
+  const normalized = { ...request, requestFingerprint: draftRequestFingerprint(request) };
   return await withRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
     async (scopedDb) => {
       await lockWorkspace(scopedDb, input);
-      return await createDraftInTransaction(scopedDb, input);
+      return await createDraftInTransaction(scopedDb, normalized);
     }
   );
 }
 async function importLegacyWorkspaceInstructionPolicyDraft(db, input) {
+  const request = { ...input, operationId: input.operationId ?? randomUUID() };
+  const normalized = {
+    ...request,
+    requestFingerprint: importLegacyRequestFingerprint(request)
+  };
   return await withRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
     async (scopedDb) => {
       const workspace = await lockWorkspace(scopedDb, input);
+      if (await getEventByOperationInTransaction(scopedDb, input.workspaceId, normalized.operationId)) {
+        throw new WorkspaceInstructionPolicyOperationReuseError();
+      }
+      const existing = await getRevisionByOperationInTransaction(
+        scopedDb,
+        input.workspaceId,
+        normalized.operationId
+      );
+      if (existing) {
+        if (existing.requestFingerprint === null ? existing.createdBySubjectId !== input.createdBySubjectId || existing.kind !== "charter" || existing.scope !== "global" || existing.roleKey !== null || existing.provenanceSource !== "legacy_import" || existing.provenanceSourceId !== "workspaces.agent_instructions" || existing.supersedesRevisionId !== input.supersedesRevisionId : existing.requestFingerprint !== normalized.requestFingerprint) {
+          throw new WorkspaceInstructionPolicyOperationReuseError();
+        }
+        return revisionFromRow(existing);
+      }
       if (workspace.agentInstructions === null) {
         throw new WorkspaceInstructionPolicyLegacyUnavailableError();
       }
@@ -7495,7 +7937,7 @@ async function importLegacyWorkspaceInstructionPolicyDraft(db, input) {
         );
       }
       return await createDraftInTransaction(scopedDb, {
-        ...input,
+        ...normalized,
         kind: "charter",
         scope: "global",
         roleKey: null,
@@ -7518,7 +7960,7 @@ function listFilterConditions(workspaceId, query) {
   }
   if (query.roleKey !== void 0) {
     conditions.push(
-      query.roleKey === null ? isNull3(workspaceInstructionPolicyRevisions.roleKey) : eq12(workspaceInstructionPolicyRevisions.roleKey, query.roleKey)
+      query.roleKey === null ? isNull4(workspaceInstructionPolicyRevisions.roleKey) : eq12(workspaceInstructionPolicyRevisions.roleKey, query.roleKey)
     );
   }
   if (query.afterRevision !== void 0) {
@@ -7619,11 +8061,27 @@ async function diffWorkspaceInstructionPolicyRevisions(db, workspaceId, input) {
   });
 }
 async function changeActiveRevision(db, input) {
+  const requestFingerprint = activeRevisionRequestFingerprint(input);
   return await withRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
     async (scopedDb) => {
       await lockWorkspace(scopedDb, input);
+      if (await getRevisionByOperationInTransaction(scopedDb, input.workspaceId, input.operationId)) {
+        throw new WorkspaceInstructionPolicyOperationReuseError();
+      }
+      const existingEvent = await getEventByOperationInTransaction(
+        scopedDb,
+        input.workspaceId,
+        input.operationId
+      );
+      if (existingEvent) {
+        const legacyRequestMatches = hasOwnField(input, "expectedCurrentRevisionId") && !hasOwnField(input, "expectedActivationVersion") && existingEvent.type === input.type && existingEvent.newRevisionId === input.targetRevisionId && existingEvent.oldRevisionId === input.expectedCurrentRevisionId && existingEvent.actorSubjectId === input.actorSubjectId && existingEvent.reason === input.reason;
+        if (existingEvent.requestFingerprint === null ? !legacyRequestMatches : existingEvent.requestFingerprint !== requestFingerprint) {
+          throw new WorkspaceInstructionPolicyOperationReuseError();
+        }
+        return { head: headFromEventRow(existingEvent), event: eventFromRow(existingEvent) };
+      }
       const targetRow = await getRevisionInTransaction(
         scopedDb,
         input.workspaceId,
@@ -7638,7 +8096,7 @@ async function changeActiveRevision(db, input) {
       };
       const currentRow = await getHeadInTransaction(scopedDb, input.workspaceId, targetIdentity);
       const currentHead = currentRow ? headFromRow(currentRow) : null;
-      if ((currentHead?.revisionId ?? null) !== input.expectedCurrentRevisionId) {
+      if ((currentHead?.revisionId ?? null) !== input.expectedCurrentRevisionId || input.expectedActivationVersion !== void 0 && (currentHead?.activationVersion ?? 0) !== input.expectedActivationVersion) {
         throw new WorkspaceInstructionPolicyConflictError(currentHead);
       }
       if (currentHead?.revisionId === target.id) {
@@ -7667,6 +8125,8 @@ async function changeActiveRevision(db, input) {
       const activationVersion = (currentHead?.activationVersion ?? 0) + 1;
       const createdAt = /* @__PURE__ */ new Date();
       const [eventRow] = await scopedDb.insert(workspaceInstructionPolicyActivationEvents).values({
+        operationId: input.operationId,
+        requestFingerprint,
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         ...targetIdentity,
@@ -7712,12 +8172,17 @@ async function changeActiveRevision(db, input) {
 async function activateWorkspaceInstructionPolicyRevision(db, input) {
   return await changeActiveRevision(db, {
     ...input,
+    operationId: input.operationId ?? randomUUID(),
     targetRevisionId: input.revisionId,
     type: "activate"
   });
 }
 async function rollbackWorkspaceInstructionPolicyRevision(db, input) {
-  return await changeActiveRevision(db, { ...input, type: "rollback" });
+  return await changeActiveRevision(db, {
+    ...input,
+    operationId: input.operationId ?? randomUUID(),
+    type: "rollback"
+  });
 }
 async function getOrCreateWorkspaceInstructionPolicySnapshot(db, claims) {
   try {
@@ -7800,16 +8265,17 @@ import {
   PREFERENCE_REGISTRY_DESCRIPTOR_MAX_COUNT,
   PREFERENCE_REGISTRY_DESCRIPTOR_MAX_UTF8_BYTES,
   PREFERENCE_REGISTRY_TITLE_MAX_CHARS,
+  PreferenceRegistryDescriptor,
   PreferenceRegistryDetailResponse,
   PreferenceRegistryEvent,
   PreferenceRegistryFullContent,
   PreferenceRegistryListResponse,
   PreferenceRegistryRecord,
   PreferenceRegistryRevisionSummary,
-  PreferenceRegistrySnapshot,
+  PreferenceRegistrySnapshot as PreferenceRegistrySnapshot2,
   PreferenceRegistryScopeTarget
 } from "@opengeni/contracts";
-import { and as and13, asc as asc7, desc as desc5, eq as eq13, gt as gt3, inArray as inArray8, isNull as isNull4, lte, or as or2, sql as sql9 } from "drizzle-orm";
+import { and as and13, asc as asc7, desc as desc5, eq as eq13, gt as gt4, inArray as inArray8, isNull as isNull5, lte, or as or4, sql as sql9 } from "drizzle-orm";
 var importedSources = /* @__PURE__ */ new Set([
   "knowledge_proposal",
   "imported_document",
@@ -8120,9 +8586,9 @@ async function listPreferenceRegistryScoped(db, input) {
   if (input.status === "active") {
     conditions.push(
       eq13(preferenceRegistryPreferences.status, "active"),
-      or2(
-        isNull4(preferenceRegistryRevisions.expiresAt),
-        gt3(preferenceRegistryRevisions.expiresAt, now)
+      or4(
+        isNull5(preferenceRegistryRevisions.expiresAt),
+        gt4(preferenceRegistryRevisions.expiresAt, now)
       )
     );
   } else if (input.status === "expired") {
@@ -8162,6 +8628,81 @@ async function listPreferenceRegistry(db, input) {
     return await listPreferenceRegistryScoped(scopedDb, input);
   });
 }
+async function getCurrentPreferenceRegistryGovernanceMetadata(db, input) {
+  return await withWorkspaceSubjectRls(db, input.workspaceId, input.subjectId, async (scopedDb) => {
+    const rows = await scopedDb.select({
+      preference: preferenceRegistryPreferences,
+      revision: preferenceRegistryRevisions
+    }).from(preferenceRegistryPreferences).innerJoin(
+      preferenceRegistryRevisions,
+      and13(
+        eq13(
+          preferenceRegistryRevisions.id,
+          preferenceRegistryPreferences.activeRevisionId
+        ),
+        eq13(
+          preferenceRegistryRevisions.accountId,
+          preferenceRegistryPreferences.accountId
+        )
+      )
+    ).where(
+      and13(
+        eq13(preferenceRegistryPreferences.status, "active"),
+        or4(
+          isNull5(preferenceRegistryRevisions.expiresAt),
+          gt4(preferenceRegistryRevisions.expiresAt, sql9`transaction_timestamp()`)
+        )
+      )
+    ).orderBy(
+      sql9`case ${preferenceRegistryPreferences.scope}
+          when 'organization' then 0
+          when 'workspace' then 1
+          when 'user' then 2
+          else 3
+        end`,
+      desc5(preferenceRegistryRevisions.precedenceRank),
+      asc7(preferenceRegistryPreferences.stableKey),
+      asc7(preferenceRegistryPreferences.id)
+    ).limit(PREFERENCE_REGISTRY_DESCRIPTOR_MAX_COUNT + 1);
+    const bounded = boundPreferenceRegistryDescriptors(
+      rows.map(
+        ({ preference, revision }) => PreferenceRegistryDescriptor.parse({
+          id: preference.id,
+          stableKey: preference.stableKey,
+          title: revision.title,
+          description: revision.description,
+          scope: preference.scope,
+          activeVersion: preference.activationVersion,
+          revisionId: revision.id,
+          contentHash: revision.contentHash,
+          precedence: {
+            tier: preference.scope,
+            rank: revision.precedenceRank,
+            conflictStrategy: revision.conflictStrategy,
+            conflictsWith: revision.conflictsWith
+          },
+          provenance: {
+            source: revision.provenanceSource,
+            sourceIdHash: revision.provenanceSourceId ? contentHash2(revision.provenanceSourceId) : null,
+            trust: revision.trust
+          },
+          expiresAt: revision.expiresAt ? iso2(revision.expiresAt) : null,
+          retrievalHandle: `preference://${preference.id}/revisions/${revision.id}?sha256=${revision.contentHash}`
+        })
+      )
+    );
+    return {
+      descriptors: bounded.descriptors.map((descriptor) => ({
+        id: descriptor.id,
+        revisionId: descriptor.revisionId,
+        contentHash: descriptor.contentHash,
+        activeVersion: descriptor.activeVersion,
+        scope: descriptor.scope
+      })),
+      truncated: bounded.truncated
+    };
+  });
+}
 async function listPreferenceRegistryForAttempt(db, input) {
   return await withPreferenceRegistryAttemptAuthority(db, input, async (scopedDb) => {
     return await listPreferenceRegistryScoped(scopedDb, input);
@@ -8382,9 +8923,9 @@ async function supersedePreferenceRegistry(db, input) {
       and13(
         eq13(preferenceRegistryRevisions.id, replacement.activeRevisionId),
         eq13(preferenceRegistryRevisions.preferenceId, replacement.id),
-        or2(
-          isNull4(preferenceRegistryRevisions.expiresAt),
-          gt3(preferenceRegistryRevisions.expiresAt, sql9`transaction_timestamp()`)
+        or4(
+          isNull5(preferenceRegistryRevisions.expiresAt),
+          gt4(preferenceRegistryRevisions.expiresAt, sql9`transaction_timestamp()`)
         )
       )
     ).limit(1);
@@ -8586,7 +9127,7 @@ async function getOrCreatePreferenceRegistrySnapshot(db, claims) {
           "Preference snapshot authority conflicts with the accepted human attempt"
         );
       }
-      return PreferenceRegistrySnapshot.parse({
+      return PreferenceRegistrySnapshot2.parse({
         ...snapshot,
         createdAt: iso2(snapshot.createdAt)
       });
@@ -11970,7 +12511,7 @@ var defaultDeps2 = {
 var inflight2 = /* @__PURE__ */ new Map();
 var REFRESH_WINDOW_MS = 6e4;
 var CONNECTION_REFRESH_TIMEOUT_MS = 1e4;
-function buildConnectionTokenResolver(db, settings, deps = defaultDeps2) {
+function buildConnectionTokenResolver(db, settings, deps = defaultDeps2, options = {}) {
   const load = async (input) => {
     const subjectOwned = input.connectionRef.subjectScope === "subject";
     if (subjectOwned && !input.subjectId) {
@@ -12033,6 +12574,7 @@ function buildConnectionTokenResolver(db, settings, deps = defaultDeps2) {
       status: "ok",
       headers,
       connectionId: cred.id,
+      connectionVersion: cred.version,
       expiresAt: cred.expiresAt
     };
   };
@@ -12041,7 +12583,7 @@ function buildConnectionTokenResolver(db, settings, deps = defaultDeps2) {
     if (!key) {
       throw new Error("OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY is not configured");
     }
-    const refreshed = await deps.refresh(cred, ref, settings);
+    const refreshed = await deps.refresh(cred, ref, settings, options.refreshTransport);
     const refreshRecord = {
       id: cred.id,
       version: cred.version,
@@ -12117,17 +12659,29 @@ function buildConnectionTokenResolver(db, settings, deps = defaultDeps2) {
         cred = await refreshSingleFlight(cred, ref);
       } catch (error) {
         if (isPermanentRefreshError(error)) {
-          await deps.setStatus(
-            db,
-            input.workspaceId,
-            "needs_reauth",
-            error instanceof Error ? error.message : String(error),
-            {
+          let handled = false;
+          if (options.transitionPermanentRefreshFailure) {
+            try {
+              handled = await options.transitionPermanentRefreshFailure({
+                workspaceId: cred.workspaceId,
+                connectionId: cred.id,
+                connectionVersion: cred.version,
+                subjectId: cred.subjectId,
+                providerDomain: cred.providerDomain,
+                httpStatus: error.httpStatus,
+                oauthErrorCode: error.oauthErrorCode
+              });
+            } catch {
+              handled = false;
+            }
+          }
+          if (!handled) {
+            await deps.setStatus(db, input.workspaceId, "needs_reauth", error.message, {
               id: cred.id,
               version: cred.version,
               subjectId: cred.subjectId
-            }
-          ).catch(() => void 0);
+            }).catch(() => void 0);
+          }
         }
         return authNeeded(ref, "refresh_failed", cred.id);
       }
@@ -12182,10 +12736,12 @@ function canonicalResource(value) {
 }
 var ConnectionRefreshHttpError = class extends Error {
   httpStatus;
-  constructor(httpStatus) {
+  oauthErrorCode;
+  constructor(httpStatus, oauthErrorCode = null) {
     super(`connection refresh failed with HTTP ${httpStatus}`);
     this.name = "ConnectionRefreshHttpError";
     this.httpStatus = httpStatus;
+    this.oauthErrorCode = oauthErrorCode;
   }
 };
 function isPermanentRefreshError(error) {
@@ -12317,8 +12873,10 @@ async function refreshOAuthConnectionCredential(cred, ref, settings, transportOp
     throw new ConnectionRefreshHttpError(response.status);
   }
   if (!response.ok) {
-    await cancelResponseBody(response);
-    throw new ConnectionRefreshHttpError(response.status);
+    throw new ConnectionRefreshHttpError(
+      response.status,
+      await readOAuthRefreshErrorCode(response)
+    );
   }
   const payload = await readResponseJsonBounded(
     response,
@@ -12347,6 +12905,20 @@ async function refreshOAuthConnectionCredential(cred, ref, settings, transportOp
     ...scopeText ? { grantedScopes: scopeText.split(/\s+/).filter(Boolean) } : {}
   };
 }
+async function readOAuthRefreshErrorCode(response) {
+  try {
+    const payload = await readResponseJsonBounded(
+      response,
+      OAUTH_MAX_RESPONSE_BYTES,
+      "OAuth refresh error response"
+    );
+    const code = stringValue(payload.error);
+    return code && /^[a-z0-9_.-]{1,64}$/i.test(code) ? code : null;
+  } catch {
+    await cancelResponseBody(response);
+    return null;
+  }
+}
 function expiresAtFromTokenResponse(payload, fallback) {
   const expiresAt = stringValue(payload.expires_at);
   if (expiresAt) {
@@ -12380,7 +12952,7 @@ async function cancelResponseBody(response) {
 }
 
 // src/workspace-artifacts.ts
-import { and as and16, desc as desc7, eq as eq16, lt as lt3, or as or3, sql as sql13 } from "drizzle-orm";
+import { and as and16, desc as desc7, eq as eq16, lt as lt3, or as or5, sql as sql13 } from "drizzle-orm";
 var WorkspaceArtifactNotFoundError = class extends Error {
   name = "WorkspaceArtifactNotFoundError";
 };
@@ -12475,7 +13047,7 @@ async function listWorkspaceArtifacts(db, workspaceId, options = {}) {
     const cursor = options.cursor ? decodeListCursor(options.cursor) : null;
     const visibility = cursor ? and16(
       eq16(workspaceArtifacts.workspaceId, workspaceId),
-      or3(
+      or5(
         lt3(workspaceArtifacts.updatedAt, cursor.updatedAt),
         and16(
           eq16(workspaceArtifacts.updatedAt, cursor.updatedAt),
@@ -13345,6 +13917,29 @@ async function withWorkspaceUsageLock(db, workspaceId, fn) {
     return await fn(scopedDb);
   });
 }
+async function resolveDocumentIndexAuthority(db, input) {
+  const rows = await rawRows(
+    db,
+    sql14`
+      select authority_kind, authority_workspace_id, authority_subject_id
+      from opengeni_private.resolve_document_index_authority(
+        ${input.accountId},
+        ${input.workspaceId},
+        ${input.documentId}
+      )
+    `
+  );
+  const row = rows[0];
+  if (!row) return null;
+  if (row.authority_kind !== "organization" && row.authority_kind !== "workspace" && row.authority_kind !== "personal") {
+    throw new Error(`Stored document authority kind is invalid: ${row.authority_kind}`);
+  }
+  return {
+    authorityKind: row.authority_kind,
+    authorityWorkspaceId: row.authority_workspace_id,
+    authoritySubjectId: row.authority_subject_id
+  };
+}
 async function withAccountRls(db, accountId, fn) {
   return await withRlsContext(db, { accountId, workspaceId: null }, fn);
 }
@@ -13967,7 +14562,7 @@ async function upsertGitHubInstallation(db, input) {
         },
         // This legacy metadata helper cannot mutate an owner-authorized row.
         // New bindings use bindAuthorizedGitHubInstallationRepositories.
-        setWhere: isNull5(githubInstallations.authorityNonce)
+        setWhere: isNull6(githubInstallations.authorityNonce)
       }).returning();
       if (!row) {
         throw new Error("Failed to upsert GitHub installation");
@@ -14010,7 +14605,7 @@ async function bindGitHubInstallationRepositories(db, input) {
           updatedAt: /* @__PURE__ */ new Date()
         },
         // Preserve the immutable authority + allowlist audit boundary.
-        setWhere: isNull5(githubInstallations.authorityNonce)
+        setWhere: isNull6(githubInstallations.authorityNonce)
       }).returning();
       if (!row) {
         throw new Error("Failed to bind GitHub installation");
@@ -14463,7 +15058,7 @@ async function sumUsageQuantity(db, input) {
       eq17(usageEvents.eventType, input.eventType),
       ...input.accountId ? [eq17(usageEvents.accountId, input.accountId)] : [],
       ...input.workspaceId ? [eq17(usageEvents.workspaceId, input.workspaceId)] : [],
-      ...input.since ? [gt4(usageEvents.occurredAt, input.since)] : []
+      ...input.since ? [gt5(usageEvents.occurredAt, input.since)] : []
     ];
     const [{ total } = { total: 0 }] = await scopedDb.select({
       total: sql14`coalesce(sum(${usageEvents.quantity}), 0)`
@@ -14619,6 +15214,20 @@ async function countScheduledTasksForWorkspace(db, workspaceId) {
     return Number(count);
   });
 }
+var ConnectionDisconnectIdempotencyError = class extends Error {
+  code = "IDEMPOTENCY_KEY_REUSED";
+  constructor() {
+    super("The disconnect idempotency key was already used with different input");
+    this.name = "ConnectionDisconnectIdempotencyError";
+  }
+};
+var ConnectionDisconnectGenerationError = class extends Error {
+  code = "CONNECTION_GENERATION_CHANGED";
+  constructor() {
+    super("The disconnect operation belongs to an older connection generation");
+    this.name = "ConnectionDisconnectGenerationError";
+  }
+};
 async function createFileUpload(db, input) {
   return await withRlsContext(
     db,
@@ -14674,6 +15283,25 @@ async function requireFile(db, workspaceId, fileId) {
   }
   return file;
 }
+async function getFiles(db, workspaceId, fileIds) {
+  const ids = [...new Set(fileIds)];
+  if (ids.length === 0) return [];
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const rows = await scopedDb.select().from(files).where(and17(eq17(files.workspaceId, workspaceId), inArray11(files.id, ids)));
+    return rows.map(mapFile);
+  });
+}
+function durableUserHistoryItem(prompt, resources) {
+  const attachmentRefs = resources.filter(
+    (resource) => resource.kind === "file"
+  );
+  return sanitizeModelPayload({
+    type: "message",
+    role: "user",
+    content: prompt,
+    ...attachmentRefs.length > 0 ? { [MODEL_ATTACHMENT_REFS_FIELD]: attachmentRefs } : {}
+  });
+}
 async function getRetainedFileArtifact(db, workspaceId, fileId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const [row] = await scopedDb.select({
@@ -15251,11 +15879,11 @@ async function upsertCapabilityCatalogItem(db, input) {
 async function listCapabilityCatalogItems(db, workspaceId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const rows = await scopedDb.select().from(capabilityCatalogItems).where(
-      or4(
+      or6(
         eq17(capabilityCatalogItems.workspaceId, workspaceId),
         and17(
-          isNull5(capabilityCatalogItems.workspaceId),
-          or4(
+          isNull6(capabilityCatalogItems.workspaceId),
+          or6(
             ne(capabilityCatalogItems.source, registryCapabilitySource),
             eq17(capabilityCatalogItems.stale, false)
           )
@@ -15277,9 +15905,9 @@ async function getCapabilityCatalogItem(db, workspaceId, capabilityId) {
     const [row] = await scopedDb.select().from(capabilityCatalogItems).where(
       and17(
         eq17(capabilityCatalogItems.id, capabilityId),
-        or4(
+        or6(
           eq17(capabilityCatalogItems.workspaceId, workspaceId),
-          isNull5(capabilityCatalogItems.workspaceId)
+          isNull6(capabilityCatalogItems.workspaceId)
         )
       )
     ).orderBy(asc8(sql14`(${capabilityCatalogItems.workspaceId} is null)`)).limit(1);
@@ -15387,12 +16015,12 @@ async function listEnabledMcpCapabilityServers(db, workspaceId) {
     }).from(capabilityInstallations).innerJoin(
       capabilityCatalogItems,
       and17(
-        or4(
+        or6(
           eq17(
             capabilityInstallations.workspaceId,
             capabilityCatalogItems.workspaceId
           ),
-          isNull5(capabilityCatalogItems.workspaceId)
+          isNull6(capabilityCatalogItems.workspaceId)
         ),
         eq17(capabilityInstallations.capabilityId, capabilityCatalogItems.id)
       )
@@ -15501,10 +16129,10 @@ var connectionMetadataColumns = {
   updatedAt: connections.updatedAt
 };
 function connectionSubjectVisibility(subjectId) {
-  return subjectId ? or4(isNull5(connections.subjectId), eq17(connections.subjectId, subjectId)) : isNull5(connections.subjectId);
+  return subjectId ? or6(isNull6(connections.subjectId), eq17(connections.subjectId, subjectId)) : isNull6(connections.subjectId);
 }
 function connectionExactSubject(subjectId) {
-  return subjectId ? eq17(connections.subjectId, subjectId) : isNull5(connections.subjectId);
+  return subjectId ? eq17(connections.subjectId, subjectId) : isNull6(connections.subjectId);
 }
 function personalSlackCanonicalConnectionOrder() {
   return [
@@ -15617,6 +16245,124 @@ async function updateConnection(db, input) {
     async (scopedDb) => await updateConnectionInScope(scopedDb, input)
   );
 }
+async function transitionConnectionStateInScope(db, input) {
+  const [row] = await db.update(connections).set({
+    ...input.status !== void 0 ? { status: input.status } : {},
+    metadata: input.metadata,
+    ...input.lastError !== void 0 ? { lastError: input.lastError } : {},
+    version: sql14`${connections.version} + 1`,
+    ...input.updatedBySubjectId !== void 0 ? { updatedBySubjectId: input.updatedBySubjectId } : {},
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(
+    and17(
+      eq17(connections.workspaceId, input.workspaceId),
+      eq17(connections.id, input.connectionId),
+      connectionSubjectVisibility(input.visibleToSubjectId),
+      eq17(connections.version, input.expectedVersion)
+    )
+  ).returning(connectionMetadataColumns);
+  return row ? mapConnectionMetadata(row) : null;
+}
+async function transitionConnectionState(db, input) {
+  return await withConnectionSubjectRls(
+    db,
+    input.workspaceId,
+    input.visibleToSubjectId,
+    async (scopedDb) => await transitionConnectionStateInScope(scopedDb, input)
+  );
+}
+var connectionDisconnectOperationColumns = {
+  accountId: connectionDisconnectOperations.accountId,
+  workspaceId: connectionDisconnectOperations.workspaceId,
+  connectionId: connectionDisconnectOperations.connectionId,
+  subjectId: connectionDisconnectOperations.subjectId,
+  idempotencyKey: connectionDisconnectOperations.idempotencyKey,
+  expectedVersion: connectionDisconnectOperations.expectedVersion,
+  resultVersion: connectionDisconnectOperations.resultVersion
+};
+async function disconnectConnectionIdempotently(db, input) {
+  return await withConnectionSubjectRls(
+    db,
+    input.workspaceId,
+    input.subjectId,
+    async (scopedDb) => {
+      const [connectionRow] = await scopedDb.select(connectionMetadataColumns).from(connections).where(
+        and17(
+          eq17(connections.accountId, input.accountId),
+          eq17(connections.workspaceId, input.workspaceId),
+          eq17(connections.id, input.connectionId),
+          eq17(connections.subjectId, input.subjectId)
+        )
+      ).for("update");
+      if (!connectionRow) return null;
+      const connection = mapConnectionMetadata(connectionRow);
+      const [replayed] = await scopedDb.select(connectionDisconnectOperationColumns).from(connectionDisconnectOperations).where(
+        and17(
+          eq17(connectionDisconnectOperations.workspaceId, input.workspaceId),
+          eq17(connectionDisconnectOperations.subjectId, input.subjectId),
+          eq17(connectionDisconnectOperations.idempotencyKey, input.idempotencyKey)
+        )
+      ).limit(1);
+      if (replayed) {
+        if (replayed.accountId !== input.accountId || replayed.connectionId !== input.connectionId || replayed.expectedVersion !== input.expectedVersion) {
+          throw new ConnectionDisconnectIdempotencyError();
+        }
+        if (connection.version !== replayed.resultVersion) {
+          throw new ConnectionDisconnectGenerationError();
+        }
+        return connection;
+      }
+      if (connection.version !== input.expectedVersion) {
+        throw new ConnectionDisconnectGenerationError();
+      }
+      const [inserted] = await scopedDb.insert(connectionDisconnectOperations).values({
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        connectionId: input.connectionId,
+        subjectId: input.subjectId,
+        idempotencyKey: input.idempotencyKey,
+        expectedVersion: input.expectedVersion,
+        resultVersion: input.expectedVersion + 1
+      }).onConflictDoNothing().returning(connectionDisconnectOperationColumns);
+      if (!inserted) {
+        const [conflictingKey] = await scopedDb.select(connectionDisconnectOperationColumns).from(connectionDisconnectOperations).where(
+          and17(
+            eq17(connectionDisconnectOperations.workspaceId, input.workspaceId),
+            eq17(connectionDisconnectOperations.subjectId, input.subjectId),
+            eq17(connectionDisconnectOperations.idempotencyKey, input.idempotencyKey)
+          )
+        ).limit(1);
+        if (!conflictingKey || conflictingKey.accountId !== input.accountId || conflictingKey.connectionId !== input.connectionId || conflictingKey.expectedVersion !== input.expectedVersion) {
+          throw new ConnectionDisconnectIdempotencyError();
+        }
+        if (connection.version !== conflictingKey.resultVersion) {
+          throw new ConnectionDisconnectGenerationError();
+        }
+        return connection;
+      }
+      const [updated] = await scopedDb.update(connections).set({
+        status: "revoked",
+        metadata: input.metadata,
+        ...input.lastError !== void 0 ? { lastError: input.lastError } : {},
+        version: sql14`${connections.version} + 1`,
+        ...input.updatedBySubjectId !== void 0 ? { updatedBySubjectId: input.updatedBySubjectId } : {},
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(
+        and17(
+          eq17(connections.accountId, input.accountId),
+          eq17(connections.workspaceId, input.workspaceId),
+          eq17(connections.id, input.connectionId),
+          eq17(connections.subjectId, input.subjectId),
+          eq17(connections.version, input.expectedVersion)
+        )
+      ).returning(connectionMetadataColumns);
+      if (!updated) {
+        throw new ConnectionDisconnectGenerationError();
+      }
+      return mapConnectionMetadata(updated);
+    }
+  );
+}
 async function revokeConnectionInScope(db, workspaceId, connectionId, updatedBySubjectId, expectedVersion) {
   const [row] = await db.update(connections).set({
     status: "revoked",
@@ -15645,12 +16391,18 @@ async function revokeConnectionInScope(db, workspaceId, connectionId, updatedByS
   ).returning(connectionMetadataColumns);
   return row ? mapConnectionMetadata(row) : null;
 }
-async function revokeConnection(db, workspaceId, connectionId, updatedBySubjectId) {
+async function revokeConnection(db, workspaceId, connectionId, updatedBySubjectId, expectedVersion) {
   return await withConnectionSubjectRls(
     db,
     workspaceId,
     updatedBySubjectId,
-    async (scopedDb) => await revokeConnectionInScope(scopedDb, workspaceId, connectionId, updatedBySubjectId)
+    async (scopedDb) => await revokeConnectionInScope(
+      scopedDb,
+      workspaceId,
+      connectionId,
+      updatedBySubjectId,
+      expectedVersion
+    )
   );
 }
 async function resolveSlackInstallationRoute(db, slackTeamId) {
@@ -15715,7 +16467,7 @@ async function enqueueSlackInteractionInbox(db, input) {
       const [existing] = await scopedDb.select().from(slackInteractionInbox).where(
         and17(
           eq17(slackInteractionInbox.connectionId, input.connectionId),
-          or4(
+          or6(
             eq17(slackInteractionInbox.providerEventId, input.providerEventId),
             eq17(slackInteractionInbox.providerMessageId, input.providerMessageId)
           )
@@ -15929,7 +16681,7 @@ async function bindSlackInteractionSession(db, input) {
         eq17(slackInteractions.id, input.id),
         eq17(slackInteractions.owningSubjectId, input.owningSubjectId),
         eq17(slackInteractions.sessionReservationId, input.sessionId),
-        isNull5(slackInteractions.sessionId)
+        isNull6(slackInteractions.sessionId)
       )
     ).returning();
     if (row) return mapSlackInteraction(row);
@@ -16431,8 +17183,8 @@ async function claimSlackBotPostOperation(db, input) {
       }).where(
         and17(
           eq17(slackBotPostOperations.id, existing.id),
-          or4(
-            isNull5(slackBotPostOperations.claimHolderId),
+          or6(
+            isNull6(slackBotPostOperations.claimHolderId),
             lte2(slackBotPostOperations.claimExpiresAt, sql14`now()`)
           )
         )
@@ -16628,7 +17380,7 @@ async function markSlackBotDeleteOperationProviderStarted(db, input) {
           eq17(slackBotDeleteOperations.connectionId, input.connectionId),
           eq17(slackBotDeleteOperations.operationId, input.operationId),
           eq17(slackBotDeleteOperations.claimHolderId, input.claimHolderId),
-          or4(
+          or6(
             eq17(slackBotDeleteOperations.status, "pending"),
             eq17(slackBotDeleteOperations.status, "outcome_unknown")
           )
@@ -16736,7 +17488,7 @@ async function loadConnectionCredentialForBroker(db, settings, input) {
       "connection credential present but OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY is not configured"
     );
   }
-  const subjectPredicate = input.allowSubjectOwned ? connectionExactSubject(input.subjectId) : isNull5(connections.subjectId);
+  const subjectPredicate = input.allowSubjectOwned ? connectionExactSubject(input.subjectId) : isNull6(connections.subjectId);
   const conditions = [
     eq17(connections.workspaceId, input.workspaceId),
     subjectPredicate
@@ -20219,7 +20971,7 @@ async function withCodexCapacityMutation(db, input, mutate) {
           eq17(codexCapacityWaiters.workspaceId, input.workspaceId),
           eq17(codexCapacityWaiters.status, "waiting"),
           ...input.policyHash !== void 0 ? [
-            input.policyHash === null ? isNull5(codexCapacityWaiters.policyHash) : eq17(codexCapacityWaiters.policyHash, input.policyHash)
+            input.policyHash === null ? isNull6(codexCapacityWaiters.policyHash) : eq17(codexCapacityWaiters.policyHash, input.policyHash)
           ] : []
         )
       ).returning();
@@ -20312,7 +21064,7 @@ async function supersedeCodexCapacityWaitInTransaction(tx, input) {
         eq17(sessionTurns.workspaceId, input.session.workspaceId),
         eq17(sessionTurns.id, input.blockedTurn.id),
         eq17(sessionTurns.status, "waiting_capacity"),
-        isNull5(sessionTurns.activeAttemptId),
+        isNull6(sessionTurns.activeAttemptId),
         eq17(sessionTurns.executionGeneration, input.waiter.blockedTurnGeneration)
       )
     ).returning({ id: sessionTurns.id });
@@ -20590,7 +21342,7 @@ async function reconcileCodexCapacityWait(db, input, decide, policy) {
           eq17(sessionTurns.workspaceId, input.workspaceId),
           eq17(sessionTurns.id, blockedTurn.id),
           eq17(sessionTurns.status, "waiting_capacity"),
-          isNull5(sessionTurns.activeAttemptId),
+          isNull6(sessionTurns.activeAttemptId),
           eq17(sessionTurns.executionGeneration, waiter.blockedTurnGeneration)
         )
       ).returning({ id: sessionTurns.id });
@@ -21411,7 +22163,7 @@ async function setInitialActiveCodexCredential(db, workspaceId, credentialId) {
     const rows = await scopedDb.update(codexRotationSettings).set({ activeCredentialId: credentialId, updatedAt: /* @__PURE__ */ new Date() }).where(
       and17(
         eq17(codexRotationSettings.workspaceId, workspaceId),
-        isNull5(codexRotationSettings.activeCredentialId)
+        isNull6(codexRotationSettings.activeCredentialId)
       )
     ).returning({ id: codexRotationSettings.id });
     return rows.length > 0;
@@ -21560,8 +22312,8 @@ async function setSessionCodexPin(db, workspaceId, sessionId, pinnedCredentialId
     ];
     if (options.expected) {
       conditions.push(
-        options.expected.pinnedCredentialId === null ? isNull5(sessions.codexPinnedCredentialId) : eq17(sessions.codexPinnedCredentialId, options.expected.pinnedCredentialId),
-        options.expected.pinSource === null ? isNull5(sessions.codexPinSource) : eq17(sessions.codexPinSource, options.expected.pinSource)
+        options.expected.pinnedCredentialId === null ? isNull6(sessions.codexPinnedCredentialId) : eq17(sessions.codexPinnedCredentialId, options.expected.pinnedCredentialId),
+        options.expected.pinSource === null ? isNull6(sessions.codexPinSource) : eq17(sessions.codexPinSource, options.expected.pinSource)
       );
     }
     const updated = await scopedDb.update(sessions).set({
@@ -22911,7 +23663,7 @@ async function listSessionSpawnDenials(db, workspaceId, options = {}) {
     const rows = await scopedDb.select().from(sessionSpawnDenials).where(
       and17(
         eq17(sessionSpawnDenials.workspaceId, workspaceId),
-        options.parentSessionId === void 0 ? void 0 : options.parentSessionId === null ? isNull5(sessionSpawnDenials.parentSessionId) : eq17(sessionSpawnDenials.parentSessionId, options.parentSessionId)
+        options.parentSessionId === void 0 ? void 0 : options.parentSessionId === null ? isNull6(sessionSpawnDenials.parentSessionId) : eq17(sessionSpawnDenials.parentSessionId, options.parentSessionId)
       )
     ).orderBy(desc8(sessionSpawnDenials.createdAt), desc8(sessionSpawnDenials.id)).limit(Math.max(1, Math.min(options.limit ?? 100, 1e3)));
     return rows.map(mapSessionSpawnDenial);
@@ -23229,7 +23981,7 @@ function sessionFilters(options) {
   if (Object.prototype.hasOwnProperty.call(options, "parentSessionId")) {
     const parentSessionId = options.parentSessionId;
     if (parentSessionId === null) {
-      filters.push(isNull5(sessions.parentSessionId));
+      filters.push(isNull6(sessions.parentSessionId));
     } else if (parentSessionId !== void 0) {
       filters.push(eq17(sessions.parentSessionId, parentSessionId));
     }
@@ -23238,7 +23990,7 @@ function sessionFilters(options) {
   if (search) {
     const pattern = `%${search.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
     filters.push(
-      or4(ilike(sessions.title, pattern), ilike(sessions.initialMessage, pattern))
+      or6(ilike(sessions.title, pattern), ilike(sessions.initialMessage, pattern))
     );
   }
   return filters;
@@ -23271,7 +24023,7 @@ function sessionAuthorizationScopeFilter(scope) {
           )
           select id from authorized_sessions
         )` : sql14`false`;
-  return or4(exact, descendants);
+  return or6(exact, descendants);
 }
 async function sessionIdsCoveredByAuthorizationRoots(db, workspaceId, sessionIds, scope) {
   if (sessionIds.length === 0) return /* @__PURE__ */ new Set();
@@ -23453,7 +24205,7 @@ async function listSessionsForSubject(db, workspaceId, options) {
           ).where(
             and17(
               ...filters,
-              or4(isNull5(sessionPins.id), eq17(sessionPins.pinned, false))
+              or6(isNull6(sessionPins.id), eq17(sessionPins.pinned, false))
             )
           ).orderBy(desc8(sessions.updatedAt), desc8(sessions.id)).limit(limit);
           pageIds = ordinaryIdRows.map((row) => row.id);
@@ -23466,14 +24218,14 @@ async function listSessionsForSubject(db, workspaceId, options) {
               lte2(sessionListSnapshots.expiresAt, now)
             )
           );
-          const snapshotSearchFilter = searchFilter ? eq17(sessionListSnapshots.search, searchFilter) : isNull5(sessionListSnapshots.search);
+          const snapshotSearchFilter = searchFilter ? eq17(sessionListSnapshots.search, searchFilter) : isNull6(sessionListSnapshots.search);
           const [reusableSnapshot] = await tx.select().from(sessionListSnapshots).where(
             and17(
               eq17(sessionListSnapshots.workspaceId, workspaceId),
               eq17(sessionListSnapshots.subjectId, options.subjectId),
               eq17(sessionListSnapshots.parentSessionFilter, parentFilter),
               snapshotSearchFilter,
-              gt4(
+              gt5(
                 sessionListSnapshots.createdAt,
                 new Date(now.getTime() - SESSION_LIST_SNAPSHOT_REUSE_MS)
               )
@@ -23494,7 +24246,7 @@ async function listSessionsForSubject(db, workspaceId, options) {
             ).where(
               and17(
                 ...filters,
-                or4(isNull5(sessionPins.id), eq17(sessionPins.pinned, false))
+                or6(isNull6(sessionPins.id), eq17(sessionPins.pinned, false))
               )
             ).orderBy(desc8(sessions.updatedAt), desc8(sessions.id)).limit(SESSION_LIST_SNAPSHOT_MAX_IDS + 1);
             if (ordinaryIdRows.length > SESSION_LIST_SNAPSHOT_MAX_IDS) {
@@ -23568,7 +24320,7 @@ async function listSessionsForSubject(db, workspaceId, options) {
             eq17(sessions.workspaceId, workspaceId),
             inArray11(sessions.id, pageIds),
             ...options.authorizationScope ? [sessionAuthorizationScopeFilter(options.authorizationScope)] : [],
-            or4(isNull5(sessionPins.id), eq17(sessionPins.pinned, false))
+            or6(isNull6(sessionPins.id), eq17(sessionPins.pinned, false))
           )
         );
         const ordinaryById = new Map(ordinaryRows.map((row) => [row.session.id, row]));
@@ -23758,7 +24510,7 @@ async function listSessions(db, workspaceId, limitOrOptions = 50) {
     if (Object.prototype.hasOwnProperty.call(options, "parentSessionId")) {
       const parentSessionId = options.parentSessionId;
       if (parentSessionId === null) {
-        filters.push(isNull5(sessions.parentSessionId));
+        filters.push(isNull6(sessions.parentSessionId));
       } else if (parentSessionId !== void 0) {
         filters.push(eq17(sessions.parentSessionId, parentSessionId));
       }
@@ -23899,11 +24651,11 @@ async function listSessionDiscoverySummaries(db, workspaceId, options) {
     if (orderBy === "createdAt" && options.cursor && (cursorSortRevision !== "0" || options.cursor.snapshotRevision !== "0")) {
       throw new Error("sessions_list created-order cursor cannot carry activity revisions");
     }
-    const cursorPredicate = options.cursor ? orderBy === "updatedAt" ? or4(
+    const cursorPredicate = options.cursor ? orderBy === "updatedAt" ? or6(
       sql14`${sessions.activityRevision} < ${cursorSortRevision}::text::bigint`,
       and17(
         sql14`${sessions.activityRevision} = ${cursorSortRevision}::text::bigint`,
-        or4(
+        or6(
           sql14`${sessions.updatedAt} < ${options.cursor.sortAt}::text::timestamptz`,
           and17(
             sql14`${sessions.updatedAt} = ${options.cursor.sortAt}::text::timestamptz`,
@@ -23911,7 +24663,7 @@ async function listSessionDiscoverySummaries(db, workspaceId, options) {
           )
         )
       )
-    ) : or4(
+    ) : or6(
       // Cast through text deliberately. postgres.js otherwise infers a
       // timestamptz parameter and serializes this exact cursor string via
       // JS Date, which discards PostgreSQL's sub-millisecond precision.
@@ -24282,16 +25034,16 @@ async function listSessionEventPage(db, workspaceId, sessionId, options = {}) {
       const filters = [
         eq17(sessionEvents.workspaceId, workspaceId),
         eq17(sessionEvents.sessionId, sessionId),
-        gt4(sessionEvents.sequence, after)
+        gt5(sessionEvents.sequence, after)
       ];
       if (options.authoritativeLatest) {
         filters.push(
           and17(
-            or4(
-              isNull5(sessionEvents.turnAssociation),
+            or6(
+              isNull6(sessionEvents.turnAssociation),
               eq17(sessionEvents.turnAssociation, "current")
             ),
-            isNull5(sessionEvents.duplicateOfEventId)
+            isNull6(sessionEvents.duplicateOfEventId)
           )
         );
       }
@@ -24306,7 +25058,7 @@ async function listSessionEventPage(db, workspaceId, sessionId, options = {}) {
           filters.push(lt4(sessionEvents.sequence, cursor));
         }
       } else if (cursor !== void 0) {
-        filters.push(gt4(sessionEvents.sequence, cursor));
+        filters.push(gt5(sessionEvents.sequence, cursor));
       }
       if (direction === "after" && before !== void 0 && before <= POSTGRES_INT_MAX) {
         filters.push(lt4(sessionEvents.sequence, before));
@@ -24489,7 +25241,7 @@ async function listSessionEvents(db, workspaceId, sessionId, afterOrOptions = 0,
     const filters = [
       eq17(sessionEvents.workspaceId, workspaceId),
       eq17(sessionEvents.sessionId, sessionId),
-      gt4(sessionEvents.sequence, after)
+      gt5(sessionEvents.sequence, after)
     ];
     if (typeFilters.includeTypes.length > 0) {
       filters.push(inArray11(sessionEvents.type, typeFilters.includeTypes));
@@ -24623,7 +25375,7 @@ async function listWorkspaceControlEvents(db, workspaceId, after = 0, limit = 50
     const rows = await scopedDb.select().from(workspaceControlEvents).where(
       and17(
         eq17(workspaceControlEvents.workspaceId, workspaceId),
-        gt4(workspaceControlEvents.revision, cursor)
+        gt5(workspaceControlEvents.revision, cursor)
       )
     ).orderBy(asc8(workspaceControlEvents.revision)).limit(boundedLimit);
     return rows.map(mapWorkspaceControlEvent);
@@ -24769,21 +25521,6 @@ function validateAnsweredHumanInput(questions, answers) {
           `Text question ${question.id} accepts one value`
         );
       }
-      const value = values[0] ?? "";
-      const minLength = question.validation?.minLength;
-      const maxLength = question.validation?.maxLength;
-      if (minLength != null && value.length < minLength) {
-        throw new HumanInputResponseValidationError(
-          "INVALID_RESPONSE",
-          `Question ${question.id} is shorter than its minimum length`
-        );
-      }
-      if (maxLength != null && value.length > maxLength) {
-        throw new HumanInputResponseValidationError(
-          "INVALID_RESPONSE",
-          `Question ${question.id} exceeds its maximum length`
-        );
-      }
       continue;
     }
     if (other && !question.allowOther) {
@@ -24856,7 +25593,7 @@ async function hasAcceptedRequiresActionAdvance(tx, input) {
       eq17(sessionEvents.turnId, input.turnId),
       eq17(sessionEvents.turnGeneration, input.turnGeneration),
       inArray11(sessionEvents.type, ["user.approvalDecision", "user.humanInputResponse"]),
-      gt4(sessionEvents.sequence, trigger.sequence)
+      gt5(sessionEvents.sequence, trigger.sequence)
     )
   ).limit(1);
   return accepted !== void 0;
@@ -24994,6 +25731,26 @@ async function acceptSessionHumanInputResponse(db, input) {
         occurredAt: now
       }).returning();
       if (!event) throw new Error("Failed to append human-input response");
+      await mirrorSessionRealtimeContextInTransaction(tx, {
+        accountId: session.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+        sourceKind: "human_input_response",
+        sourceId: event.id,
+        turnId: turn.id,
+        channel: response.outcome === "answered" || response.outcome === "skipped" ? "speakable" : null,
+        text: renderRealtimeHumanInputResponseContext({
+          requestId: request.id,
+          questions: request.questions,
+          response
+        }),
+        payload: {
+          requestId: request.id,
+          outcome: response.outcome,
+          sourceEventId: event.id
+        },
+        now
+      });
       await tx.update(sessions).set({ lastSequence: session.lastSequence + 1, updatedAt: now }).where(eq17(sessions.id, session.id));
       const workflowWakeRevision = await enqueueSessionWorkflowWakeInTransaction(
         tx,
@@ -26054,7 +26811,7 @@ function exactPtyIdentityPredicates(identity) {
     eq17(sandboxPtySessions.providerBackend, identity.providerBackend),
     eq17(sandboxPtySessions.providerInstanceId, identity.providerInstanceId),
     eq17(sandboxPtySessions.routeKind, identity.routeKind),
-    identity.routeTargetId === null ? isNull5(sandboxPtySessions.routeTargetId) : eq17(sandboxPtySessions.routeTargetId, identity.routeTargetId),
+    identity.routeTargetId === null ? isNull6(sandboxPtySessions.routeTargetId) : eq17(sandboxPtySessions.routeTargetId, identity.routeTargetId),
     eq17(sandboxPtySessions.routeEpoch, identity.routeEpoch)
   ];
 }
@@ -28079,7 +28836,7 @@ async function settleExactLostProviderWorkspaceBlockersTx(tx, input) {
       eq17(sandboxWorkspaceMutationAdmissions.sandboxGroupId, input.sandboxGroupId),
       eq17(sandboxWorkspaceMutationAdmissions.leaseEpoch, input.lostEpoch),
       eq17(sandboxWorkspaceMutationAdmissions.providerInstanceId, input.lostInstanceId),
-      isNull5(sandboxWorkspaceMutationAdmissions.settledAt)
+      isNull6(sandboxWorkspaceMutationAdmissions.settledAt)
     )
   ).returning({ id: sandboxWorkspaceMutationAdmissions.id });
   const closedPtys = await tx.update(sandboxPtySessions).set({ status: "closed", closedAt: /* @__PURE__ */ new Date() }).where(
@@ -29711,8 +30468,8 @@ async function retainWorkspaceMutationProcess(db, input) {
           and17(
             eq17(sandboxRetainedProcesses.id, process.id),
             eq17(sandboxRetainedProcesses.state, "active"),
-            isNull5(sandboxRetainedProcesses.providerBindingKey),
-            isNull5(sandboxRetainedProcesses.providerBinding)
+            isNull6(sandboxRetainedProcesses.providerBindingKey),
+            isNull6(sandboxRetainedProcesses.providerBinding)
           )
         ).returning();
         if (!bound) {
@@ -29917,8 +30674,8 @@ async function bindRetainedProcessProviderIdentity(db, input) {
           eq17(sandboxRetainedProcesses.id, process.id),
           eq17(sandboxRetainedProcesses.state, "active"),
           eq17(sandboxRetainedProcesses.reconcileClaimId, input.claimId),
-          isNull5(sandboxRetainedProcesses.providerBindingKey),
-          isNull5(sandboxRetainedProcesses.providerBinding)
+          isNull6(sandboxRetainedProcesses.providerBindingKey),
+          isNull6(sandboxRetainedProcesses.providerBinding)
         )
       ).returning();
       if (!updated) {
@@ -31893,7 +32650,7 @@ async function setEnrollmentDisplayState(db, input) {
           // Only write on a CHANGE to EITHER field — an unchanged display state must
           // not churn a write on every reconnect Hello. `IS DISTINCT FROM` is the
           // null-safe inequality (a plain `ne` skips NULL rows).
-          or4(
+          or6(
             ne(enrollments.hasDisplay, input.hasDisplay),
             sql14`${enrollments.desktopUnavailableReason} IS DISTINCT FROM ${input.desktopUnavailableReason}`
           )
@@ -32588,7 +33345,7 @@ async function forceDrainOverLimitViewerOnlyBoxes(db, input) {
         and17(
           eq17(usageEvents.workspaceId, input.workspaceId),
           eq17(usageEvents.eventType, "sandbox.warm_seconds"),
-          gt4(usageEvents.occurredAt, since)
+          gt5(usageEvents.occurredAt, since)
         )
       );
       if (Number(total) >= input.maxWarmSecondsPerWorkspace) {
@@ -34575,7 +35332,7 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
             "acknowledged",
             "settled"
           ]),
-          isNull5(sessionTurnAttempts.quiescedAt)
+          isNull6(sessionTurnAttempts.quiescedAt)
         )
       ).orderBy(desc8(sessionAttemptInterruptions.requestedAt)).limit(1);
       if (unquiescedInterruption) {
@@ -34623,7 +35380,7 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
               eq17(sessions.accountId, session.accountId),
               eq17(sessions.workspaceId, workspaceId),
               eq17(sessions.id, sessionId),
-              isNull5(sessions.activeTurnId)
+              isNull6(sessions.activeTurnId)
             )
           ).returning({ id: sessions.id });
           if (!claimedSession) {
@@ -35328,11 +36085,10 @@ async function claimSessionWorkForAttempt(db, workspaceId, input) {
         sessionId,
         turnId: row.id,
         position: Number(historyPosition),
-        item: sanitizeModelPayload({
-          type: "message",
-          role: "user",
-          content: row.prompt
-        }),
+        item: durableUserHistoryItem(
+          row.prompt,
+          Array.isArray(row.resources) ? row.resources : []
+        ),
         producerCodexCredentialId: null
       });
       const providerDelegatedTurn = isSessionRealtimeDelegationTurnMetadata(row.metadata);
@@ -35449,7 +36205,7 @@ async function markSessionAttemptQuiesced(db, input) {
       and17(
         eq17(sessionTurnAttempts.workspaceId, input.workspaceId),
         eq17(sessionTurnAttempts.id, input.attemptId),
-        isNull5(sessionTurnAttempts.quiescedAt)
+        isNull6(sessionTurnAttempts.quiescedAt)
       )
     ).returning({ id: sessionTurnAttempts.id });
     if (!marked) {
@@ -35987,7 +36743,7 @@ async function peekSessionWork(db, workspaceId, sessionId) {
               "user.approvalDecision",
               "user.humanInputResponse"
             ]),
-            gt4(sessionEvents.sequence, currentTrigger.sequence)
+            gt5(sessionEvents.sequence, currentTrigger.sequence)
           )
         ).orderBy(desc8(sessionEvents.sequence), desc8(sessionEvents.id)).limit(1);
         if (actionResponse) {
@@ -36452,11 +37208,11 @@ async function applySessionTurnSettlement(db, workspaceId, input, hooks = {}) {
           activeTurnId: session.activeTurnId
         };
       }
+      const humanInputRequests = input.runState?.humanInputRequests ?? [];
       if (input.runState) {
         if (input.turnStatus !== "requires_action" || input.sessionStatus !== "requires_action") {
           throw new Error("A frozen run state requires a requires_action settlement");
         }
-        const humanInputRequests = input.runState.humanInputRequests ?? [];
         for (const request of humanInputRequests) {
           const parsedQuestions = request.questions.map(
             (question) => HumanInputQuestionContract.parse(question)
@@ -36656,7 +37412,10 @@ async function applySessionTurnSettlement(db, workspaceId, input, hooks = {}) {
           eq17(sessionHumanInputRequests.turnId, input.turnId),
           eq17(sessionHumanInputRequests.status, "pending")
         )
-      ).returning({ id: sessionHumanInputRequests.id }) : [];
+      ).returning({
+        id: sessionHumanInputRequests.id,
+        questions: sessionHumanInputRequests.questions
+      }) : [];
       const terminalHumanInputEvents = terminalHumanInputRows.map(
         (request) => ({
           type: "user.humanInputResponse",
@@ -36721,6 +37480,69 @@ async function applySessionTurnSettlement(db, workspaceId, input, hooks = {}) {
         };
       });
       const inserted = values.length > 0 ? await tx.insert(sessionEvents).values(values).returning() : [];
+      const requestedEvents = inserted.filter(
+        (event) => event.type === "session.humanInput.requested"
+      );
+      if (requestedEvents.length > 0) {
+        const requestedIds = new Set(
+          requestedEvents.flatMap((event) => {
+            const request = sessionEventPayloadRecord(event.payload).request;
+            if (!request || typeof request !== "object" || Array.isArray(request)) return [];
+            const id = request.id;
+            return typeof id === "string" ? [id] : [];
+          })
+        );
+        const requests = humanInputRequests.filter((request) => requestedIds.has(request.id));
+        if (requests.length !== requestedIds.size) {
+          throw new Error("Human-input realtime projection lost its durable request contract");
+        }
+        await mirrorSessionRealtimeContextInTransaction(tx, {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId: input.sessionId,
+          sourceKind: "human_input_request",
+          sourceId: requestedEvents.map((event) => event.id).join(":"),
+          turnId: input.turnId,
+          channel: "speakable",
+          text: renderRealtimeHumanInputRequestContext({ requests }),
+          payload: {
+            status: "waiting_for_user",
+            requestIds: requests.map((request) => request.id),
+            sourceEventIds: requestedEvents.map((event) => event.id)
+          },
+          now
+        });
+      }
+      const terminalHumanInputById = new Map(
+        terminalHumanInputRows.map((request) => [request.id, request])
+      );
+      for (const event of inserted) {
+        if (event.type !== "user.humanInputResponse") continue;
+        const payload = sessionEventPayloadRecord(event.payload);
+        const requestId = typeof payload.requestId === "string" ? payload.requestId : null;
+        const request = requestId ? terminalHumanInputById.get(requestId) : null;
+        if (!request) continue;
+        await mirrorSessionRealtimeContextInTransaction(tx, {
+          accountId: session.accountId,
+          workspaceId,
+          sessionId: input.sessionId,
+          sourceKind: "human_input_response",
+          sourceId: event.id,
+          turnId: input.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 terminal = isTerminalSessionTurnStatus(input.turnStatus);
       if (isTerminalSessionTurnStatus(input.turnStatus)) {
         const terminalType = terminalSessionTurnEventType(input.turnStatus);
@@ -37217,7 +38039,7 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
               sessionHistoryItems.producerCodexCredentialId,
               input.providerArtifactInvalidation.codexCredentialId
             ),
-            isNull5(sessionHistoryItems.providerArtifactInvalidatedAt),
+            isNull6(sessionHistoryItems.providerArtifactInvalidatedAt),
             sql14`${sessionHistoryItems.item} ->> 'type' in ('reasoning', 'compaction')`
           )
         ).returning({ id: sessionHistoryItems.id });
@@ -37231,7 +38053,7 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
               agentRunStates.frozenCodexCredentialId,
               input.providerArtifactInvalidation.codexCredentialId
             ),
-            isNull5(agentRunStates.providerArtifactInvalidatedAt)
+            isNull6(agentRunStates.providerArtifactInvalidatedAt)
           )
         ).orderBy(desc8(agentRunStates.stateVersion)).limit(1);
         const invalidatedRunState = latestRunState ? await tx.update(agentRunStates).set({
@@ -37241,7 +38063,7 @@ async function requestSessionTurnRecovery(db, workspaceId, input) {
         }).where(
           and17(
             eq17(agentRunStates.id, latestRunState.id),
-            isNull5(agentRunStates.providerArtifactInvalidatedAt)
+            isNull6(agentRunStates.providerArtifactInvalidatedAt)
           )
         ).returning({ id: agentRunStates.id }) : [];
         providerArtifactsInvalidated = invalidatedHistory.length + invalidatedRunState.length;
@@ -38029,7 +38851,7 @@ async function markSessionWorkflowWakeDelivered(db, input) {
           and17(
             eq17(sessionTurnAttempts.workspaceId, input.workspaceId),
             eq17(sessionTurnAttempts.sessionId, input.sessionId),
-            isNull5(sessionTurnAttempts.quiescedAt),
+            isNull6(sessionTurnAttempts.quiescedAt),
             inArray11(sessionAttemptInterruptions.state, ["settled", "rejected_stale"])
           )
         ).limit(1);
@@ -39744,6 +40566,8 @@ export {
   CODEX_CREDENTIAL_LEASE_TTL_MS,
   CODEX_RESET_REDEMPTION_OUTCOMES,
   CODEX_ROTATION_STRATEGIES,
+  ConnectionDisconnectGenerationError,
+  ConnectionDisconnectIdempotencyError,
   ConnectionRefreshHttpError,
   FORCE_RLS_TABLES,
   GitHubInstallationAuthorityCommitError,
@@ -39852,6 +40676,7 @@ export {
   WorkspaceInstructionPolicyInvalidOperationError,
   WorkspaceInstructionPolicyLegacyUnavailableError,
   WorkspaceInstructionPolicyNotFoundError,
+  WorkspaceInstructionPolicyOperationReuseError,
   WorkspaceInstructionPolicySnapshotAuthorityError,
   abandonCodexResetRedemptionBeforeProvider,
   abandonRecordingForTurnAttempt,
@@ -40053,6 +40878,8 @@ export {
   disableHostExportConsumer,
   disconnectAllCodexAccounts,
   disconnectCodexAccount,
+  disconnectConnectionIdempotently,
+  durableUserHistoryItem,
   editQueuedTurnInTransaction,
   enableCapabilityInstallation,
   enablePackInstallation,
@@ -40101,11 +40928,13 @@ export {
   getCodexRotationSettings,
   getComposerDraftInTransaction,
   getConnectionMetadata,
+  getCurrentPreferenceRegistryGovernanceMetadata,
   getDeviceEnrollmentRequestByDeviceCode,
   getEligibleKnowledgeClaim,
   getEnrollment,
   getFile,
   getFileUpload,
+  getFiles,
   getHostExportConsumerStatus,
   getHumanInputResumeForEvent,
   getKnowledgeMemory,
@@ -40188,6 +41017,7 @@ export {
   getWorkspaceInstructionPolicyRevision,
   getWorkspaceModelPolicy,
   getWorkspacePack,
+  getWorkspaceStateAcceptedAttemptGovernance,
   grantWorkspaceAccess,
   hasAuditableGitHubInstallationAuthority,
   hasCreditLedgerEntry,
@@ -40422,6 +41252,7 @@ export {
   reserveSessionCommandReceipt,
   reserveToolspaceCallForAttempt,
   resolveConnectorActionPolicy,
+  resolveDocumentIndexAuthority,
   resolveSlackInstallationRoute,
   resolveWorkspaceMemoryBlock,
   restoreKnowledgeSourceObject,
@@ -40514,6 +41345,7 @@ export {
   syncSessionRealtimeLedgerInTransaction,
   touchEnrollmentLastSeen,
   touchLeaseHolder,
+  transitionConnectionState,
   updateCodexAllocatorEligibility,
   updateCodexRotationSettings,
   updateConnection,