@opengeni/db 0.12.6 → 0.13.0

package/src/index.ts

@@ -214,6 +214,7 @@ export { sql as dbSql } from "drizzle-orm";
 export * from "./session-control";
 export * from "./session-queue-commands";
 export * from "./new-session-drafts";
+export * from "./workspace-instruction-policies";
 export { interruptedToolCallResult } from "./session-tool-call-settlement";
 export { decryptEnvironmentValue, encryptEnvironmentValue } from "./environment-crypto";
 export {
@@ -3144,6 +3145,8 @@ export type CreateConnectionInput = {
   credentialEncrypted: string;
   grantedScopes?: string[];
   expiresAt?: Date | null;
+  verifiedInstallAt?: Date | null;
+  verifiedInstallVersion?: number | null;
   metadata?: Record<string, unknown>;
   createdBySubjectId?: string | null;
   updatedBySubjectId?: string | null;
@@ -3161,10 +3164,40 @@ export type UpdateConnectionInput = {
   credentialEncrypted?: string;
   grantedScopes?: string[];
   expiresAt?: Date | null;
+  verifiedInstallAt?: Date | null;
+  verifiedInstallVersion?: number | null;
   metadata?: Record<string, unknown>;
   updatedBySubjectId?: string | null;
 };
 
+/** Server-owned verification facts; public schemas expose them read-only and nullable. */
+export type ConnectionMetadataWithVerification = ConnectionMetadata & {
+  verifiedInstallAt: string | null;
+  verifiedInstallVersion: number | null;
+};
+
+export type SlackBotPostOperation = {
+  id: string;
+  accountId: string;
+  workspaceId: string;
+  connectionId: string;
+  operationId: string;
+  clientMessageId: string;
+  targetKind: "channel" | "user";
+  targetId: string;
+  requestDigest: string;
+  status: "provider_started" | "completed";
+  claimHolderId: string | null;
+  claimExpiresAt: Date | null;
+  attemptCount: number;
+  lastFailureCode: string | null;
+  slackChannelId: string | null;
+  slackMessageTimestamp: string | null;
+  completedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
 export type ConnectionCredentialForBroker = {
   id: string;
   accountId: string;
@@ -4723,6 +4756,8 @@ const connectionMetadataColumns = {
   lastUsedAt: schema.connections.lastUsedAt,
   lastError: schema.connections.lastError,
   version: schema.connections.version,
+  verifiedInstallAt: schema.connections.verifiedInstallAt,
+  verifiedInstallVersion: schema.connections.verifiedInstallVersion,
   metadata: schema.connections.metadata,
   createdBySubjectId: schema.connections.createdBySubjectId,
   updatedBySubjectId: schema.connections.updatedBySubjectId,
@@ -4739,7 +4774,7 @@ function connectionSubjectVisibility(subjectId?: string | null): SQL {
 export async function createConnection(
   db: Database,
   input: CreateConnectionInput,
-): Promise<ConnectionMetadata> {
+): Promise<ConnectionMetadataWithVerification> {
   return await withRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
@@ -4756,6 +4791,8 @@ export async function createConnection(
           credentialEncrypted: input.credentialEncrypted,
           grantedScopes: input.grantedScopes ?? [],
           expiresAt: input.expiresAt ?? null,
+          verifiedInstallAt: input.verifiedInstallAt ?? null,
+          verifiedInstallVersion: input.verifiedInstallVersion ?? null,
           metadata: input.metadata ?? {},
           createdBySubjectId: input.createdBySubjectId ?? null,
           updatedBySubjectId: input.updatedBySubjectId ?? input.createdBySubjectId ?? null,
@@ -4773,7 +4810,7 @@ export async function listConnectionsMetadata(
   db: Database,
   workspaceId: string,
   subjectId?: string | null,
-): Promise<ConnectionMetadata[]> {
+): Promise<ConnectionMetadataWithVerification[]> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const rows = await scopedDb
       .select(connectionMetadataColumns)
@@ -4794,7 +4831,7 @@ export async function getConnectionMetadata(
   workspaceId: string,
   connectionId: string,
   subjectId?: string | null,
-): Promise<ConnectionMetadata | null> {
+): Promise<ConnectionMetadataWithVerification | null> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const [row] = await scopedDb
       .select(connectionMetadataColumns)
@@ -4814,7 +4851,7 @@ export async function getConnectionMetadata(
 export async function updateConnection(
   db: Database,
   input: UpdateConnectionInput,
-): Promise<ConnectionMetadata | null> {
+): Promise<ConnectionMetadataWithVerification | null> {
   return await withWorkspaceRls(db, input.workspaceId, async (scopedDb) => {
     const set = {
       updatedAt: new Date(),
@@ -4831,6 +4868,12 @@ export async function updateConnection(
         : {}),
       ...(input.grantedScopes !== undefined ? { grantedScopes: input.grantedScopes } : {}),
       ...(input.expiresAt !== undefined ? { expiresAt: input.expiresAt } : {}),
+      ...(input.verifiedInstallAt !== undefined
+        ? { verifiedInstallAt: input.verifiedInstallAt }
+        : {}),
+      ...(input.verifiedInstallVersion !== undefined
+        ? { verifiedInstallVersion: input.verifiedInstallVersion }
+        : {}),
       ...(input.metadata !== undefined ? { metadata: input.metadata } : {}),
       ...(input.updatedBySubjectId !== undefined
         ? { updatedBySubjectId: input.updatedBySubjectId }
@@ -4859,7 +4902,7 @@ export async function revokeConnection(
   workspaceId: string,
   connectionId: string,
   updatedBySubjectId?: string | null,
-): Promise<ConnectionMetadata | null> {
+): Promise<ConnectionMetadataWithVerification | null> {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const [row] = await scopedDb
       .update(schema.connections)
@@ -4868,6 +4911,13 @@ export async function revokeConnection(
         // The version bump invalidates any in-flight refresh's (id, version) CAS,
         // so a racing refresh cannot commit and flip the row back to active.
         version: sql`${schema.connections.version} + 1`,
+        // Status-only revocation does not replace the verified credential or bot
+        // identity. Carry the marker to the same new CAS version so the dedicated
+        // reinstall path can still recognize (but not use) the inactive row.
+        verifiedInstallVersion: sql`case
+          when ${schema.connections.verifiedInstallAt} is null then null
+          else ${schema.connections.version} + 1
+        end`,
         updatedBySubjectId: updatedBySubjectId ?? null,
         updatedAt: new Date(),
       })
@@ -4886,6 +4936,272 @@ export async function revokeConnection(
   });
 }
 
+export type ClaimSlackBotPostOperationResult =
+  | { kind: "claimed" | "in_progress" | "completed"; operation: SlackBotPostOperation }
+  | { kind: "conflict" | "connection_not_found" };
+
+/**
+ * Claims one durable Slack post identity. The insert occurs before any provider
+ * call; retries retain the original client_msg_id and immutable request digest.
+ * A live claim suppresses concurrent sends, while a released/expired claim can
+ * be reclaimed after response loss or process death.
+ */
+export async function claimSlackBotPostOperation(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    targetKind: "channel" | "user";
+    targetId: string;
+    requestDigest: string;
+    claimHolderId: string;
+    claimLeaseMs: number;
+  },
+): Promise<ClaimSlackBotPostOperationResult> {
+  const claimLeaseMs = Math.max(1, Math.min(Math.trunc(input.claimLeaseMs), 120_000));
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) =>
+      await scopedDb.transaction(async (txRaw) => {
+        const tx = txRaw as unknown as Database;
+        const [connection] = await tx
+          .select({ id: schema.connections.id })
+          .from(schema.connections)
+          .where(
+            and(
+              eq(schema.connections.accountId, input.accountId),
+              eq(schema.connections.workspaceId, input.workspaceId),
+              eq(schema.connections.id, input.connectionId),
+            ),
+          )
+          .for("share")
+          .limit(1);
+        if (!connection) return { kind: "connection_not_found" } as const;
+
+        const [created] = await tx
+          .insert(schema.slackBotPostOperations)
+          .values({
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            connectionId: input.connectionId,
+            operationId: input.operationId,
+            clientMessageId: input.operationId,
+            targetKind: input.targetKind,
+            targetId: input.targetId,
+            requestDigest: input.requestDigest,
+            status: "provider_started",
+            claimHolderId: input.claimHolderId,
+            claimExpiresAt: sql`now() + (${claimLeaseMs} * interval '1 millisecond')`,
+            attemptCount: 1,
+          })
+          .onConflictDoNothing({
+            target: [
+              schema.slackBotPostOperations.workspaceId,
+              schema.slackBotPostOperations.connectionId,
+              schema.slackBotPostOperations.operationId,
+            ],
+          })
+          .returning();
+        if (created) {
+          return { kind: "claimed", operation: mapSlackBotPostOperation(created) } as const;
+        }
+
+        const [existing] = await tx
+          .select()
+          .from(schema.slackBotPostOperations)
+          .where(
+            and(
+              eq(schema.slackBotPostOperations.workspaceId, input.workspaceId),
+              eq(schema.slackBotPostOperations.connectionId, input.connectionId),
+              eq(schema.slackBotPostOperations.operationId, input.operationId),
+            ),
+          )
+          .for("update")
+          .limit(1);
+        if (!existing) throw new Error("Slack post operation disappeared after conflict");
+        if (
+          existing.accountId !== input.accountId ||
+          existing.targetKind !== input.targetKind ||
+          existing.targetId !== input.targetId ||
+          existing.requestDigest !== input.requestDigest ||
+          existing.clientMessageId !== input.operationId
+        ) {
+          return { kind: "conflict" } as const;
+        }
+        if (existing.status === "completed") {
+          return { kind: "completed", operation: mapSlackBotPostOperation(existing) } as const;
+        }
+
+        const [reclaimed] = await tx
+          .update(schema.slackBotPostOperations)
+          .set({
+            claimHolderId: input.claimHolderId,
+            claimExpiresAt: sql`now() + (${claimLeaseMs} * interval '1 millisecond')`,
+            attemptCount: sql`${schema.slackBotPostOperations.attemptCount} + 1`,
+            lastFailureCode: null,
+            updatedAt: sql`now()`,
+          })
+          .where(
+            and(
+              eq(schema.slackBotPostOperations.id, existing.id),
+              or(
+                isNull(schema.slackBotPostOperations.claimHolderId),
+                lte(schema.slackBotPostOperations.claimExpiresAt, sql`now()`),
+              ),
+            ),
+          )
+          .returning();
+        return reclaimed
+          ? ({ kind: "claimed", operation: mapSlackBotPostOperation(reclaimed) } as const)
+          : ({ kind: "in_progress", operation: mapSlackBotPostOperation(existing) } as const);
+      }),
+  );
+}
+
+export async function releaseSlackBotPostOperationClaim(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    claimHolderId: string;
+    failureCode: string;
+  },
+): Promise<boolean> {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb
+        .update(schema.slackBotPostOperations)
+        .set({
+          claimHolderId: null,
+          claimExpiresAt: null,
+          lastFailureCode: input.failureCode.slice(0, 128),
+          updatedAt: sql`now()`,
+        })
+        .where(
+          and(
+            eq(schema.slackBotPostOperations.workspaceId, input.workspaceId),
+            eq(schema.slackBotPostOperations.connectionId, input.connectionId),
+            eq(schema.slackBotPostOperations.operationId, input.operationId),
+            eq(schema.slackBotPostOperations.status, "provider_started"),
+            eq(schema.slackBotPostOperations.claimHolderId, input.claimHolderId),
+          ),
+        )
+        .returning({ id: schema.slackBotPostOperations.id });
+      return rows.length === 1;
+    },
+  );
+}
+
+export type CompleteSlackBotPostOperationResult =
+  | { kind: "completed"; operation: SlackBotPostOperation; newlyCompleted: boolean }
+  | { kind: "not_found" | "not_owned" };
+
+/** Completion and the single success audit receipt commit atomically. */
+export async function completeSlackBotPostOperation(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    connectionId: string;
+    operationId: string;
+    claimHolderId: string;
+    slackChannelId: string;
+    slackMessageTimestamp: string;
+    subjectId?: string | null;
+    auditMetadata: Record<string, unknown>;
+  },
+): Promise<CompleteSlackBotPostOperationResult> {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) =>
+      await scopedDb.transaction(async (txRaw) => {
+        const tx = txRaw as unknown as Database;
+        const [current] = await tx
+          .select()
+          .from(schema.slackBotPostOperations)
+          .where(
+            and(
+              eq(schema.slackBotPostOperations.workspaceId, input.workspaceId),
+              eq(schema.slackBotPostOperations.connectionId, input.connectionId),
+              eq(schema.slackBotPostOperations.operationId, input.operationId),
+            ),
+          )
+          .for("update")
+          .limit(1);
+        if (!current) return { kind: "not_found" } as const;
+        if (current.status === "completed") {
+          return {
+            kind: "completed",
+            operation: mapSlackBotPostOperation(current),
+            newlyCompleted: false,
+          } as const;
+        }
+        if (current.claimHolderId !== input.claimHolderId) {
+          return { kind: "not_owned" } as const;
+        }
+        const [completed] = await tx
+          .update(schema.slackBotPostOperations)
+          .set({
+            status: "completed",
+            claimHolderId: null,
+            claimExpiresAt: null,
+            lastFailureCode: null,
+            slackChannelId: input.slackChannelId,
+            slackMessageTimestamp: input.slackMessageTimestamp,
+            completedAt: sql`now()`,
+            updatedAt: sql`now()`,
+          })
+          .where(eq(schema.slackBotPostOperations.id, current.id))
+          .returning();
+        if (!completed) throw new Error("Slack post completion returned no row");
+        await tx.insert(schema.auditEvents).values({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          subjectId: input.subjectId ?? null,
+          action: "slack_bot.message.post",
+          targetType: "connection",
+          targetId: input.connectionId,
+          metadata: input.auditMetadata,
+        });
+        return {
+          kind: "completed",
+          operation: mapSlackBotPostOperation(completed),
+          newlyCompleted: true,
+        } as const;
+      }),
+  );
+}
+
+export async function getSlackBotPostOperation(
+  db: Database,
+  workspaceId: string,
+  connectionId: string,
+  operationId: string,
+): Promise<SlackBotPostOperation | null> {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const [row] = await scopedDb
+      .select()
+      .from(schema.slackBotPostOperations)
+      .where(
+        and(
+          eq(schema.slackBotPostOperations.workspaceId, workspaceId),
+          eq(schema.slackBotPostOperations.connectionId, connectionId),
+          eq(schema.slackBotPostOperations.operationId, operationId),
+        ),
+      )
+      .limit(1);
+    return row ? mapSlackBotPostOperation(row) : null;
+  });
+}
+
 export async function loadConnectionCredentialForBroker(
   db: Database,
   settings: Settings,
@@ -5019,6 +5335,10 @@ export async function setConnectionStatus(
         status,
         lastError,
         version: sql`${schema.connections.version} + 1`,
+        verifiedInstallVersion: sql`case
+          when ${schema.connections.verifiedInstallAt} is null then null
+          else ${schema.connections.version} + 1
+        end`,
         updatedAt: new Date(),
       })
       .where(
@@ -35402,12 +35722,14 @@ function mapConnectionMetadata(row: {
   lastUsedAt: Date | null;
   lastError: string | null;
   version: number;
+  verifiedInstallAt: Date | null;
+  verifiedInstallVersion: number | null;
   metadata: Record<string, unknown>;
   createdBySubjectId: string | null;
   updatedBySubjectId: string | null;
   createdAt: Date;
   updatedAt: Date;
-}): ConnectionMetadata {
+}): ConnectionMetadataWithVerification {
   return {
     id: row.id,
     accountId: row.accountId,
@@ -35422,6 +35744,8 @@ function mapConnectionMetadata(row: {
     lastUsedAt: row.lastUsedAt?.toISOString() ?? null,
     lastError: row.lastError,
     version: row.version,
+    verifiedInstallAt: row.verifiedInstallAt?.toISOString() ?? null,
+    verifiedInstallVersion: row.verifiedInstallVersion,
     metadata: row.metadata,
     createdBySubjectId: row.createdBySubjectId,
     updatedBySubjectId: row.updatedBySubjectId,
@@ -35430,6 +35754,32 @@ function mapConnectionMetadata(row: {
   };
 }
 
+function mapSlackBotPostOperation(
+  row: typeof schema.slackBotPostOperations.$inferSelect,
+): SlackBotPostOperation {
+  return {
+    id: row.id,
+    accountId: row.accountId,
+    workspaceId: row.workspaceId,
+    connectionId: row.connectionId,
+    operationId: row.operationId,
+    clientMessageId: row.clientMessageId,
+    targetKind: row.targetKind,
+    targetId: row.targetId,
+    requestDigest: row.requestDigest,
+    status: row.status,
+    claimHolderId: row.claimHolderId,
+    claimExpiresAt: row.claimExpiresAt,
+    attemptCount: row.attemptCount,
+    lastFailureCode: row.lastFailureCode,
+    slackChannelId: row.slackChannelId,
+    slackMessageTimestamp: row.slackMessageTimestamp,
+    completedAt: row.completedAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
 function mapKnowledgeMemory(row: typeof schema.knowledgeMemories.$inferSelect): KnowledgeMemory {
   return {
     id: row.id,

package/src/runtime-posture.ts

@@ -73,12 +73,16 @@ export const FORCE_RLS_TABLES = [
   "session_turns",
   "session_workflow_wake_outbox",
   "sessions",
+  "slack_bot_post_operations",
   "social_connections",
   "social_posts",
   "usage_events",
   "workspace_captures",
   "workspace_control_events",
   "workspace_inference_controls",
+  "workspace_instruction_policy_activation_events",
+  "workspace_instruction_policy_heads",
+  "workspace_instruction_policy_revisions",
   "workspace_model_policies",
   "workspace_packs",
   "workspace_session_activity_revisions",
@@ -178,6 +182,7 @@ export const RUNTIME_FULL_DML_TABLES = [
   "session_turns",
   "session_workflow_wake_outbox",
   "sessions",
+  "slack_bot_post_operations",
   "social_connections",
   "social_posts",
   "stripe_webhook_events",
@@ -185,6 +190,7 @@ export const RUNTIME_FULL_DML_TABLES = [
   "workspace_captures",
   "workspace_control_events",
   "workspace_inference_controls",
+  "workspace_instruction_policy_heads",
   "workspace_memberships",
   "workspace_model_policies",
   "workspace_packs",
@@ -197,8 +203,12 @@ export const RUNTIME_FULL_DML_TABLES = [
 /** Configuration is deployment-global and intentionally read-only at runtime. */
 export const RUNTIME_READ_ONLY_TABLES = ["nested_agent_depth_configuration"] as const;
 
-/** Spawn-denial evidence is append-only to the runtime, but remains queryable. */
-export const RUNTIME_READ_INSERT_TABLES = ["session_spawn_denials"] as const;
+/** Append-only evidence/revision tables are insertable and queryable, never mutable. */
+export const RUNTIME_READ_INSERT_TABLES = [
+  "session_spawn_denials",
+  "workspace_instruction_policy_activation_events",
+  "workspace_instruction_policy_revisions",
+] as const;
 
 /**
  * These FORCE-RLS tables are owned by security-definer host-export routines.

package/src/schema.ts

@@ -485,6 +485,12 @@ export const connections = pgTable(
     lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
     lastError: text("last_error"),
     version: integer("version").notNull().default(1),
+    // Server-owned proof that the dedicated install route verified the exact
+    // credential at this connection version. Generic/legacy writers cannot set
+    // these columns, and migration 0131 clears them when protected fields change
+    // without a fresh verification in the same statement.
+    verifiedInstallAt: timestamp("verified_install_at", { withTimezone: true }),
+    verifiedInstallVersion: integer("verified_install_version"),
     metadata: jsonb("metadata").$type<Record<string, unknown>>().notNull().default({}),
     createdBySubjectId: text("created_by_subject_id"),
     updatedBySubjectId: text("updated_by_subject_id"),
@@ -510,6 +516,85 @@ export const connections = pgTable(
   }),
 );
 
+// Durable provider-operation identity for OpenGeni Slack bot posts. The
+// caller-supplied operation UUID is also Slack's client_msg_id; a bounded claim
+// serializes live attempts while an expired/released claim can safely retry the
+// same provider identity after response loss or process death.
+export const slackBotPostOperations = pgTable(
+  "slack_bot_post_operations",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    accountId: uuid("account_id")
+      .notNull()
+      .references(() => managedAccounts.id, { onDelete: "cascade" }),
+    workspaceId: uuid("workspace_id")
+      .notNull()
+      .references(() => workspaces.id, { onDelete: "cascade" }),
+    connectionId: uuid("connection_id")
+      .notNull()
+      .references(() => connections.id, { onDelete: "cascade" }),
+    operationId: uuid("operation_id").notNull(),
+    clientMessageId: uuid("client_message_id").notNull(),
+    targetKind: text("target_kind").$type<"channel" | "user">().notNull(),
+    targetId: text("target_id").notNull(),
+    requestDigest: text("request_digest").notNull(),
+    status: text("status").$type<"provider_started" | "completed">().notNull(),
+    claimHolderId: uuid("claim_holder_id"),
+    claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    lastFailureCode: text("last_failure_code"),
+    slackChannelId: text("slack_channel_id"),
+    slackMessageTimestamp: text("slack_message_timestamp"),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    workspaceOperation: uniqueIndex("slack_bot_post_operations_workspace_operation_uq").on(
+      table.workspaceId,
+      table.connectionId,
+      table.operationId,
+    ),
+    workspaceStatus: index("slack_bot_post_operations_workspace_status_idx").on(
+      table.workspaceId,
+      table.status,
+      table.updatedAt,
+    ),
+    targetKindValid: check(
+      "slack_bot_post_operations_target_kind_check",
+      sql`${table.targetKind} in ('channel', 'user')`,
+    ),
+    statusValid: check(
+      "slack_bot_post_operations_status_check",
+      sql`${table.status} in ('provider_started', 'completed')`,
+    ),
+    identityValid: check(
+      "slack_bot_post_operations_identity_check",
+      sql`${table.clientMessageId} = ${table.operationId}
+        and length(${table.targetId}) between 1 and 64
+        and ${table.requestDigest} ~ '^[0-9a-f]{64}$'
+        and ${table.attemptCount} > 0
+        and ((${table.claimHolderId} is null) = (${table.claimExpiresAt} is null))`,
+    ),
+    completionValid: check(
+      "slack_bot_post_operations_completion_check",
+      sql`(
+          ${table.status} = 'provider_started'
+          and ${table.slackChannelId} is null
+          and ${table.slackMessageTimestamp} is null
+          and ${table.completedAt} is null
+        ) or (
+          ${table.status} = 'completed'
+          and ${table.claimHolderId} is null
+          and ${table.claimExpiresAt} is null
+          and ${table.slackChannelId} is not null
+          and ${table.slackMessageTimestamp} is not null
+          and ${table.completedAt} is not null
+        )`,
+    ),
+  }),
+);
+
 // OAuth client registrations minted through MCP DCR, keyed by authorization
 // server issuer. This is deployment-wide client identity, not a workspace
 // credential; per-user/provider tokens still live only in connections.
@@ -4333,3 +4418,5 @@ export const rigChanges = pgTable(
     workspaceStatus: index("rig_changes_workspace_status_idx").on(table.workspaceId, table.status),
   }),
 );
+
+export * from "./workspace-instruction-policies-schema";