@opengeni/db 0.7.3 → 0.9.3

package/dist/schema.d.ts

@@ -1,3 +1,3 @@
 import 'drizzle-orm';
 import 'drizzle-orm/pg-core';
-export { m as agentRunStates, n as apiKeys, o as auditEvents, p as billingCustomers, q as capabilityCatalogItems, r as capabilityInstallations, t as codexCapacityWaiters, u as codexCredentialLeases, v as codexRotationSettings, w as codexSubscriptionCredentials, c as composerDrafts, x as connections, y as creditLedgerEntries, z as deviceEnrollmentRequests, g as deviceEnrollmentStatusValues, A as documentBases, B as documentChunks, C as documents, f as enrollmentExposureValues, e as enrollmentOsValues, h as enrollmentStatusValues, D as enrollments, E as fileUploads, F as files, G as githubInstallations, H as importBatches, I as integrationOauthClients, J as integrationOauthStateNonces, K as knowledgeMemories, L as machineMetricsLatest, M as machineMetricsSeries, N as managedAccounts, O as packInstallations, P as rigChanges, Q as rigVersions, R as rigs, i as sandboxKindValues, S as sandboxLeaseHolders, T as sandboxLeaseLivenessValues, U as sandboxLeases, V as sandboxPtySessions, W as sandboxSessionEnvelopes, X as sandboxes, Y as scheduledTaskRuns, Z as scheduledTasks, _ as sessionAttemptInterruptions, s as sessionCommandReceipts, $ as sessionEvents, a0 as sessionGoals, a1 as sessionHistoryItems, a2 as sessionListSnapshots, a3 as sessionMcpServers, a4 as sessionPendingToolCalls, a5 as sessionPins, j as sessionRecordingCodecValues, k as sessionRecordingModeValues, l as sessionRecordingStateValues, a6 as sessionRecordings, a7 as sessionSystemUpdateOutbox, a8 as sessionSystemUpdates, a as sessionTurnAttempts, b as sessionTurns, a9 as sessionWorkflowWakeOutbox, aa as sessions, ab as socialConnections, ac as socialPosts, ad as stripeWebhookEvents, ae as usageEvents, af as workspaceCaptures, ag as workspaceControlEvents, ah as workspaceInferenceControls, ai as workspaceMemberships, aj as workspaceModelPolicies, ak as workspacePacks, al as workspaceVariableSetVariables, am as workspaceVariableSets, an as workspaces } from './schema-BN5mB9xZ.js';
+export { n as agentRunStates, o as apiKeys, p as auditEvents, q as billingCustomers, r as capabilityCatalogItems, t as capabilityInstallations, u as codexCapacityWaiters, v as codexCredentialLeases, x as codexRotationSettings, y as codexSubscriptionCredentials, d as composerDrafts, z as connections, A as creditLedgerEntries, B as deviceEnrollmentRequests, h as deviceEnrollmentStatusValues, C as documentBases, D as documentChunks, E as documents, g as enrollmentExposureValues, f as enrollmentOsValues, i as enrollmentStatusValues, F as enrollments, G as fileUploads, H as files, I as githubInstallationRepositories, J as githubInstallations, K as hostExportConfig, L as hostExportConsumers, M as hostExportCursorState, N as hostExportDeadLetters, O as hostExportOutbox, P as importBatches, Q as integrationOauthClients, R as integrationOauthStateNonces, S as knowledgeMemories, T as machineMetricsLatest, U as machineMetricsSeries, V as managedAccounts, W as packInstallations, X as rigChanges, Y as rigVersions, Z as rigs, j as sandboxKindValues, _ as sandboxLeaseHolders, $ as sandboxLeaseLivenessValues, a0 as sandboxLeases, a1 as sandboxPtySessions, a2 as sandboxSessionEnvelopes, a3 as sandboxes, a4 as scheduledTaskRuns, a5 as scheduledTasks, a6 as sessionAttemptInterruptions, s as sessionCommandReceipts, a7 as sessionEvents, a8 as sessionGoals, a9 as sessionHistoryItems, aa as sessionHumanInputRequests, ab as sessionListSnapshots, ac as sessionMcpServers, ad as sessionPendingToolCalls, ae as sessionPins, k as sessionRecordingCodecValues, l as sessionRecordingModeValues, m as sessionRecordingStateValues, af as sessionRecordings, ag as sessionSystemUpdateOutbox, ah as sessionSystemUpdates, c as sessionTurnAttempts, b as sessionTurns, ai as sessionWorkflowWakeOutbox, a as sessions, aj as socialConnections, ak as socialPosts, al as stripeWebhookEvents, am as usageEvents, an as workspaceCaptures, ao as workspaceControlEvents, ap as workspaceInferenceControls, aq as workspaceMemberships, ar as workspaceModelPolicies, as as workspacePacks, at as workspaceSessionActivityRevisions, au as workspaceVariableSetVariables, av as workspaceVariableSets, w as workspaces } from './schema-CdPGTHlD.js';

package/dist/schema.js

@@ -23,7 +23,13 @@ import {
   enrollments,
   fileUploads,
   files,
+  githubInstallationRepositories,
   githubInstallations,
+  hostExportConfig,
+  hostExportConsumers,
+  hostExportCursorState,
+  hostExportDeadLetters,
+  hostExportOutbox,
   importBatches,
   integrationOauthClients,
   integrationOauthStateNonces,
@@ -49,6 +55,7 @@ import {
   sessionEvents,
   sessionGoals,
   sessionHistoryItems,
+  sessionHumanInputRequests,
   sessionListSnapshots,
   sessionMcpServers,
   sessionPendingToolCalls,
@@ -73,10 +80,11 @@ import {
   workspaceMemberships,
   workspaceModelPolicies,
   workspacePacks,
+  workspaceSessionActivityRevisions,
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces
-} from "./chunk-B22X3IEZ.js";
+} from "./chunk-4LG5NBTC.js";
 import "./chunk-PZ5AY32C.js";
 export {
   agentRunStates,
@@ -103,7 +111,13 @@ export {
   enrollments,
   fileUploads,
   files,
+  githubInstallationRepositories,
   githubInstallations,
+  hostExportConfig,
+  hostExportConsumers,
+  hostExportCursorState,
+  hostExportDeadLetters,
+  hostExportOutbox,
   importBatches,
   integrationOauthClients,
   integrationOauthStateNonces,
@@ -129,6 +143,7 @@ export {
   sessionEvents,
   sessionGoals,
   sessionHistoryItems,
+  sessionHumanInputRequests,
   sessionListSnapshots,
   sessionMcpServers,
   sessionPendingToolCalls,
@@ -153,6 +168,7 @@ export {
   workspaceMemberships,
   workspaceModelPolicies,
   workspacePacks,
+  workspaceSessionActivityRevisions,
   workspaceVariableSetVariables,
   workspaceVariableSets,
   workspaces

package/drizzle/0064_rotation_strategy_sharded_backfill.sql

@@ -0,0 +1,15 @@
+-- deployment-mode: rolling
+-- OPE-36: the strategy picker is gone — rotation-enabled always behaves as
+-- sticky-sharded (worker-side effectiveRotationStrategy normalizes every read).
+-- Backfill stored legacy values so the column tells the truth going forward.
+-- The column itself is KEPT (old-binary rollback safety): an old worker reading
+-- 'sharded' runs the strategy that was already live on every real workspace.
+
+SET lock_timeout = '5s';
+SET statement_timeout = '10min';
+
+UPDATE "codex_rotation_settings"
+SET "rotation_strategy" = 'sharded'
+WHERE "rotation_strategy" IS DISTINCT FROM 'sharded';
+
+ALTER TABLE "codex_rotation_settings" ALTER COLUMN "rotation_strategy" SET DEFAULT 'sharded';

package/drizzle/0065_session_attempt_quiescence.sql

@@ -0,0 +1,26 @@
+-- deployment-mode: maintenance
+-- A cancelled attempt records the exact boundary after which it has no
+-- inference, user-visible output, or workspace-persistence authority.
+-- Fenced/idempotent cleanup and telemetry may still finish. Temporal
+-- independently waits for the activity to terminate; this receipt lets queue
+-- admission and UI state use durable truth.
+
+SET lock_timeout = '5s';
+SET statement_timeout = '5min';
+
+ALTER TABLE "session_turn_attempts"
+  ADD COLUMN "quiesced_at" timestamptz;
+
+-- Maintenance mode drains the pre-cutover workers before this backfill, so an
+-- interrupted attempt that is already closed has also left its physical
+-- activity. Seed only that historical population; new activity/workflow code
+-- owns all later receipts.
+UPDATE "session_turn_attempts" AS attempt
+SET "quiesced_at" = COALESCE(attempt."closed_at", attempt."updated_at", now())
+WHERE attempt."state" = 'closed'
+  AND EXISTS (
+    SELECT 1
+    FROM "session_attempt_interruptions" AS interruption
+    WHERE interruption."workspace_id" = attempt."workspace_id"
+      AND interruption."attempt_id" = attempt."id"
+  );

package/drizzle/0066_session_interruption_attempt_lookup.sql

@@ -0,0 +1,4 @@
+-- deployment-mode: rolling
+-- opengeni:concurrent-index lock-timeout=5s
+CREATE INDEX CONCURRENTLY "session_attempt_interruptions_attempt_lookup_idx"
+  ON "session_attempt_interruptions" ("workspace_id", "session_id", "attempt_id", "requested_at" DESC);

package/drizzle/0067_session_event_payload_bounds.sql

@@ -0,0 +1,209 @@
+-- deployment-mode: rolling
+-- OPE-64: session_events is the lossy human/audit projection, not a blob store.
+-- Install the BEFORE trigger before the NOT VALID check so an older pod in the
+-- same rolling deployment is normalized instead of having an oversized write
+-- rejected. Historical oversized rows stay readable and can be defensively
+-- bounded by NATS/SSE; NOT VALID enforces the invariant for every new row.
+
+SET lock_timeout = '5s';
+SET statement_timeout = '10min';
+
+CREATE OR REPLACE FUNCTION opengeni_private.project_session_event_payload(source_payload jsonb)
+RETURNS jsonb
+LANGUAGE plpgsql
+IMMUTABLE
+SET search_path = pg_catalog
+AS $function$
+DECLARE
+  original_bytes integer;
+  delivered_bytes integer;
+  bounded jsonb;
+BEGIN
+  original_bytes := octet_length(source_payload::text);
+  IF original_bytes <= 65536 THEN
+    RETURN source_payload;
+  END IF;
+
+  -- This is intentionally a small content-free fallback. Normal application
+  -- writers produce richer deterministic head/tail previews before INSERT; the
+  -- trigger exists for rolling old binaries and unforeseen direct writers.
+  bounded := jsonb_strip_nulls(jsonb_build_object(
+    'id', left(source_payload ->> 'id', 256),
+    'name', left(coalesce(source_payload ->> 'name', source_payload ->> 'toolName'), 256),
+    'type', left(source_payload ->> 'type', 128),
+    'status', left(source_payload ->> 'status', 128),
+    'code', left(source_payload ->> 'code', 128),
+    'isError', source_payload -> 'isError',
+    'preview', '[event payload omitted by durable audit storage guard]',
+    'truncation', jsonb_build_object(
+      'truncated', true,
+      'surface', 'database_guard',
+      'reason', 'database_guard',
+      'originalBytes', original_bytes,
+      'deliveredBytes', 0,
+      'omittedBytes', original_bytes,
+      'estimatedOriginalTokens', ceil(original_bytes / 4.0)::integer,
+      'estimatedDeliveredTokens', 0,
+      'fullEvidence', jsonb_build_object('available', false, 'reason', 'not_retained'),
+      'details', jsonb_build_array(jsonb_build_object(
+        'path', '$',
+        'kind', 'object',
+        'originalBytes', original_bytes
+      ))
+    )
+  ));
+
+  -- Size fields affect their own JSON width. Converge to an exact fixed point
+  -- without retaining any omitted content; fail the write rather than publish
+  -- false accounting if PostgreSQL's representation ever stops converging.
+  FOR pass IN 1..8 LOOP
+    delivered_bytes := octet_length(bounded::text);
+    EXIT WHEN (bounded #>> '{truncation,deliveredBytes}')::integer = delivered_bytes
+      AND (bounded #>> '{truncation,omittedBytes}')::integer
+        = greatest(0, original_bytes - delivered_bytes)
+      AND (bounded #>> '{truncation,estimatedDeliveredTokens}')::integer
+        = ceil(delivered_bytes / 4.0)::integer;
+    bounded := jsonb_set(bounded, '{truncation,deliveredBytes}', to_jsonb(delivered_bytes), false);
+    bounded := jsonb_set(
+      bounded,
+      '{truncation,omittedBytes}',
+      to_jsonb(greatest(0, original_bytes - delivered_bytes)),
+      false
+    );
+    bounded := jsonb_set(
+      bounded,
+      '{truncation,estimatedDeliveredTokens}',
+      to_jsonb(ceil(delivered_bytes / 4.0)::integer),
+      false
+    );
+  END LOOP;
+
+  delivered_bytes := octet_length(bounded::text);
+  IF (bounded #>> '{truncation,deliveredBytes}')::integer <> delivered_bytes
+    OR (bounded #>> '{truncation,omittedBytes}')::integer
+      <> greatest(0, original_bytes - delivered_bytes)
+    OR (bounded #>> '{truncation,estimatedDeliveredTokens}')::integer
+      <> ceil(delivered_bytes / 4.0)::integer THEN
+    RAISE EXCEPTION 'session event payload accounting failed to converge';
+  END IF;
+
+  RETURN bounded;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION opengeni_private.bound_session_event_payload()
+RETURNS trigger
+LANGUAGE plpgsql
+SET search_path = pg_catalog
+AS $function$
+DECLARE
+  original_type text := NEW.type;
+  original_event_bytes integer;
+  fields jsonb := '[]'::jsonb;
+  delivered text;
+BEGIN
+  original_event_bytes := octet_length(row_to_json(NEW)::text);
+  -- Bound every free-form envelope string by UTF-8 bytes. left() uses
+  -- characters, so one quarter of each byte limit is a conservative bound for
+  -- both ASCII and four-byte Unicode without ever splitting a code point.
+  IF octet_length(NEW.type) > 256 OR position(E'\n' in NEW.type) > 0
+    OR position(E'\r' in NEW.type) > 0 THEN
+    delivered := 'session.event.envelope_omitted';
+    fields := fields || jsonb_build_array(jsonb_build_object(
+      'field', 'type',
+      'originalBytes', octet_length(NEW.type),
+      'deliveredBytes', octet_length(delivered)
+    ));
+    NEW.type := delivered;
+  END IF;
+
+  IF NEW.client_event_id IS NOT NULL AND octet_length(NEW.client_event_id) > 1024 THEN
+    delivered := left(NEW.client_event_id, 256);
+    fields := fields || jsonb_build_array(jsonb_build_object(
+      'field', 'clientEventId',
+      'originalBytes', octet_length(NEW.client_event_id),
+      'deliveredBytes', octet_length(delivered)
+    ));
+    NEW.client_event_id := delivered;
+  END IF;
+
+  IF NEW.producer_id IS NOT NULL AND octet_length(NEW.producer_id) > 1024 THEN
+    delivered := left(NEW.producer_id, 256);
+    fields := fields || jsonb_build_array(jsonb_build_object(
+      'field', 'producerId',
+      'originalBytes', octet_length(NEW.producer_id),
+      'deliveredBytes', octet_length(delivered)
+    ));
+    NEW.producer_id := delivered;
+  END IF;
+
+  IF NEW.turn_association IS NOT NULL AND NEW.turn_association NOT IN (
+    'current', 'late_rejected', 'duplicate'
+  ) THEN
+    fields := fields || jsonb_build_array(jsonb_build_object(
+      'field', 'turnAssociation',
+      'originalBytes', octet_length(NEW.turn_association),
+      'deliveredBytes', 0
+    ));
+    NEW.turn_association := NULL;
+  END IF;
+
+  IF NEW.duplicate_reason IS NOT NULL AND octet_length(NEW.duplicate_reason) > 4096 THEN
+    delivered := left(NEW.duplicate_reason, 1024);
+    fields := fields || jsonb_build_array(jsonb_build_object(
+      'field', 'duplicateReason',
+      'originalBytes', octet_length(NEW.duplicate_reason),
+      'deliveredBytes', octet_length(delivered)
+    ));
+    NEW.duplicate_reason := delivered;
+  END IF;
+
+  IF jsonb_array_length(fields) > 0 THEN
+    NEW.payload := jsonb_build_object(
+      'preview', '[legacy event envelope normalized by durable audit storage guard]',
+      'originalEventBytes', original_event_bytes,
+      'originalType', left(original_type, 64),
+      'envelopeProjection', jsonb_build_object(
+        'truncated', true,
+        'surface', 'database_guard',
+        'fields', fields
+      ),
+      'fullEvidence', jsonb_build_object('available', false, 'reason', 'not_retained')
+    );
+  END IF;
+
+  NEW.payload := opengeni_private.project_session_event_payload(NEW.payload);
+  RETURN NEW;
+END;
+$function$;
+
+DROP TRIGGER IF EXISTS session_events_bound_payload_before_insert ON session_events;
+CREATE TRIGGER session_events_bound_payload_before_insert
+BEFORE INSERT OR UPDATE OF payload, type, client_event_id, producer_id, turn_association, duplicate_reason
+ON session_events
+FOR EACH ROW
+EXECUTE FUNCTION opengeni_private.bound_session_event_payload();
+
+ALTER TABLE session_events
+  ADD CONSTRAINT session_events_payload_bytes_check
+  CHECK (octet_length(payload::text) <= 65536)
+  NOT VALID,
+  ADD CONSTRAINT session_events_type_bytes_check
+  CHECK (
+    octet_length(type) <= 256
+    AND position(E'\n' in type) = 0
+    AND position(E'\r' in type) = 0
+  )
+  NOT VALID,
+  ADD CONSTRAINT session_events_client_event_id_bytes_check
+  CHECK (client_event_id IS NULL OR octet_length(client_event_id) <= 1024)
+  NOT VALID,
+  ADD CONSTRAINT session_events_producer_id_bytes_check
+  CHECK (producer_id IS NULL OR octet_length(producer_id) <= 1024)
+  NOT VALID,
+  ADD CONSTRAINT session_events_turn_association_bytes_check
+  CHECK (turn_association IS NULL OR octet_length(turn_association) <= 64)
+  NOT VALID,
+  ADD CONSTRAINT session_events_duplicate_reason_bytes_check
+  CHECK (duplicate_reason IS NULL OR octet_length(duplicate_reason) <= 4096)
+  NOT VALID;

package/drizzle/0068_workspace_control_event_bounds.sql

@@ -0,0 +1,134 @@
+-- deployment-mode: rolling
+-- OPE-64: workspace-control rows are compact invalidations, not evidence blobs.
+-- Preserve exact source byte counts while bounding the two free-form fields so
+-- old binaries and direct writers cannot create a durable replay poison row.
+
+SET lock_timeout = '5s';
+SET statement_timeout = '10min';
+
+ALTER TABLE workspace_control_events
+  ADD COLUMN reason_original_bytes integer,
+  ADD COLUMN actor_original_bytes integer;
+
+CREATE OR REPLACE FUNCTION opengeni_private.truncate_workspace_control_text(
+  source_text text,
+  max_bytes integer
+)
+RETURNS text
+LANGUAGE plpgsql
+IMMUTABLE
+STRICT
+SET search_path = pg_catalog
+AS $function$
+DECLARE
+  marker constant text := '…[truncated]';
+  prefix_budget integer := greatest(0, max_bytes - octet_length(marker));
+  candidate text;
+  excess integer;
+BEGIN
+  IF octet_length(source_text) <= max_bytes THEN
+    RETURN source_text;
+  END IF;
+
+  -- left() is character-safe. Starting at at most prefix_budget characters
+  -- caps allocation even for a multi-megabyte legacy value; each pass removes
+  -- enough characters for the worst-case four-byte UTF-8 encoding.
+  candidate := left(source_text, prefix_budget);
+  WHILE octet_length(candidate) > prefix_budget LOOP
+    excess := octet_length(candidate) - prefix_budget;
+    candidate := left(candidate, greatest(0, char_length(candidate) - ceil(excess / 4.0)::integer));
+  END LOOP;
+  RETURN candidate || marker;
+END;
+$function$;
+
+CREATE OR REPLACE FUNCTION opengeni_private.bound_workspace_control_event()
+RETURNS trigger
+LANGUAGE plpgsql
+SET search_path = pg_catalog
+AS $function$
+DECLARE
+  source_bytes integer;
+BEGIN
+  IF NEW.reason IS NULL THEN
+    NEW.reason_original_bytes := NULL;
+  ELSE
+    source_bytes := octet_length(NEW.reason);
+    IF TG_OP = 'INSERT' THEN
+      NEW.reason_original_bytes := greatest(source_bytes, coalesce(NEW.reason_original_bytes, 0));
+    ELSIF NEW.reason IS DISTINCT FROM OLD.reason THEN
+      -- An update from an old binary carries the old metadata column even
+      -- though it knows only `reason`. A genuinely changed raw value starts a
+      -- new byte fact instead of inheriting the previous value's larger count.
+      NEW.reason_original_bytes := source_bytes;
+    ELSE
+      NEW.reason_original_bytes := greatest(
+        source_bytes,
+        coalesce(NEW.reason_original_bytes, OLD.reason_original_bytes, 0)
+      );
+    END IF;
+    NEW.reason := opengeni_private.truncate_workspace_control_text(NEW.reason, 8192);
+  END IF;
+
+  source_bytes := octet_length(NEW.actor);
+  IF TG_OP = 'INSERT' THEN
+    NEW.actor_original_bytes := greatest(source_bytes, coalesce(NEW.actor_original_bytes, 0));
+  ELSIF NEW.actor IS DISTINCT FROM OLD.actor THEN
+    NEW.actor_original_bytes := source_bytes;
+  ELSE
+    NEW.actor_original_bytes := greatest(
+      source_bytes,
+      coalesce(NEW.actor_original_bytes, OLD.actor_original_bytes, 0)
+    );
+  END IF;
+  NEW.actor := opengeni_private.truncate_workspace_control_text(NEW.actor, 1024);
+  RETURN NEW;
+END;
+$function$;
+
+CREATE TRIGGER workspace_control_events_bound_fields
+BEFORE INSERT OR UPDATE OF reason, actor, reason_original_bytes, actor_original_bytes
+ON workspace_control_events
+FOR EACH ROW EXECUTE FUNCTION opengeni_private.bound_workspace_control_event();
+
+-- Rewrite only historical rows that violate the new durable caps. Already
+-- bounded rows are safe to serve as-is and retain null metadata as the explicit
+-- rolling-upgrade legacy shape; avoiding a blanket UPDATE keeps installation
+-- work proportional to poison rows instead of table cardinality. The original
+-- counts are supplied in the same statement so truncation never erases truth.
+UPDATE workspace_control_events
+SET
+  reason_original_bytes = CASE WHEN reason IS NULL THEN NULL ELSE octet_length(reason) END,
+  actor_original_bytes = octet_length(actor),
+  reason = reason,
+  actor = actor
+WHERE octet_length(reason) > 8192
+   OR octet_length(actor) > 1024;
+
+ALTER TABLE workspace_control_events
+  ADD CONSTRAINT workspace_control_events_reason_bytes_check
+    CHECK (reason IS NULL OR octet_length(reason) <= 8192) NOT VALID,
+  ADD CONSTRAINT workspace_control_events_actor_bytes_check
+    CHECK (octet_length(actor) <= 1024) NOT VALID,
+  ADD CONSTRAINT workspace_control_events_original_bytes_check
+    CHECK (
+      (reason IS NULL AND reason_original_bytes IS NULL)
+      OR (
+        reason IS NOT NULL
+        AND (
+          reason_original_bytes IS NULL
+          OR reason_original_bytes >= octet_length(reason)
+        )
+      )
+    ) NOT VALID,
+  ADD CONSTRAINT workspace_control_events_actor_original_bytes_check
+    CHECK (
+      actor_original_bytes IS NULL
+      OR actor_original_bytes >= octet_length(actor)
+    ) NOT VALID;
+
+ALTER TABLE workspace_control_events
+  VALIDATE CONSTRAINT workspace_control_events_reason_bytes_check,
+  VALIDATE CONSTRAINT workspace_control_events_actor_bytes_check,
+  VALIDATE CONSTRAINT workspace_control_events_original_bytes_check,
+  VALIDATE CONSTRAINT workspace_control_events_actor_original_bytes_check;

package/drizzle/0069_session_event_history_backfill.sql

@@ -0,0 +1,32 @@
+-- deployment-mode: rolling
+-- OPE-64: finish the 0067 expand/contract sequence. The trigger has bounded
+-- every new/updated row since 0067; now rewrite only legacy violations through
+-- that trigger and validate the durable storage invariant.
+
+SET lock_timeout = '5s';
+SET statement_timeout = '10min';
+
+UPDATE session_events
+SET
+  payload = payload,
+  type = type,
+  client_event_id = client_event_id,
+  producer_id = producer_id,
+  turn_association = turn_association,
+  duplicate_reason = duplicate_reason
+WHERE octet_length(payload::text) > 65536
+  OR octet_length(type) > 256
+  OR position(E'\n' in type) > 0
+  OR position(E'\r' in type) > 0
+  OR (client_event_id IS NOT NULL AND octet_length(client_event_id) > 1024)
+  OR (producer_id IS NOT NULL AND octet_length(producer_id) > 1024)
+  OR (turn_association IS NOT NULL AND octet_length(turn_association) > 64)
+  OR (duplicate_reason IS NOT NULL AND octet_length(duplicate_reason) > 4096);
+
+ALTER TABLE session_events
+  VALIDATE CONSTRAINT session_events_payload_bytes_check,
+  VALIDATE CONSTRAINT session_events_type_bytes_check,
+  VALIDATE CONSTRAINT session_events_client_event_id_bytes_check,
+  VALIDATE CONSTRAINT session_events_producer_id_bytes_check,
+  VALIDATE CONSTRAINT session_events_turn_association_bytes_check,
+  VALIDATE CONSTRAINT session_events_duplicate_reason_bytes_check;

package/drizzle/0070_session_event_type_sequence_lookup.sql

@@ -0,0 +1,4 @@
+-- deployment-mode: rolling
+-- opengeni:concurrent-index lock-timeout=5s
+CREATE INDEX CONCURRENTLY "session_events_workspace_session_type_sequence_idx"
+  ON "session_events" ("workspace_id", "session_id", "type", "sequence" DESC);

package/drizzle/0071_session_event_monitoring_tail.sql

@@ -0,0 +1,10 @@
+-- deployment-mode: rolling
+-- opengeni:concurrent-index lock-timeout=5s
+CREATE INDEX CONCURRENTLY "session_events_workspace_session_monitoring_tail_idx"
+  ON "session_events" ("workspace_id", "session_id", "sequence" DESC)
+  WHERE "type" NOT IN (
+    'agent.message.delta',
+    'agent.reasoning.delta',
+    'sandbox.command.output.delta',
+    'terminal.pty.output.delta'
+  );

package/drizzle/0072_sessions_workspace_created_id_idx.sql

@@ -0,0 +1,4 @@
+-- deployment-mode: rolling
+-- opengeni:concurrent-index lock-timeout=5s
+CREATE INDEX CONCURRENTLY "sessions_workspace_created_id_idx"
+  ON "sessions" ("workspace_id", "created_at" DESC, "id" DESC);

package/drizzle/0073_sessions_workspace_updated_id_idx.sql

@@ -0,0 +1,4 @@
+-- deployment-mode: rolling
+-- opengeni:concurrent-index lock-timeout=5s
+CREATE INDEX CONCURRENTLY "sessions_workspace_updated_id_idx"
+  ON "sessions" ("workspace_id", "updated_at" DESC, "id" DESC);

package/drizzle/0074_session_activity_revisions.sql

@@ -0,0 +1,72 @@
+-- deployment-mode: rolling
+-- OPE-65: transactional workspace revisions make updated-order discovery and
+-- its next incremental scan one gap-free handoff independent of application
+-- clocks. Existing sessions remain revision zero until their next activity.
+
+SET lock_timeout = '5s';
+SET statement_timeout = '10min';
+
+CREATE TABLE "workspace_session_activity_revisions" (
+  "workspace_id" uuid PRIMARY KEY,
+  "account_id" uuid NOT NULL,
+  "revision" bigint NOT NULL DEFAULT 0,
+  CONSTRAINT "workspace_session_activity_revisions_workspace_account_fk"
+    FOREIGN KEY ("workspace_id", "account_id")
+    REFERENCES "workspaces"("id", "account_id") ON DELETE CASCADE,
+  CONSTRAINT "workspace_session_activity_revisions_revision_check"
+    CHECK ("revision" >= 0)
+);
+
+ALTER TABLE "workspace_session_activity_revisions" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "workspace_session_activity_revisions" FORCE ROW LEVEL SECURITY;
+CREATE POLICY workspace_isolation ON "workspace_session_activity_revisions"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+-- PostgreSQL installs this constant default without rewriting existing rows.
+-- Revision zero is an intentional legacy bucket ordered by (updated_at, id).
+ALTER TABLE "sessions"
+  ADD COLUMN "activity_revision" bigint NOT NULL DEFAULT 0;
+
+CREATE OR REPLACE FUNCTION opengeni_private.assign_session_activity_revision()
+RETURNS trigger
+LANGUAGE plpgsql
+SET search_path = pg_catalog
+AS $function$
+DECLARE
+  next_revision bigint;
+BEGIN
+  EXECUTE format(
+    'INSERT INTO %I.workspace_session_activity_revisions AS counter '
+    || '(workspace_id, account_id, revision) VALUES ($1, $2, 1) '
+    || 'ON CONFLICT (workspace_id) DO UPDATE SET '
+    || 'account_id = excluded.account_id, revision = counter.revision + 1 '
+    || 'RETURNING revision',
+    TG_TABLE_SCHEMA
+  )
+  INTO next_revision
+  USING NEW.workspace_id, NEW.account_id;
+
+  NEW.activity_revision := next_revision;
+  RETURN NEW;
+END;
+$function$;
+
+CREATE TRIGGER sessions_assign_activity_revision
+BEFORE INSERT OR UPDATE OF updated_at, activity_revision
+ON "sessions"
+FOR EACH ROW EXECUTE FUNCTION opengeni_private.assign_session_activity_revision();
+
+DO $grants$
+DECLARE target_schema text := current_schema();
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    EXECUTE format(
+      'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE %I.workspace_session_activity_revisions TO opengeni_app',
+      target_schema
+    );
+  END IF;
+END $grants$;
+
+RESET statement_timeout;
+RESET lock_timeout;

package/drizzle/0075_sessions_workspace_activity_revision_idx.sql

@@ -0,0 +1,4 @@
+-- deployment-mode: rolling
+-- opengeni:concurrent-index lock-timeout=5s
+CREATE INDEX CONCURRENTLY "sessions_workspace_activity_revision_idx"
+  ON "sessions" ("workspace_id", "activity_revision" DESC, "updated_at" DESC, "id" DESC);

package/drizzle/0076_session_workflow_wake_acl.sql

@@ -0,0 +1,13 @@
+-- deployment-mode: rolling
+-- Migration 0063 recreates this SECURITY DEFINER function and revokes its
+-- default PUBLIC authority. Restore only the runtime dispatcher's exact grant;
+-- production Helm runs migrations without a separate provision-roles pass.
+REVOKE ALL ON FUNCTION opengeni_private.claim_session_workflow_wakes(integer) FROM PUBLIC;
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT EXECUTE ON FUNCTION opengeni_private.claim_session_workflow_wakes(integer)
+      TO opengeni_app;
+  END IF;
+END $$;

package/drizzle/0077_session_attempt_latest_lookup.sql

@@ -0,0 +1,4 @@
+-- deployment-mode: rolling
+-- opengeni:concurrent-index lock-timeout=5s
+CREATE INDEX CONCURRENTLY "session_turn_attempts_latest_session_idx"
+  ON "session_turn_attempts" ("workspace_id", "session_id", "started_at" DESC, "id" DESC);