@opengeni/db 1.0.1 → 3.1.0-canary.0

package/src/company-brain.ts

@@ -0,0 +1,309 @@
+import {
+  COMPANY_BRAIN_INSPECTOR_DEFAULT_LIMIT,
+  COMPANY_BRAIN_INSPECTOR_MAX_LIMIT,
+  COMPANY_BRAIN_PROPOSAL_CONTENT_MAX_BYTES,
+  COMPANY_BRAIN_PROPOSAL_RESPONSE_MAX_BYTES,
+  type CompanyBrainKnowledgeProposal,
+  type CompanyBrainKnowledgeProposalPage,
+} from "@opengeni/contracts";
+import { and, asc, desc, eq, inArray, notInArray } from "drizzle-orm";
+
+import type { Database } from "./database";
+import { withWorkspaceSubjectRls } from "./database";
+import * as schema from "./schema";
+
+export const COMPANY_BRAIN_PREFERENCE_MAX_COUNT = 100;
+export const COMPANY_BRAIN_PREFERENCE_MAX_REVISIONS = 256;
+export const COMPANY_BRAIN_PREFERENCE_MAX_CONTENT_BYTES = 2 * 1024 * 1024;
+
+export type CompanyBrainPreferenceGuidanceRow = {
+  preferenceId: string;
+  stableKey: string;
+  scope: string;
+  status: string;
+  supersededByPreferenceId: string | null;
+  revisionId: string;
+  revision: number;
+  title: string;
+  description: string;
+  content: string;
+  contentHash: string;
+  provenanceSource: string;
+  provenanceSourceId: string | null;
+  trust: string;
+  correctsRevisionId: string | null;
+  expiresAt: Date | null;
+  createdAt: Date;
+  active: boolean;
+};
+
+export type CompanyBrainPreferenceGuidancePage = {
+  rows: CompanyBrainPreferenceGuidanceRow[];
+  preferenceCountTruncated: boolean;
+  revisionCountTruncated: boolean;
+  contentBytesTruncated: boolean;
+};
+
+function boundedUtf8Projection(
+  value: string,
+  maxBytes: number,
+): {
+  value: string;
+  originalBytes: number;
+  truncated: boolean;
+} {
+  const originalBytes = Buffer.byteLength(value, "utf8");
+  if (originalBytes <= maxBytes) return { value, originalBytes, truncated: false };
+  const marker = `\n[truncated; original UTF-8 bytes=${originalBytes}]`;
+  const budget = Math.max(0, maxBytes - Buffer.byteLength(marker, "utf8"));
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const midpoint = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, midpoint), "utf8") <= budget) low = midpoint;
+    else high = midpoint - 1;
+  }
+  return { value: value.slice(0, low) + marker, originalBytes, truncated: true };
+}
+
+function proposalPageBytes(page: CompanyBrainKnowledgeProposalPage): number {
+  return Buffer.byteLength(JSON.stringify(page), "utf8");
+}
+
+function finalizeProposalPage(
+  proposals: CompanyBrainKnowledgeProposal[],
+  truncatedForCount: boolean,
+  truncatedForResponseBytes: boolean,
+): CompanyBrainKnowledgeProposalPage {
+  const page: CompanyBrainKnowledgeProposalPage = {
+    proposals,
+    truncatedForCount,
+    truncatedForResponseBytes,
+    responseBytes: 0,
+  };
+  for (let pass = 0; pass < 3; pass += 1) page.responseBytes = proposalPageBytes(page);
+  return page;
+}
+
+/**
+ * Read-only review projection over governed Knowledge change proposals. RLS
+ * filters scope before rows enter this independent item/aggregate byte bound.
+ */
+export async function listCompanyBrainKnowledgeProposals(
+  db: Database,
+  input: { workspaceId: string; subjectId: string; limit?: number },
+): Promise<CompanyBrainKnowledgeProposalPage> {
+  const limit = input.limit ?? COMPANY_BRAIN_INSPECTOR_DEFAULT_LIMIT;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > COMPANY_BRAIN_INSPECTOR_MAX_LIMIT) {
+    throw new Error("Company Brain proposal limit must be between 1 and 50");
+  }
+  return await withWorkspaceSubjectRls(db, input.workspaceId, input.subjectId, async (scopedDb) => {
+    const rows = await scopedDb
+      .select()
+      .from(schema.knowledgeChangeProposals)
+      .where(eq(schema.knowledgeChangeProposals.status, "proposed"))
+      .orderBy(
+        desc(schema.knowledgeChangeProposals.createdAt),
+        desc(schema.knowledgeChangeProposals.id),
+      )
+      .limit(limit + 1);
+    const truncatedForCount = rows.length > limit;
+    const selected: CompanyBrainKnowledgeProposal[] = [];
+    let truncatedForResponseBytes = false;
+    for (const row of rows.slice(0, limit)) {
+      const content = boundedUtf8Projection(row.content, COMPANY_BRAIN_PROPOSAL_CONTENT_MAX_BYTES);
+      const projected: CompanyBrainKnowledgeProposal = {
+        id: row.id,
+        authority: { kind: row.scopeKind as CompanyBrainKnowledgeProposal["authority"]["kind"] },
+        targetKind: row.targetKind as CompanyBrainKnowledgeProposal["targetKind"],
+        targetScope: row.targetScope,
+        targetKey: row.targetKey,
+        content: content.value,
+        contentHash: row.contentHash,
+        source: { claimId: row.claimId, evidenceId: row.evidenceId },
+        status: "proposed",
+        createdAt: row.createdAt.toISOString(),
+        projection: {
+          truncated: content.truncated,
+          originalContentUtf8Bytes: content.originalBytes,
+        },
+      };
+      const candidate = finalizeProposalPage(
+        [...selected, projected],
+        truncatedForCount,
+        truncatedForResponseBytes,
+      );
+      if (candidate.responseBytes > COMPANY_BRAIN_PROPOSAL_RESPONSE_MAX_BYTES) {
+        truncatedForResponseBytes = true;
+        continue;
+      }
+      selected.push(projected);
+    }
+    const page = finalizeProposalPage(selected, truncatedForCount, truncatedForResponseBytes);
+    if (page.responseBytes > COMPANY_BRAIN_PROPOSAL_RESPONSE_MAX_BYTES) {
+      throw new Error("Company Brain proposal projection exceeded its response boundary");
+    }
+    return page;
+  });
+}
+
+export async function listActivatedCompanyBrainPolicyRevisionIds(
+  db: Database,
+  input: { workspaceId: string; subjectId: string; revisionIds: string[] },
+): Promise<string[]> {
+  const revisionIds = [...new Set(input.revisionIds)].sort();
+  if (revisionIds.length === 0) return [];
+  return await withWorkspaceSubjectRls(db, input.workspaceId, input.subjectId, async (scopedDb) => {
+    const rows = await scopedDb
+      .select({ revisionId: schema.workspaceInstructionPolicyActivationEvents.newRevisionId })
+      .from(schema.workspaceInstructionPolicyActivationEvents)
+      .where(
+        and(
+          eq(schema.workspaceInstructionPolicyActivationEvents.workspaceId, input.workspaceId),
+          inArray(schema.workspaceInstructionPolicyActivationEvents.newRevisionId, revisionIds),
+        ),
+      );
+    return [
+      ...new Set(rows.map((row) => row.revisionId).filter((id): id is string => id !== null)),
+    ].sort();
+  });
+}
+
+/**
+ * Read bounded full guidance only after applying the existing subject-aware
+ * Preference Registry RLS context. Personal rows for another subject never
+ * enter the candidate set, and relationship targets are filtered by the API
+ * projection against this authorized page.
+ */
+export async function listCompanyBrainPreferenceGuidance(
+  db: Database,
+  input: { workspaceId: string; subjectId: string },
+): Promise<CompanyBrainPreferenceGuidancePage> {
+  return await withWorkspaceSubjectRls(db, input.workspaceId, input.subjectId, async (scopedDb) => {
+    const preferences = await scopedDb
+      .select()
+      .from(schema.preferenceRegistryPreferences)
+      .orderBy(
+        asc(schema.preferenceRegistryPreferences.scope),
+        asc(schema.preferenceRegistryPreferences.stableKey),
+        asc(schema.preferenceRegistryPreferences.id),
+      )
+      .limit(COMPANY_BRAIN_PREFERENCE_MAX_COUNT + 1);
+
+    const preferenceCountTruncated = preferences.length > COMPANY_BRAIN_PREFERENCE_MAX_COUNT;
+    const boundedPreferences = preferences.slice(0, COMPANY_BRAIN_PREFERENCE_MAX_COUNT);
+    if (boundedPreferences.length === 0) {
+      return {
+        rows: [],
+        preferenceCountTruncated,
+        revisionCountTruncated: false,
+        contentBytesTruncated: false,
+      };
+    }
+
+    const preferenceById = new Map(
+      boundedPreferences.map((preference) => [preference.id, preference] as const),
+    );
+    const preferenceIds = boundedPreferences.map((preference) => preference.id);
+    const activeRevisionIds = [
+      ...new Set(
+        boundedPreferences.flatMap((preference) =>
+          preference.activeRevisionId ? [preference.activeRevisionId] : [],
+        ),
+      ),
+    ].sort();
+    const activeRevisions =
+      activeRevisionIds.length === 0
+        ? []
+        : await scopedDb
+            .select()
+            .from(schema.preferenceRegistryRevisions)
+            .where(inArray(schema.preferenceRegistryRevisions.id, activeRevisionIds))
+            .orderBy(
+              asc(schema.preferenceRegistryRevisions.preferenceId),
+              desc(schema.preferenceRegistryRevisions.revision),
+              asc(schema.preferenceRegistryRevisions.id),
+            );
+    const historicalLimit = Math.max(
+      0,
+      COMPANY_BRAIN_PREFERENCE_MAX_REVISIONS - activeRevisions.length,
+    );
+    const historicalRevisions = await scopedDb
+      .select()
+      .from(schema.preferenceRegistryRevisions)
+      .where(
+        and(
+          inArray(schema.preferenceRegistryRevisions.preferenceId, preferenceIds),
+          activeRevisionIds.length > 0
+            ? notInArray(schema.preferenceRegistryRevisions.id, activeRevisionIds)
+            : undefined,
+        ),
+      )
+      .orderBy(
+        asc(schema.preferenceRegistryRevisions.preferenceId),
+        desc(schema.preferenceRegistryRevisions.revision),
+        asc(schema.preferenceRegistryRevisions.id),
+      )
+      .limit(historicalLimit + 1);
+    const revisionCountTruncated = historicalRevisions.length > historicalLimit;
+    const revisions = [...activeRevisions, ...historicalRevisions.slice(0, historicalLimit)];
+
+    // Active bodies are the most important portable truth. Put them first,
+    // then retain newest authorized history under independent count/byte caps.
+    const ordered = [...revisions].sort((left, right) => {
+      const leftPreference = preferenceById.get(left.preferenceId)!;
+      const rightPreference = preferenceById.get(right.preferenceId)!;
+      const leftActive = left.id === leftPreference.activeRevisionId ? 0 : 1;
+      const rightActive = right.id === rightPreference.activeRevisionId ? 0 : 1;
+      if (leftActive !== rightActive) return leftActive - rightActive;
+      const preferenceOrder = left.preferenceId.localeCompare(right.preferenceId);
+      if (preferenceOrder !== 0) return preferenceOrder;
+      if (left.revision !== right.revision) return right.revision - left.revision;
+      return left.id.localeCompare(right.id);
+    });
+
+    const rows: CompanyBrainPreferenceGuidanceRow[] = [];
+    let contentBytes = 0;
+    let contentBytesTruncated = false;
+    for (const revision of ordered) {
+      const nextBytes = new TextEncoder().encode(revision.content).byteLength;
+      if (contentBytes + nextBytes > COMPANY_BRAIN_PREFERENCE_MAX_CONTENT_BYTES) {
+        contentBytesTruncated = true;
+        continue;
+      }
+      const preference = preferenceById.get(revision.preferenceId);
+      if (!preference) continue;
+      rows.push({
+        preferenceId: preference.id,
+        stableKey: preference.stableKey,
+        scope: preference.scope,
+        status: preference.status,
+        supersededByPreferenceId: preference.supersededByPreferenceId,
+        revisionId: revision.id,
+        revision: revision.revision,
+        title: revision.title,
+        description: revision.description,
+        content: revision.content,
+        contentHash: revision.contentHash,
+        provenanceSource: revision.provenanceSource,
+        provenanceSourceId: revision.provenanceSourceId,
+        trust: revision.trust,
+        correctsRevisionId: revision.correctsRevisionId,
+        expiresAt: revision.expiresAt,
+        createdAt: revision.createdAt,
+        active: revision.id === preference.activeRevisionId,
+      });
+      contentBytes += nextBytes;
+    }
+
+    if (rows.length < ordered.length) {
+      contentBytesTruncated = true;
+    }
+    return {
+      rows,
+      preferenceCountTruncated,
+      revisionCountTruncated,
+      contentBytesTruncated,
+    };
+  });
+}

package/src/company-profile-agent-admin.ts

@@ -0,0 +1,225 @@
+import { createHash } from "node:crypto";
+import {
+  CompanyProfileAgentAttempt,
+  CompanyProfileAgentConfirmRequest,
+  CompanyProfileAgentConfirmationReceipt,
+  CompanyProfileAgentHumanInputPrompt,
+  CompanyProfileAgentProposalReceipt,
+  CompanyProfileAgentProposalRequest,
+  CompanyProfileContent,
+  type CompanyProfileAgentAttempt as CompanyProfileAgentAttemptType,
+  type CompanyProfileAgentConfirmRequest as CompanyProfileAgentConfirmRequestType,
+  type CompanyProfileAgentConfirmationReceipt as CompanyProfileAgentConfirmationReceiptType,
+  type CompanyProfileAgentProposalReceipt as CompanyProfileAgentProposalReceiptType,
+  type CompanyProfileAgentProposalRequest as CompanyProfileAgentProposalRequestType,
+} from "@opengeni/contracts";
+import { sql } from "drizzle-orm";
+import { rawRows, withRlsContext, withSessionRlsActorContext, type Database } from "./database";
+import {
+  getCompanyProfileActivationEvent,
+  getCompanyProfileRevision,
+  listCompanyProfile,
+} from "./company-profile";
+import { nestedPostgresSqlState } from "./persistence-errors";
+
+export class CompanyProfileAgentAdminError extends Error {
+  readonly name = "CompanyProfileAgentAdminError";
+
+  constructor(
+    readonly code:
+      | "authority_unavailable"
+      | "confirmation_unavailable"
+      | "profile_conflict"
+      | "operation_reused"
+      | "invalid_operation",
+    message: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+  }
+}
+
+function canonicalProfileJson(value: unknown): string {
+  const profile = CompanyProfileContent.parse(value);
+  return JSON.stringify({
+    identity: profile.identity,
+    mission: profile.mission,
+    products: profile.products.map(({ key, content }) => ({ key, content })),
+    customers: profile.customers.map(({ key, content }) => ({ key, content })),
+    goals: profile.goals.map(({ key, content }) => ({ key, content })),
+    constraints: profile.constraints.map(({ key, content }) => ({ key, content })),
+  });
+}
+
+function translate(error: unknown, stage: "propose" | "confirm"): never {
+  const state = nestedPostgresSqlState(error);
+  if (state === "42501") {
+    throw new CompanyProfileAgentAdminError(
+      stage === "confirm" ? "confirmation_unavailable" : "authority_unavailable",
+      stage === "confirm"
+        ? "The bound organization-owner confirmation is unavailable or no longer valid."
+        : "An exact live turn initiated by the active organization owner is required.",
+      { cause: error },
+    );
+  }
+  if (state === "40001") {
+    throw new CompanyProfileAgentAdminError(
+      "profile_conflict",
+      "The organization company profile changed after this proposal was prepared. Create a new proposal against the current profile.",
+      { cause: error },
+    );
+  }
+  if (state === "P1851" || state === "23505") {
+    throw new CompanyProfileAgentAdminError(
+      "operation_reused",
+      "The company-profile operation id was already used for different input.",
+      { cause: error },
+    );
+  }
+  if (state === "22023" || state === "23514" || state === "55000") {
+    throw new CompanyProfileAgentAdminError(
+      "invalid_operation",
+      "The company-profile administration request is invalid or no longer eligible.",
+      { cause: error },
+    );
+  }
+  throw error;
+}
+
+async function withAgentAttemptContext<T>(
+  db: Database,
+  attempt: CompanyProfileAgentAttemptType,
+  fn: (scoped: Database) => Promise<T>,
+): Promise<T> {
+  return await withSessionRlsActorContext({ subjectId: attempt.agentSubjectId }, async () =>
+    withRlsContext(
+      db,
+      { accountId: attempt.accountId, workspaceId: attempt.workspaceId },
+      async (scoped) => {
+        await scoped.execute(
+          sql`select set_config('opengeni.principal_kind', 'agent_attempt', true)`,
+        );
+        return await fn(scoped);
+      },
+    ),
+  );
+}
+
+export async function proposeCompanyProfileForAgent(
+  db: Database,
+  raw: { attempt: CompanyProfileAgentAttemptType; request: CompanyProfileAgentProposalRequestType },
+): Promise<CompanyProfileAgentProposalReceiptType> {
+  const attempt = CompanyProfileAgentAttempt.parse(raw.attempt);
+  const request = CompanyProfileAgentProposalRequest.parse(raw.request);
+  const contentJson = canonicalProfileJson(request.profile);
+  const contentHash = createHash("sha256").update(contentJson, "utf8").digest("hex");
+  try {
+    const result = await withAgentAttemptContext(db, attempt, async (scoped) => {
+      const [row] = await rawRows<{
+        receipt_id: string;
+        revision_id: string;
+        human_input: unknown;
+        replayed: boolean;
+      }>(
+        scoped,
+        sql`select * from propose_company_profile_for_attempt(
+          ${attempt.accountId}::uuid,
+          ${attempt.workspaceId}::uuid,
+          ${attempt.sessionId}::uuid,
+          ${attempt.turnId}::uuid,
+          ${attempt.attemptId}::uuid,
+          ${attempt.executionGeneration},
+          ${request.operationId}::uuid,
+          ${contentJson},
+          ${contentHash},
+          ${request.reason}
+        )`,
+      );
+      if (!row) throw new Error("Company-profile proposal returned no receipt");
+      return row;
+    });
+    const revision = await getCompanyProfileRevision(db, {
+      accountId: attempt.accountId,
+      workspaceId: attempt.workspaceId,
+      revisionId: result.revision_id,
+    });
+    return CompanyProfileAgentProposalReceipt.parse({
+      status: "confirmation_required",
+      operationId: request.operationId,
+      proposalReceiptId: result.receipt_id,
+      revision,
+      humanInput: CompanyProfileAgentHumanInputPrompt.parse(result.human_input),
+      confirmWith: "company_profile_confirm",
+      replayed: result.replayed,
+    });
+  } catch (error) {
+    translate(error, "propose");
+  }
+}
+
+export async function confirmCompanyProfileForAgent(
+  db: Database,
+  raw: { attempt: CompanyProfileAgentAttemptType; request: CompanyProfileAgentConfirmRequestType },
+): Promise<CompanyProfileAgentConfirmationReceiptType> {
+  const attempt = CompanyProfileAgentAttempt.parse(raw.attempt);
+  const request = CompanyProfileAgentConfirmRequest.parse(raw.request);
+  try {
+    const result = await withAgentAttemptContext(db, attempt, async (scoped) => {
+      const [row] = await rawRows<{
+        receipt_id: string;
+        activation_event_id: string;
+        replayed: boolean;
+      }>(
+        scoped,
+        sql`select * from confirm_company_profile_for_attempt(
+          ${attempt.accountId}::uuid,
+          ${attempt.workspaceId}::uuid,
+          ${attempt.sessionId}::uuid,
+          ${attempt.turnId}::uuid,
+          ${attempt.attemptId}::uuid,
+          ${attempt.executionGeneration},
+          ${request.operationId}::uuid,
+          ${request.proposalReceiptId}::uuid,
+          ${request.humanInputRequestId}::uuid
+        )`,
+      );
+      if (!row) throw new Error("Company-profile confirmation returned no receipt");
+      return row;
+    });
+    const [inventory, event] = await Promise.all([
+      listCompanyProfile(db, {
+        accountId: attempt.accountId,
+        workspaceId: attempt.workspaceId,
+        limit: 1,
+      }),
+      getCompanyProfileActivationEvent(db, {
+        accountId: attempt.accountId,
+        workspaceId: attempt.workspaceId,
+        eventId: result.activation_event_id,
+      }),
+    ]);
+    if (!event?.newRevision) {
+      throw new Error("Company-profile confirmation activation event is unavailable");
+    }
+    const revision = await getCompanyProfileRevision(db, {
+      accountId: attempt.accountId,
+      workspaceId: attempt.workspaceId,
+      revisionId: event.newRevision.id,
+    });
+    return CompanyProfileAgentConfirmationReceipt.parse({
+      status: "activated",
+      operationId: request.operationId,
+      confirmationReceiptId: result.receipt_id,
+      proposalReceiptId: request.proposalReceiptId,
+      humanInputRequestId: request.humanInputRequestId,
+      mutation: {
+        revision,
+        head: inventory.current?.revisionId === revision.id ? inventory.current : null,
+        event,
+      },
+      replayed: result.replayed,
+    });
+  } catch (error) {
+    translate(error, "confirm");
+  }
+}

package/src/company-profile-schema.ts

@@ -1,5 +1,8 @@
 import { sql } from "drizzle-orm";
-import type { CompanyProfileSnapshotEntry } from "@opengeni/contracts";
+import type {
+  CompanyProfileAgentHumanInputPrompt,
+  CompanyProfileSnapshotEntry,
+} from "@opengeni/contracts";
 import {
   bigint,
   check,
@@ -37,6 +40,7 @@ export const companyProfileRevisions = pgTable(
       table.accountId,
       table.operationId,
     ),
+    idAccount: uniqueIndex("company_profile_revisions_id_account_uq").on(table.id, table.accountId),
     accountRevision: uniqueIndex("company_profile_revisions_account_revision_uq").on(
       table.accountId,
       table.revision,
@@ -89,6 +93,7 @@ export const companyProfileActivationEvents = pgTable(
       table.accountId,
       table.operationId,
     ),
+    idAccount: uniqueIndex("company_profile_events_id_account_uq").on(table.id, table.accountId),
     accountActivationVersion: uniqueIndex("company_profile_events_account_version_uq").on(
       table.accountId,
       table.activationVersion,
@@ -141,3 +146,118 @@ export const companyProfileSnapshots = pgTable(
     ),
   }),
 );
+
+export const companyProfileAgentProposalReceipts = pgTable(
+  "company_profile_agent_proposal_receipts",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    operationId: uuid("operation_id").notNull(),
+    inputHash: text("input_hash").notNull(),
+    accountId: uuid("account_id").notNull(),
+    workspaceId: uuid("workspace_id").notNull(),
+    sessionId: uuid("session_id").notNull(),
+    turnId: uuid("turn_id").notNull(),
+    creationAttemptId: uuid("creation_attempt_id").notNull(),
+    executionGeneration: integer("execution_generation").notNull(),
+    initiatingHumanSubjectId: text("initiating_human_subject_id").notNull(),
+    initiatingMembershipId: uuid("initiating_membership_id").notNull(),
+    revisionId: uuid("revision_id").notNull(),
+    expectedCurrentRevisionId: uuid("expected_current_revision_id"),
+    expectedActivationVersion: bigint("expected_activation_version", { mode: "number" }).notNull(),
+    reason: text("reason").notNull(),
+    humanInput: jsonb("human_input").$type<CompanyProfileAgentHumanInputPrompt>().notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    accountOperation: uniqueIndex("company_profile_agent_proposals_account_operation_uq").on(
+      table.accountId,
+      table.operationId,
+    ),
+    accountRevision: uniqueIndex("company_profile_agent_proposals_account_revision_uq").on(
+      table.accountId,
+      table.revisionId,
+    ),
+    idAccount: uniqueIndex("company_profile_agent_proposals_id_account_uq").on(
+      table.id,
+      table.accountId,
+    ),
+    turn: index("company_profile_agent_proposals_turn_idx").on(
+      table.workspaceId,
+      table.sessionId,
+      table.turnId,
+      table.executionGeneration,
+    ),
+    hash: check(
+      "company_profile_agent_proposals_input_hash_check",
+      sql`${table.inputHash} ~ '^[0-9a-f]{64}$'`,
+    ),
+    generation: check(
+      "company_profile_agent_proposals_generation_check",
+      sql`${table.executionGeneration} > 0 and ${table.expectedActivationVersion} >= 0`,
+    ),
+    subject: check(
+      "company_profile_agent_proposals_subject_check",
+      sql`octet_length(btrim(${table.initiatingHumanSubjectId})) between 1 and 1024`,
+    ),
+    reason: check(
+      "company_profile_agent_proposals_reason_check",
+      sql`char_length(btrim(${table.reason})) between 1 and 4096
+        and octet_length(convert_to(btrim(${table.reason}), 'UTF8')) <= 16384`,
+    ),
+    humanInputShape: check(
+      "company_profile_agent_proposals_human_input_check",
+      sql`jsonb_typeof(${table.humanInput}) = 'object'
+        and jsonb_array_length(${table.humanInput}->'questions') = 1
+        and ${table.humanInput}->>'allowSkip' = 'false'
+        and octet_length(${table.humanInput}::text) <= 49152`,
+    ),
+  }),
+);
+
+export const companyProfileAgentConfirmationReceipts = pgTable(
+  "company_profile_agent_confirmation_receipts",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    operationId: uuid("operation_id").notNull(),
+    inputHash: text("input_hash").notNull(),
+    accountId: uuid("account_id").notNull(),
+    workspaceId: uuid("workspace_id").notNull(),
+    sessionId: uuid("session_id").notNull(),
+    turnId: uuid("turn_id").notNull(),
+    confirmationAttemptId: uuid("confirmation_attempt_id").notNull(),
+    executionGeneration: integer("execution_generation").notNull(),
+    proposalReceiptId: uuid("proposal_receipt_id").notNull(),
+    proposalRevisionId: uuid("proposal_revision_id").notNull(),
+    humanInputRequestId: uuid("human_input_request_id").notNull(),
+    approverSubjectId: text("approver_subject_id").notNull(),
+    approverMembershipId: uuid("approver_membership_id").notNull(),
+    activationEventId: uuid("activation_event_id").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => ({
+    accountOperation: uniqueIndex("company_profile_agent_confirmations_account_operation_uq").on(
+      table.accountId,
+      table.operationId,
+    ),
+    proposal: uniqueIndex("company_profile_agent_confirmations_proposal_uq").on(
+      table.accountId,
+      table.proposalReceiptId,
+    ),
+    activationEvent: uniqueIndex("company_profile_agent_confirmations_event_uq").on(
+      table.accountId,
+      table.activationEventId,
+    ),
+    hash: check(
+      "company_profile_agent_confirmations_input_hash_check",
+      sql`${table.inputHash} ~ '^[0-9a-f]{64}$'`,
+    ),
+    generation: check(
+      "company_profile_agent_confirmations_generation_check",
+      sql`${table.executionGeneration} > 0`,
+    ),
+    subject: check(
+      "company_profile_agent_confirmations_subject_check",
+      sql`octet_length(btrim(${table.approverSubjectId})) between 1 and 1024`,
+    ),
+  }),
+);