@opengeni/db 1.3.0 → 1.4.2

package/src/insights-unified.ts

@@ -331,7 +331,8 @@ export async function readInsightsUsage(
           ||jsonb_strip_nulls(jsonb_build_object(
           'provider',case when ${query.groupBy} in ('model','provider') then provider end,
           'model',case when ${query.groupBy}='model' then model end,
-          'workspaceId',case when ${query.groupBy}='workspace' then workspace_id end,
+          'workspaceId',case when ${query.groupBy}='workspace'
+            or (${query.groupBy}='rootSession' and kind='item') then workspace_id end,
           'you',case when ${query.groupBy}='person' or kind='personal' then you end))
           order by (measures->>'chargedMicros')::bigint+(measures->>'listMicros')::bigint desc,key) from selected_groups),'[]'::jsonb),
         'series',coalesce((select jsonb_agg(jsonb_build_object('start',points.start,'measures',coalesce(buckets.measures,zero.measures))

package/src/legacy-tool-action-reviews.ts

@@ -0,0 +1,242 @@
+import { createHash } from "node:crypto";
+import { and, desc, eq, gt, isNull, sql } from "drizzle-orm";
+import { parseVerifiedAttemptToolCatalog } from "@opengeni/codemode";
+import {
+  McpConnectionAccountBindings,
+  ToolActionReview,
+  decodeReviewArguments,
+  ToolDisplayMetadata,
+  stableJson,
+  toolReviewAction,
+  toolReviewContextFromSchema,
+  toolReviewFields,
+  type ToolReviewContext,
+} from "@opengeni/contracts";
+import { type Database, withRlsContext } from "./database";
+import { fromPostgresLosslessJson } from "./lossless-json";
+import * as schema from "./schema";
+
+const object = (value: unknown): Record<string, unknown> | null =>
+  value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+
+function approval(value: unknown) {
+  const item = object(value);
+  const raw = object(item?.rawItem);
+  if (!item) return null;
+  return {
+    id: raw?.callId ?? raw?.id ?? item.id ?? item.callId,
+    name: item.name ?? item.toolName ?? raw?.name,
+    args: decodeReviewArguments(item.arguments ?? raw?.arguments),
+  };
+}
+
+/** Read-only presentation for SDK approvals created before durable connector
+ * reviews. Neither current catalogs nor display labels establish a provider.
+ * This never creates a request, changes a policy, or resumes an operation. */
+export async function legacyToolActionReview(
+  db: Database,
+  input: { accountId: string; workspaceId: string; sessionId: string; approvalId: string },
+) {
+  return await withRlsContext(db, input, async (tx) => {
+    const [snapshot] = await tx
+      .select({
+        state: {
+          id: schema.agentRunStates.id,
+          pending: schema.agentRunStates.pendingApprovals,
+          codec: schema.agentRunStates.pendingApprovalsCodecVersion,
+        },
+        turn: schema.sessionTurns,
+        session: { status: schema.sessions.status, activeTurnId: schema.sessions.activeTurnId },
+      })
+      .from(schema.agentRunStates)
+      .innerJoin(schema.sessionTurns, eq(schema.sessionTurns.id, schema.agentRunStates.turnId))
+      .innerJoin(schema.sessions, eq(schema.sessions.id, schema.agentRunStates.sessionId))
+      .where(
+        and(
+          eq(schema.agentRunStates.accountId, input.accountId),
+          eq(schema.agentRunStates.workspaceId, input.workspaceId),
+          eq(schema.agentRunStates.sessionId, input.sessionId),
+        ),
+      )
+      .orderBy(desc(schema.agentRunStates.stateVersion))
+      .limit(1);
+    if (!snapshot) return null;
+    const pending = fromPostgresLosslessJson(snapshot.state.pending, snapshot.state.codec);
+    const matching = Array.isArray(pending)
+      ? pending.map(approval).filter((item) => item?.id === input.approvalId)
+      : [];
+    if (matching.length !== 1) return null;
+    const saved = matching[0]!;
+    if (typeof saved.name !== "string" || saved.args === null) return null;
+    const args = saved.args;
+    const { turn, session } = snapshot;
+    const scope = and(
+      eq(schema.sessionEvents.accountId, input.accountId),
+      eq(schema.sessionEvents.workspaceId, input.workspaceId),
+      eq(schema.sessionEvents.sessionId, input.sessionId),
+      eq(schema.sessionEvents.turnId, turn.id),
+      eq(schema.sessionEvents.turnAssociation, "current"),
+      isNull(schema.sessionEvents.duplicateOfEventId),
+    );
+    const [waiting] = await tx
+      .select()
+      .from(schema.sessionEvents)
+      .where(and(scope, eq(schema.sessionEvents.type, "session.requiresAction")))
+      .orderBy(desc(schema.sessionEvents.sequence))
+      .limit(1);
+    if (!waiting?.turnAttemptId || waiting.turnGeneration === null) return null;
+    const waitPayload = object(
+      fromPostgresLosslessJson(waiting.payload, waiting.payloadCodecVersion),
+    );
+    const waitApprovals = Array.isArray(waitPayload?.approvals)
+      ? waitPayload.approvals.map(approval).filter((item) => item?.id === input.approvalId)
+      : [];
+    if (
+      waitApprovals.length !== 1 ||
+      waitApprovals[0]!.name !== saved.name ||
+      stableJson(waitApprovals[0]!.args) !== stableJson(args)
+    )
+      return null;
+
+    let toolName = saved.name;
+    let context: ToolReviewContext = { kind: "generic" };
+    // Only the immutable attempt catalog proves which fields its schema protects.
+    // Without that proof no argument value is shown and approval is unavailable.
+    let proven = false;
+    const calls = await tx
+      .select()
+      .from(schema.sessionEvents)
+      .where(
+        and(
+          scope,
+          eq(schema.sessionEvents.turnAttemptId, waiting.turnAttemptId),
+          eq(schema.sessionEvents.turnGeneration, waiting.turnGeneration),
+          eq(schema.sessionEvents.type, "agent.toolCall.created"),
+          sql`${schema.sessionEvents.payload}->>'id' = ${input.approvalId}`,
+        ),
+      )
+      .limit(2);
+    if (calls.length === 1 && calls[0]!.sequence < waiting.sequence) {
+      const call = object(
+        fromPostgresLosslessJson(calls[0]!.payload, calls[0]!.payloadCodecVersion),
+      );
+      if (
+        call?.name === saved.name &&
+        stableJson(decodeReviewArguments(call.arguments)) === stableJson(args)
+      ) {
+        const displayResult = ToolDisplayMetadata.safeParse(call.display);
+        const display = displayResult.success ? displayResult.data : undefined;
+        if (display)
+          context = {
+            kind: "generic",
+            title: (display.title ?? display.toolName.replaceAll("_", " ")).slice(0, 256),
+            ...(display.accountLabel ? { accountLabel: display.accountLabel.slice(0, 256) } : {}),
+          };
+        const [stored] = await tx
+          .select()
+          .from(schema.sessionAttemptToolCatalogs)
+          .where(
+            and(
+              eq(schema.sessionAttemptToolCatalogs.accountId, input.accountId),
+              eq(schema.sessionAttemptToolCatalogs.workspaceId, input.workspaceId),
+              eq(schema.sessionAttemptToolCatalogs.sessionId, input.sessionId),
+              eq(schema.sessionAttemptToolCatalogs.turnId, turn.id),
+              eq(schema.sessionAttemptToolCatalogs.attemptId, waiting.turnAttemptId),
+              eq(schema.sessionAttemptToolCatalogs.executionGeneration, waiting.turnGeneration),
+            ),
+          )
+          .limit(1);
+        // The immutable model-name map supplies schema privacy and exact tool
+        // identity; the accepted account binding independently supplies provider.
+        if (stored) {
+          const catalog = parseVerifiedAttemptToolCatalog(stored.catalog);
+          const entry = catalog.entries.find((item) => item.modelName === saved.name);
+          if (entry) {
+            const bindings = McpConnectionAccountBindings.safeParse(turn.mcpAccountBindings);
+            const binding = bindings.success
+              ? bindings.data.find((item) => item.serverId === entry.identity.serverId)
+              : undefined;
+            proven = true;
+            toolName = entry.identity.toolName;
+            context = toolReviewContextFromSchema(entry.inputSchema, {
+              kind:
+                entry.source === "mcp" && binding?.providerDomain === "gmailmcp.googleapis.com"
+                  ? "gmail"
+                  : "generic",
+              ...(entry.title ? { title: entry.title } : {}),
+              ...(binding?.accountLabel
+                ? { accountLabel: binding.accountLabel }
+                : context.accountLabel
+                  ? { accountLabel: context.accountLabel }
+                  : {}),
+            });
+          }
+        }
+      }
+    }
+    const [decision] = await tx
+      .select({ payload: schema.sessionEvents.payload })
+      .from(schema.sessionEvents)
+      .where(
+        and(
+          scope,
+          eq(schema.sessionEvents.type, "user.approvalDecision"),
+          gt(schema.sessionEvents.sequence, waiting.sequence),
+          sql`${schema.sessionEvents.payload}->>'approvalId' = ${input.approvalId}`,
+        ),
+      )
+      .orderBy(desc(schema.sessionEvents.sequence))
+      .limit(1);
+    const active =
+      !decision &&
+      turn.status === "requires_action" &&
+      session.status === "requires_action" &&
+      session.activeTurnId === turn.id;
+    const status = decision
+      ? object(decision.payload)?.decision === "reject"
+        ? "rejected"
+        : "approved"
+      : active
+        ? "pending"
+        : "cancelled";
+    const actionDigest = createHash("sha256")
+      .update(
+        stableJson({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          turnId: turn.id,
+          approvalId: input.approvalId,
+          name: saved.name,
+          args,
+        }),
+      )
+      .digest("hex");
+    return {
+      args,
+      context,
+      proven,
+      review: ToolActionReview.parse({
+        version: 1,
+        id: input.approvalId,
+        actionDigest,
+        revision: `${snapshot.state.id}:${turn.updatedAt.toISOString()}:${status}`,
+        status,
+        ...(proven
+          ? {
+              ...toolReviewAction(toolName, args, context),
+              ...toolReviewFields(args, context),
+            }
+          : { ...toolReviewAction(toolName, null, context), fields: [], moreFields: 0 }),
+        ...(context.accountLabel ? { accountLabel: context.accountLabel } : {}),
+        reason: "This action asks first.",
+        createdAt: waiting.createdAt.toISOString(),
+        updatedAt: turn.updatedAt.toISOString(),
+        availableActions: active ? (proven ? ["approve", "reject"] : ["reject"]) : [],
+        detailsAvailable: proven,
+      }),
+    };
+  });
+}

package/src/modal-native-live-origin.ts

@@ -0,0 +1,148 @@
+import { sql } from "drizzle-orm";
+import { rawRows, type Database } from "./database";
+
+/** Structural V2 correlation scope. This is deliberately NOT an actor/grant. */
+export type ModalNativeLiveOriginScope = Readonly<{
+  version: 2;
+  declarationId: string;
+  planId: string;
+  creatorId: string;
+  accountId: string;
+  workspaceId: string;
+  sessionId: string;
+  turnId: string;
+  attemptId: string;
+  executionGeneration: number;
+  triggerEventId: string;
+  sandboxGroupId: string;
+  routeKind: "home";
+  routeTargetId: null;
+  routeEpoch: number;
+}>;
+
+export type ModalNativeLiveOriginProjection = Readonly<{
+  version: 1;
+  scope: ModalNativeLiveOriginScope;
+  initiator: {
+    kind: "subject" | "service";
+    subjectId: string;
+    initiatingHumanSubjectId: string;
+  };
+  membership: {
+    id: string;
+    authorizationRevision: string;
+    basis: "workspace_membership" | "personal_workspace";
+  };
+  acceptedAuthority: {
+    epoch: number;
+    visibility: "user_private" | "workspace_shared";
+    ownerOrganizationMembershipId: string | null;
+  };
+  currentAuthority: {
+    epoch: number;
+    executionEpoch: number;
+    visibility: "user_private" | "workspace_shared";
+    ownerSubjectId: string | null;
+    ownerOrganizationMembershipId: string | null;
+  };
+  control: { workspaceRevision: string; sessionVersion: string };
+  execution: { workflowId: string; workflowRunId: string; activityId: string };
+  providerRecoveryCount: 0 | 1 | 2 | 3 | 4 | 5;
+  checkedAt: string;
+}>;
+
+export type ModalNativeLiveOriginResult =
+  | { kind: "live"; projection: ModalNativeLiveOriginProjection }
+  | { kind: "fenced" }
+  | {
+      kind: "unsupported";
+      reason: "invalid_scope" | "human_unavailable" | "external_authority" | "not_premodel";
+    };
+
+const keys = [
+  "version",
+  "declarationId",
+  "planId",
+  "creatorId",
+  "accountId",
+  "workspaceId",
+  "sessionId",
+  "turnId",
+  "attemptId",
+  "executionGeneration",
+  "triggerEventId",
+  "sandboxGroupId",
+  "routeKind",
+  "routeTargetId",
+  "routeEpoch",
+] as const;
+const ids = [
+  "declarationId",
+  "planId",
+  "creatorId",
+  "accountId",
+  "workspaceId",
+  "sessionId",
+  "turnId",
+  "attemptId",
+  "triggerEventId",
+  "sandboxGroupId",
+] as const;
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+function scopeSnapshot(value: ModalNativeLiveOriginScope): ModalNativeLiveOriginScope | null {
+  if (!value || typeof value !== "object") return null;
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(value).length !== keys.length) return null;
+  const copy: Record<string, unknown> = {};
+  for (const key of keys) {
+    const descriptor = descriptors[key];
+    if (!descriptor || !("value" in descriptor)) return null;
+    copy[key] = descriptor.value;
+  }
+  if (ids.some((key) => typeof copy[key] !== "string" || !uuid.test(copy[key] as string)))
+    return null;
+  if (
+    copy.version !== 2 ||
+    copy.routeKind !== "home" ||
+    copy.routeTargetId !== null ||
+    copy.creatorId === copy.attemptId ||
+    copy.creatorId === copy.planId ||
+    !Number.isSafeInteger(copy.executionGeneration) ||
+    (copy.executionGeneration as number) < 1 ||
+    (copy.executionGeneration as number) > 2_147_483_647 ||
+    !Number.isSafeInteger(copy.routeEpoch) ||
+    (copy.routeEpoch as number) < 0 ||
+    (copy.routeEpoch as number) > 2_147_483_647
+  )
+    return null;
+  return Object.freeze(copy) as ModalNativeLiveOriginScope;
+}
+
+/**
+ * Private-server integration primitive, NOT host authentication or a grant.
+ * The caller must authenticate the exact host request separately and consume
+ * this projection in this SAME transaction. No native/provider awaits here.
+ * Enter before taking any tenancy/control/session/lease lock: SQL acquires the
+ * organization-membership -> tenancy -> canonical control/row prefix itself.
+ * Preserves all subject and tenant GUCs. SQL uncertainty propagates (including
+ * 55P03); no failed/aborted transaction is reported as successful admission.
+ */
+export async function lockLiveNativeOriginalOriginTx(
+  scopedTx: Database,
+  scope: ModalNativeLiveOriginScope,
+): Promise<ModalNativeLiveOriginResult> {
+  if (typeof (scopedTx as Database & { rollback?: unknown }).rollback !== "function") {
+    throw new Error("LIVE native origin projection requires an existing transaction");
+  }
+  const snapshot = scopeSnapshot(scope);
+  if (!snapshot) return { kind: "unsupported", reason: "invalid_scope" };
+  const [row] = await rawRows<{ result: ModalNativeLiveOriginResult }>(
+    scopedTx,
+    sql`select lock_live_native_original_origin_v2(${JSON.stringify(snapshot)}::jsonb) as result`,
+  );
+  if (!row || !["live", "fenced", "unsupported"].includes(row.result?.kind)) {
+    throw new Error("Invalid LIVE native origin database projection");
+  }
+  return row.result;
+}

package/src/organization-slack-bots.ts

@@ -1,6 +1,6 @@
 import { sql } from "drizzle-orm";
 import { rawRows, setSubjectRlsContext, withRlsContext, type Database } from "./database";
-import { getConnectionMetadata, listConnectionsMetadata } from "./index";
+import { getConnectionMetadata, listConnectionsMetadata } from "./connection-metadata";
 
 export type SlackBotAccess = {
   connectionId: string;

package/src/provision-roles.ts

@@ -578,6 +578,8 @@ async function grantAppRoleIfSchemaExists(
     "prepare_organization_membership_protocol_settlements(jsonb)",
     "assert_active_managed_human_organization_membership(uuid,text)",
     "resolve_workspace_writer_grant_identity(uuid,text)",
+    "lock_live_native_original_origin_v2(jsonb)",
+    "modal_native_origin_member_read_active(uuid,text)",
     "prepare_workspace_membership_removal_settlements(jsonb)",
     "workspace_membership_removal_command(jsonb)",
     "get_organization_retention_policy(uuid,text)",
@@ -2105,6 +2107,16 @@ BEGIN
         REVOKE ALL ON FUNCTION opengeni_private.list_pending_modal_provider_creates() FROM PUBLIC;
       END IF;
     END IF;
+    IF to_regclass('opengeni_private.modal_native_origin_read_capabilities') IS NOT NULL THEN
+      EXECUTE format('REVOKE ALL ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM %I', ${literal(role)});
+      EXECUTE format('REVOKE ALL (%s) ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM %I',
+        (SELECT string_agg(quote_ident(attname), ',') FROM pg_attribute
+          WHERE attrelid='opengeni_private.modal_native_origin_read_capabilities'::regclass AND attnum>0 AND NOT attisdropped), ${literal(role)});
+      REVOKE ALL ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM PUBLIC;
+      EXECUTE format('REVOKE ALL (%s) ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM PUBLIC',
+        (SELECT string_agg(quote_ident(attname), ',') FROM pg_attribute
+          WHERE attrelid='opengeni_private.modal_native_origin_read_capabilities'::regclass AND attnum>0 AND NOT attisdropped));
+    END IF;
     IF to_regclass('opengeni_private.sandbox_recovery_rollout') IS NOT NULL THEN
       -- Migration may precede this role's creation. Converge only read access;
       -- runtime identities and PUBLIC never receive recovery activation writes.

package/src/runtime-posture.ts

@@ -609,6 +609,8 @@ const PRIVATE_SESSION_CREATE_CAPABILITY_ROUTINES = [
   "close_private_session_create_capability(uuid)",
 ] as const;
 const SESSION_AUTHORITY_ROUTINES = new Set<string>([
+  "lock_live_native_original_origin_v2(jsonb)",
+  "modal_native_origin_member_read_active(uuid, text)",
   LEGACY_FORK_SESSION_CONTENT_ROUTINE,
   FORK_SESSION_CONTENT_ROUTINE,
   MESSAGE_FORK_SESSION_CONTENT_ROUTINE,
@@ -712,6 +714,8 @@ const UNIFIED_KNOWLEDGE_AUTHORITY_TABLES = [
   "documents",
 ] as const;
 export const RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES = [
+  "lock_live_native_original_origin_v2(jsonb)",
+  "modal_native_origin_member_read_active(uuid, text)",
   ...CLAUDE_SUBSCRIPTION_CAPABILITY_ROUTINES,
   "maintain_usage_allowances(integer, integer)",
   "usage_allowance_command(jsonb)",
@@ -2135,15 +2139,15 @@ export async function inspectRuntimeDatabasePosture(
             -- Column-only grants on capability tables are also unsafe; a pin
             -- table must remain EXECUTE-only even after column ACL drift.
             (has_table_privilege(current_user, c.oid, 'SELECT') or
-              ((c.relname in ('modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
+              ((c.relname in ('modal_native_origin_read_capabilities','modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
                 c.relname in (select jsonb_array_elements_text(${JSON.stringify(RUNTIME_ALLOWANCE_PRIVATE_TABLES)}::jsonb))) and
                 has_any_column_privilege(current_user, c.oid, 'SELECT'))) as can_select,
             (has_table_privilege(current_user, c.oid, 'INSERT') or
-              ((c.relname in ('modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
+              ((c.relname in ('modal_native_origin_read_capabilities','modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
                 c.relname in (select jsonb_array_elements_text(${JSON.stringify(RUNTIME_ALLOWANCE_PRIVATE_TABLES)}::jsonb))) and
                 has_any_column_privilege(current_user, c.oid, 'INSERT'))) as can_insert,
             (has_table_privilege(current_user, c.oid, 'UPDATE') or
-              ((c.relname in ('modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
+              ((c.relname in ('modal_native_origin_read_capabilities','modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
                 c.relname in (select jsonb_array_elements_text(${JSON.stringify(RUNTIME_ALLOWANCE_PRIVATE_TABLES)}::jsonb))) and
                 has_any_column_privilege(current_user, c.oid, 'UPDATE'))) as can_update,
             has_table_privilege(current_user, c.oid, 'DELETE') as can_delete,
@@ -2190,6 +2194,7 @@ export async function inspectRuntimeDatabasePosture(
               'session_file_read_capabilities',
               'session_import_batches',
               'modal_inventory_read_capabilities',
+              'modal_native_origin_read_capabilities',
               ${AUTOMATIC_SESSION_TITLE_FANOUT_OUTBOX_TABLE},
               ${VERIFIED_SIGNUP_TRIAL_SWITCH_TABLE},
               'credit_promotion_policy_revisions',
@@ -4235,6 +4240,30 @@ export function evaluateRuntimeDatabasePosture(
   ) {
     violations.push("usage allowance attribution receipts lack same-owner FORCE-RLS isolation");
   }
+  const nativeOriginCapability = posture.privateTables.find(
+    (table) => table.name === "modal_native_origin_read_capabilities",
+  );
+  const nativeOriginRoutineInstalled = posture.targetRoutines.some(
+    (routine) => routine.name === "lock_live_native_original_origin_v2(jsonb)",
+  );
+  if (
+    (nativeOriginRoutineInstalled || nativeOriginCapability) &&
+    (!nativeOriginCapability ||
+      nativeOriginCapability.owner === expectedRole ||
+      nativeOriginCapability.owner !== tableByName.get("sessions")?.owner ||
+      nativeOriginCapability.owner !== tableByName.get("organization_memberships")?.owner ||
+      !nativeOriginCapability.rlsEnabled ||
+      !nativeOriginCapability.rlsForced ||
+      !nativeOriginCapability.rlsActive ||
+      nativeOriginCapability.select ||
+      nativeOriginCapability.insert ||
+      nativeOriginCapability.update ||
+      nativeOriginCapability.delete ||
+      nativeOriginCapability.truncate ||
+      nativeOriginCapability.references ||
+      nativeOriginCapability.trigger)
+  )
+    violations.push("Native LIVE-origin read capability has unsafe owner, RLS or privileges");
   const modalInventoryCapability = posture.privateTables.find(
     (table) => table.name === "modal_inventory_read_capabilities",
   );

package/src/sandbox-interaction-idle.ts

@@ -0,0 +1,91 @@
+import { sql } from "drizzle-orm";
+import { rawRows, withRlsContext, type Database } from "./database";
+
+export const INTERACTION_ONLY_IDLE_BUCKETS = ["lt_30m", "30m_2h", "2h_6h", "gte_6h"] as const;
+export type InteractionOnlyIdleBucket = (typeof INTERACTION_ONLY_IDLE_BUCKETS)[number];
+
+export type InteractionOnlyLeaseCandidate = {
+  accountId: string;
+  workspaceId: string;
+  sandboxGroupId: string;
+};
+
+export function interactionOnlyIdleBucket(idleMs: number): InteractionOnlyIdleBucket {
+  if (idleMs < 30 * 60_000) return "lt_30m";
+  if (idleMs < 2 * 60 * 60_000) return "30m_2h";
+  if (idleMs < 6 * 60 * 60_000) return "2h_6h";
+  return "gte_6h";
+}
+
+/**
+ * Read-only inventory of warm leases whose ONLY holders are Browser/Computer
+ * interaction holders, bucketed by time since the newest interaction activity
+ * (holder heartbeat, controller heartbeat, or last use). Interaction holders
+ * deliberately never expire by timestamp, so such a box stays warm until its
+ * session ends or the provider deadline; this makes that visible. Candidates
+ * come from the sanctioned cross-workspace warm-lease list; each workspace is
+ * then read under its own RLS scope. No lock beyond the snapshot is taken.
+ */
+export async function countInteractionOnlyWarmLeasesByIdle(
+  db: Database,
+  candidates: InteractionOnlyLeaseCandidate[],
+  options: { now?: Date; maxWorkspaces?: number } = {},
+): Promise<Record<InteractionOnlyIdleBucket, number>> {
+  const nowMs = (options.now ?? new Date()).getTime();
+  const counts = Object.fromEntries(INTERACTION_ONLY_IDLE_BUCKETS.map((b) => [b, 0])) as Record<
+    InteractionOnlyIdleBucket,
+    number
+  >;
+  const byWorkspace = new Map<string, InteractionOnlyLeaseCandidate[]>();
+  for (const candidate of candidates) {
+    const key = `${candidate.accountId}:${candidate.workspaceId}`;
+    byWorkspace.set(key, [...(byWorkspace.get(key) ?? []), candidate]);
+  }
+  const workspaces = [...byWorkspace.values()].slice(0, options.maxWorkspaces ?? 500);
+  for (const group of workspaces) {
+    const { accountId, workspaceId } = group[0]!;
+    const groupIds = group.map((candidate) => candidate.sandboxGroupId);
+    const rows = await withRlsContext(
+      db,
+      { accountId, workspaceId },
+      async (scoped) =>
+        await rawRows<{ last_activity_at: Date | string | null }>(
+          scoped,
+          sql`
+            select max(greatest(
+              holder.last_heartbeat_at,
+              browser.controller_heartbeat_at, browser.last_used_at,
+              computer.controller_heartbeat_at, computer.last_used_at
+            )) as last_activity_at
+            from sandbox_leases lease
+            join sandbox_lease_holders holder
+              on holder.lease_id = lease.id and holder.workspace_id = lease.workspace_id
+            left join browser_sessions browser
+              on holder.holder_id = 'browser-session:' || browser.id::text
+              and browser.workspace_id = lease.workspace_id
+            left join computer_sessions computer
+              on holder.holder_id = 'computer-session:' || computer.id::text
+              and computer.workspace_id = lease.workspace_id
+            where lease.account_id = ${accountId}
+              and lease.workspace_id = ${workspaceId}
+              and lease.sandbox_group_id in ${sql`(${sql.join(
+                groupIds.map((id) => sql`${id}`),
+                sql`, `,
+              )})`}
+              and lease.liveness = 'warm'
+            group by lease.id
+            having bool_and(holder.kind = 'interaction')
+          `,
+        ),
+      undefined,
+      "none",
+    );
+    for (const row of rows) {
+      const last = row.last_activity_at ? new Date(row.last_activity_at).getTime() : Number.NaN;
+      counts[
+        interactionOnlyIdleBucket(Number.isFinite(last) ? Math.max(0, nowMs - last) : Infinity)
+      ] += 1;
+    }
+  }
+  return counts;
+}

package/src/schema.ts

@@ -5293,6 +5293,7 @@ export const sessionRealtimeModes = pgTable(
     modelValid: check(
       "session_realtime_modes_model_check",
       sql`${table.model} in (
+        'opengeni-azure/gpt-live-1',
         'gpt-live-1-boulder-alpha',
         'supergrok/grok-voice-think-fast-2.0',
         'opengeni-gateway/openai/gpt-realtime-2.1',