@opengeni/db 6.0.0 → 6.0.1

package/src/integration-oauth-pending-states.ts

@@ -0,0 +1,52 @@
+import { and, eq, gt, sql } from "drizzle-orm";
+import { type Database, withRlsContext } from "./database";
+import { integrationOauthPendingStates } from "./schema";
+
+type PendingStateScope = {
+  accountId: string;
+  workspaceId: string;
+};
+
+export async function storeIntegrationOAuthPendingState(
+  db: Database,
+  input: PendingStateScope & {
+    id: string;
+    stateEncrypted: string;
+    expiresAt: Date;
+  },
+): Promise<void> {
+  await withRlsContext(db, input, async (scopedDb) => {
+    // A bounded per-workspace sweep prevents abandoned browser grants from
+    // accumulating without adding a process-local timer to API instances.
+    await scopedDb.execute(sql`delete from integration_oauth_pending_states
+      where id in (
+        select id from integration_oauth_pending_states
+        where account_id = ${input.accountId}::uuid
+          and workspace_id = ${input.workspaceId}::uuid
+          and expires_at <= clock_timestamp()
+        order by expires_at, id limit 128
+      )`);
+    await scopedDb.insert(integrationOauthPendingStates).values(input);
+  });
+}
+
+export async function loadIntegrationOAuthPendingState(
+  db: Database,
+  input: PendingStateScope & { id: string },
+): Promise<string | null> {
+  return withRlsContext(db, input, async (scopedDb) => {
+    const [row] = await scopedDb
+      .select({ stateEncrypted: integrationOauthPendingStates.stateEncrypted })
+      .from(integrationOauthPendingStates)
+      .where(
+        and(
+          eq(integrationOauthPendingStates.id, input.id),
+          eq(integrationOauthPendingStates.accountId, input.accountId),
+          eq(integrationOauthPendingStates.workspaceId, input.workspaceId),
+          gt(integrationOauthPendingStates.expiresAt, sql`clock_timestamp()`),
+        ),
+      )
+      .limit(1);
+    return row?.stateEncrypted ?? null;
+  });
+}

package/src/new-session-drafts.ts

@@ -365,7 +365,9 @@ export async function saveNewSessionDraftInTransaction(
   throw new NewSessionDraftConflictError(raced?.revision ?? 0);
 }
 
-function safeRepositoryResource(resource: RepositoryResourceRef): RepositoryResourceRef {
+export function reusableNewSessionRepositoryResource(
+  resource: RepositoryResourceRef,
+): RepositoryResourceRef {
   // A repository's URI/ref/mount and GitHub identity are ordinary selection
   // state. Credential bindings, connection refs, access intent, and generic
   // provider ids are per-session authorization/runtime state and must not seed
@@ -574,7 +576,7 @@ export async function seedNewSessionDraftInTransaction(
     if (!raw || typeof raw !== "object" || (raw as { kind?: unknown }).kind !== "repository") {
       return [];
     }
-    return [safeRepositoryResource(raw as RepositoryResourceRef)];
+    return [reusableNewSessionRepositoryResource(raw as RepositoryResourceRef)];
   });
   const [seeded] = await db
     .update(schema.newSessionDrafts)

package/src/runtime-posture.ts

@@ -835,6 +835,7 @@ export const FORCE_RLS_TABLES = [
   "integration_facet_binding_owners",
   "integration_facet_bindings",
   "integration_facet_definitions",
+  "integration_oauth_pending_states",
   "integration_oauth_state_nonces",
   "integration_spec_revisions",
   "integration_tools",
@@ -1184,6 +1185,7 @@ export const RUNTIME_FULL_DML_TABLES = [
   "integration_facet_binding_owners",
   "integration_facet_bindings",
   "integration_oauth_clients",
+  "integration_oauth_pending_states",
   "integration_oauth_state_nonces",
   "knowledge_source_sync_index_obligations",
   "knowledge_source_sync_item_outcomes",

package/src/schema.ts

@@ -1,4 +1,5 @@
 import type { StoredSessionAdmissionBlock } from "./session-admission-block";
+import { meaningfulSessionEventSql } from "./session-meaningful-events";
 import type {
   SandboxProviderCommand,
   CommandSupervisionReceipt,
@@ -3716,6 +3717,31 @@ export const integrationOauthStateNonces = pgTable(
   }),
 );
 
+export const integrationOauthPendingStates = pgTable(
+  "integration_oauth_pending_states",
+  {
+    id: uuid("id").primaryKey(),
+    accountId: uuid("account_id")
+      .notNull()
+      .references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid("workspace_id").notNull(),
+    stateEncrypted: text("state_encrypted").notNull(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    workspaceAccount: foreignKey({
+      name: "integration_oauth_pending_states_workspace_account_fk",
+      columns: [table.workspaceId, table.accountId],
+      foreignColumns: [workspaces.id, workspaces.accountId],
+    }).onDelete("cascade"),
+    expiry: index("integration_oauth_pending_states_expiry_idx").on(
+      table.workspaceId,
+      table.expiresAt,
+    ),
+  }),
+);
+
 export const hostMcpBindings = pgTable(
   "host_mcp_bindings",
   {
@@ -5379,10 +5405,12 @@ export const sessionPins = pgTable(
     pinned: boolean("pinned").notNull().default(true),
     pinnedAt: timestamp("pinned_at", { withTimezone: true }).defaultNow(),
     version: integer("version").notNull().default(1),
-    // A session is unread for this subject whenever its durable event sequence
-    // has advanced beyond this explicit acknowledgment fence. Merely opening a
-    // route never changes the fence.
+    // Compare the meaningful event frontier, not the raw durable cursor.
+    // Merely opening a route never changes this per-subject fence.
     acknowledgedSequence: integer("acknowledged_sequence").notNull().default(0),
+    // A replay at/before this raw event position cannot consume explicit intent.
+    // A genuinely newer proven read, or an explicit mark-read, removes it.
+    manuallyUnreadThrough: integer("manually_unread_through"),
     activelyWorking: boolean("actively_working").notNull().default(false),
     attentionVersion: integer("attention_version").notNull().default(0),
     archived: boolean("archived").notNull().default(false),
@@ -8824,6 +8852,9 @@ export const sessionEvents = pgTable(
       table.type,
       table.sequence,
     ),
+    meaningfulAttention: index("session_events_meaningful_attention_idx")
+      .on(table.workspaceId, table.sessionId, table.sequence)
+      .where(meaningfulSessionEventSql("session_events")),
     workspaceTurnType: index("session_events_workspace_turn_type_idx")
       .on(table.workspaceId, table.turnId, table.type)
       .where(sql`${table.turnId} is not null`),
@@ -10235,6 +10266,7 @@ export const sessionBackgroundCommands = pgTable(
     connectionInstanceId: text("connection_instance_id"),
     opId: text("op_id"),
     commandPreview: text("command_preview").notNull().default(""),
+    commandText: text("command_text"),
     cancelRequestedAt: timestamp("cancel_requested_at", { withTimezone: true }),
     cancelRequestedBy: text("cancel_requested_by"),
     exitCode: integer("exit_code"),

package/src/session-background-commands.ts

@@ -75,8 +75,11 @@ type ConnectedMachineBackgroundCommandClaimRow = {
 };
 
 function commandPreview(value: string): string {
-  const normalized = value.replace(/\s+/g, " ").trim();
-  return Array.from(normalized).slice(0, 512).join("");
+  if (value.length <= 512) return value;
+  let preview = value.slice(0, 511);
+  // Do not split a UTF-16 surrogate pair at the preview boundary.
+  if (/[\uD800-\uDBFF]$/.test(preview)) preview = preview.slice(0, -1);
+  return `${preview}…`;
 }
 
 const commandObservationUnavailable = sql<boolean>`
@@ -138,6 +141,7 @@ function mapCommand(
       ? { observationStatus: "unavailable" as const }
       : {}),
     commandPreview: row.commandPreview,
+    ...(row.commandText !== null ? { commandText: row.commandText } : {}),
     cancelRequestedAt: row.cancelRequestedAt?.toISOString() ?? null,
     exitCode: row.exitCode ?? null,
     settlementReason: row.settlementReason ?? null,
@@ -271,6 +275,7 @@ export async function insertManagedSessionBackgroundCommandInTransaction(
       state: "running",
       retainedProcessId: input.retainedProcessId,
       commandPreview: commandPreview(input.command),
+      commandText: input.command,
       launchTurnId: input.turnId ?? null,
       launchAttemptId: input.attemptId ?? null,
       launchExecutionGeneration: input.executionGeneration ?? null,
@@ -339,6 +344,7 @@ export async function insertConnectedMachineSessionBackgroundCommandInTransactio
       connectionInstanceId: input.connectionInstanceId,
       opId: input.opId,
       commandPreview: commandPreview(input.command),
+      commandText: input.command,
       launchTurnId: input.turnId ?? null,
       launchAttemptId: input.attemptId ?? null,
       launchExecutionGeneration: input.executionGeneration ?? null,

package/src/session-meaningful-events.ts

@@ -0,0 +1,97 @@
+import { Column, getTableName, is, sql, type SQL, type SQLWrapper } from "drizzle-orm";
+
+function correlatedReference(reference: SQLWrapper): SQLWrapper {
+  // Drizzle's single-table SELECT projection removes Column table qualifiers,
+  // including inside nested SQL. Here that would bind workspace_id/session_id
+  // to the inner event row and turn correlation into a tautology. Identifiers
+  // retain the exact outer table (or alias) through that projection rewrite.
+  return is(reference, Column)
+    ? sql`${sql.identifier(getTableName(reference.table))}.${sql.identifier(reference.name)}`
+    : reference;
+}
+
+/** Attention is conversational output or an actionable boundary, not activity.
+ * Keep this allow-list shared by rail, tree and consumption queries. */
+export const MEANINGFUL_SESSION_EVENT_TYPES = [
+  "agent.message.completed",
+  "turn.completed",
+  "turn.failed",
+  "session.requiresAction",
+  "session.humanInput.requested",
+  "tool.auth_needed",
+  "credential.auth_needed",
+  "goal.completed",
+  "goal.paused",
+  "goal.progress",
+  "goal.rewrite.proposed",
+  "rig.setup.failed",
+  "sandbox.operation.failed",
+  "sandbox.box.lost",
+  "workspace.revision.degraded",
+  "machine.op.failed",
+  "machine.link.lost",
+  "session.event.envelope_omitted",
+] as const;
+
+export function meaningfulSessionEventSql(alias: string): SQL {
+  const e = sql.identifier(alias);
+  // These are code-owned literals, not request values. Literal predicates let
+  // PostgreSQL use the matching partial index even with a generic cached plan.
+  return sql`${e}.type in (${sql.join(
+    MEANINGFUL_SESSION_EVENT_TYPES.map((type) => sql.raw(`'${type}'`)),
+    sql`, `,
+  )})
+    and ${e}.duplicate_of_event_id is null
+    and (${e}.turn_association is null or ${e}.turn_association = 'current')
+    and (${e}.type <> 'agent.message.completed' or coalesce(${e}.payload ->> 'text', '') <> '')
+    and (${e}.type <> 'turn.completed' or (
+      not (${e}.payload ?| array['maintenance', 'segmentLimit'])
+      and coalesce(nullif(${e}.payload -> 'output', 'null'::jsonb), ${e}.payload -> 'result') is not null
+      and coalesce(nullif(${e}.payload -> 'output', 'null'::jsonb), ${e}.payload -> 'result') not in ('null'::jsonb, '""'::jsonb)
+    ))`;
+}
+
+/** A stored audit preview can still need attention, but cannot stand in for
+ * consumption of the original content, even when the reader returned it whole. */
+export function completeMeaningfulSessionEventSql(alias: string): SQL {
+  const e = sql.identifier(alias);
+  return sql`${meaningfulSessionEventSql(alias)}
+    and coalesce(${e}.payload -> 'truncation' ->> 'truncated', 'false') <> 'true'
+    and coalesce(${e}.payload ->> 'sourceOmitted', 'false') <> 'true'`;
+}
+
+/** One reverse partial-index probe, independent of the raw-delta tail length.
+ * Derivation also repairs historical bookkeeping-only dots without changing
+ * personal state or rewriting append-only events. */
+export function meaningfulSessionSequenceSql(
+  workspaceId: SQLWrapper,
+  sessionId: SQLWrapper,
+): SQL<number> {
+  return sql<number>`coalesce((
+      select meaningful.sequence from session_events meaningful
+      where meaningful.workspace_id = ${correlatedReference(workspaceId)} and meaningful.session_id = ${correlatedReference(sessionId)}
+        and ${meaningfulSessionEventSql("meaningful")}
+      order by meaningful.sequence desc limit 1
+    ), 0)`;
+}
+
+/** Bound indexed candidate rows BEFORE testing payload size/completeness. Without
+ * this boundary, a long run of oversized answers can cause an unbounded scan. */
+export function childLifecycleEvidenceCandidatesSql(
+  workspaceId: SQLWrapper,
+  sessionId: SQLWrapper,
+): SQL {
+  return sql`with candidates as materialized (
+    select meaningful.* from session_events meaningful
+    where meaningful.workspace_id = ${workspaceId} and meaningful.session_id = ${sessionId}
+      and ${meaningfulSessionEventSql("meaningful")}
+    order by meaningful.sequence desc limit 32
+  )
+  select candidates.sequence, candidates.type, candidates.payload,
+    candidates.payload_codec_version as "payloadCodecVersion" from candidates
+  where ${completeMeaningfulSessionEventSql("candidates")}
+    -- Inspection cap only: the 8 KiB evidence budget applies after logical
+    -- decoding in boundedChildLifecycleEvidence, not to this stored encoding.
+    and octet_length(candidates.payload::text) <= 65536
+  order by candidates.sequence desc`;
+}

package/src/skills.ts

@@ -222,6 +222,8 @@ export async function listSkillRecords(
     revisionId?: string;
     limit?: number;
     metadataOnly?: boolean;
+    /** Pending revisions authored by this exact session, independent of event retention. */
+    sessionId?: string;
     after?: { stableKey: string; id: string };
   } = {},
 ): Promise<SkillRecord[]> {
@@ -260,7 +262,7 @@ export async function listSkillRecords(
         SELECT candidate.* FROM preference_registry_revisions candidate
         WHERE candidate.preference_id=h.id AND candidate.account_id=h.account_id
           AND (${options.revisionId ?? null}::uuid IS NULL OR candidate.id=${options.revisionId ?? null}::uuid)
-        ORDER BY (candidate.id=h.active_revision_id) DESC NULLS LAST,candidate.revision DESC LIMIT 1
+        ORDER BY (${options.sessionId ?? null}::uuid IS NULL AND candidate.id=h.active_revision_id) DESC NULLS LAST,candidate.revision DESC LIMIT 1
       ) r ON true
       LEFT JOIN skill_source_bindings b ON b.preference_id=h.id AND b.account_id=h.account_id
         AND b.workspace_id=${context.workspaceId}::uuid
@@ -269,6 +271,17 @@ export async function listSkillRecords(
           OR (h.scope='user' AND h.scope_subject_id=${context.subjectId ?? null}))
         AND (${options.skillId ?? null}::uuid IS NULL OR h.id=${options.skillId ?? null}::uuid)
         AND (${options.revisionId ?? null}::uuid IS NULL OR r.id IS NOT NULL)
+        AND (${options.sessionId ?? null}::uuid IS NULL OR EXISTS (
+          SELECT 1 FROM skill_write_receipts origin
+          WHERE origin.account_id=h.account_id AND origin.workspace_id=${context.workspaceId}::uuid
+            AND origin.actor->>'kind'='agent' AND origin.actor->>'sessionId'=${options.sessionId ?? null}
+            AND origin.receipt->>'skillId'=h.id::text AND origin.receipt->>'revisionId'=r.id::text
+            AND origin.receipt->>'outcome'='pending'
+            AND coalesce(origin.receipt->>'pendingReason','approval')='approval'
+            AND NOT EXISTS (SELECT 1 FROM preference_registry_events settled
+              WHERE settled.account_id=h.account_id AND settled.preference_id=h.id
+                AND settled.new_revision_id=r.id AND settled.type IN ('activated','corrected','rejected'))
+        ))
         AND (${options.after?.id ?? null}::uuid IS NULL OR
           (h.stable_key,h.id) > (${options.after?.stableKey ?? ""},${options.after?.id ?? null}::uuid))
       ORDER BY h.stable_key,h.id LIMIT ${Math.min(Math.max(options.limit ?? 128, 1), 1000)}