@opengeni/db 3.6.0 → 3.7.3-canary.0

package/drizzle/0382_organization_api_key_provenance.sql

@@ -0,0 +1,91 @@
+-- deployment-mode: rolling
+-- Organization-wide workspace authority must come from an explicitly issued
+-- organization key, never from the historical workspace_id IS NULL shape.
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '5min';
+
+ALTER TABLE api_keys
+  ADD COLUMN credential_kind text;
+
+ALTER TABLE api_keys NO FORCE ROW LEVEL SECURITY;
+
+UPDATE api_keys
+SET
+  credential_kind = CASE
+    WHEN workspace_id IS NOT NULL THEN 'workspace'
+    ELSE 'legacy_account'
+  END,
+  revoked_at = CASE
+    WHEN workspace_id IS NULL THEN COALESCE(revoked_at, CURRENT_TIMESTAMP)
+    ELSE revoked_at
+  END,
+  updated_at = CASE
+    WHEN workspace_id IS NULL AND revoked_at IS NULL THEN CURRENT_TIMESTAMP
+    ELSE updated_at
+  END;
+
+ALTER TABLE api_keys FORCE ROW LEVEL SECURITY;
+
+CREATE FUNCTION opengeni_private.normalize_api_key_credential_kind()
+RETURNS trigger
+LANGUAGE plpgsql
+SECURITY INVOKER
+SET search_path = pg_catalog, public
+AS $function$
+BEGIN
+  IF NEW.workspace_id IS NOT NULL THEN
+    NEW.credential_kind := 'workspace';
+  ELSIF NEW.credential_kind IS NULL THEN
+    -- The previous application version omitted this column. Its organization-key
+    -- route is the only null-workspace insert path with this exact fixed grant.
+    IF NEW.permissions = '["account:read","workspace:create","workspace:read","workspace:admin","api_keys:manage"]'::jsonb THEN
+      NEW.credential_kind := 'organization';
+    ELSE
+      NEW.credential_kind := 'legacy_account';
+    END IF;
+  END IF;
+
+  -- Old application versions authorize every active null-workspace row by
+  -- shape alone. Keep ambiguous legacy rows unusable through that old lookup
+  -- path for the entire rolling window; only the exact previous organization
+  -- writer above may create an active null-workspace credential.
+  IF NEW.credential_kind = 'legacy_account' AND NEW.revoked_at IS NULL THEN
+    NEW.revoked_at := CURRENT_TIMESTAMP;
+    NEW.updated_at := CURRENT_TIMESTAMP;
+  END IF;
+
+  RETURN NEW;
+END;
+$function$;
+
+REVOKE ALL ON FUNCTION opengeni_private.normalize_api_key_credential_kind() FROM PUBLIC;
+
+CREATE TRIGGER api_keys_00_normalize_credential_kind
+BEFORE INSERT OR UPDATE OF workspace_id, credential_kind, permissions, revoked_at
+ON api_keys
+FOR EACH ROW
+EXECUTE FUNCTION opengeni_private.normalize_api_key_credential_kind();
+
+ALTER TABLE api_keys
+  ALTER COLUMN credential_kind SET NOT NULL;
+
+ALTER TABLE api_keys
+  ADD CONSTRAINT api_keys_credential_kind_check
+  CHECK (
+    (workspace_id IS NOT NULL AND credential_kind = 'workspace')
+    OR
+    (workspace_id IS NULL AND credential_kind = 'organization')
+    OR
+    (workspace_id IS NULL AND credential_kind = 'legacy_account' AND revoked_at IS NOT NULL)
+  ) NOT VALID;
+
+ALTER TABLE api_keys
+  VALIDATE CONSTRAINT api_keys_credential_kind_check;
+
+CREATE INDEX api_keys_organization_account_idx
+  ON api_keys (account_id, created_at DESC)
+  WHERE credential_kind = 'organization';
+
+COMMENT ON COLUMN api_keys.credential_kind IS
+  'Persisted API-key provenance. Only organization keys receive organization-wide shared-workspace authority; ambiguous legacy account keys are revoked.';

package/drizzle/0383_codex_cooldown_reconciliation.sql

@@ -0,0 +1,51 @@
+-- deployment-mode: rolling
+--
+-- Give Codex cooldowns typed provenance plus an independent revision. A fresh
+-- provider usage read may then clear only the exact quota cooldown it observed
+-- before the request; generic backpressure and a concurrently newer refusal
+-- remain authoritative. Legacy writers do not know these columns, so the
+-- trigger advances the revision and removes typed auto-clear authority whenever
+-- they change exhausted_until alone during a rolling deployment.
+
+ALTER TABLE "codex_subscription_credentials"
+  ADD COLUMN "exhausted_kind" text,
+  ADD COLUMN "exhausted_revision" bigint NOT NULL DEFAULT 0,
+  ADD CONSTRAINT "codex_credentials_exhausted_kind_chk" CHECK (
+    ("exhausted_until" IS NULL AND "exhausted_kind" IS NULL)
+    OR (
+      "exhausted_until" IS NOT NULL
+      AND ("exhausted_kind" IS NULL OR "exhausted_kind" IN ('quota', 'rate_limit'))
+    )
+  );
+
+CREATE OR REPLACE FUNCTION opengeni_private.codex_cooldown_revision_guard()
+RETURNS trigger
+LANGUAGE plpgsql
+SET search_path = pg_catalog
+AS $function$
+BEGIN
+  IF NEW.exhausted_until IS DISTINCT FROM OLD.exhausted_until THEN
+    IF NEW.exhausted_revision = OLD.exhausted_revision THEN
+      -- Compatibility path for a pre-0382 writer: retain the cooldown but do
+      -- not let a new usage reader mistake its unknown cause for quota.
+      NEW.exhausted_kind := NULL;
+      NEW.exhausted_revision := OLD.exhausted_revision + 1;
+    ELSIF NEW.exhausted_revision <> OLD.exhausted_revision + 1 THEN
+      RAISE EXCEPTION 'Codex cooldown revision must advance exactly once';
+    END IF;
+  ELSIF NEW.exhausted_kind IS DISTINCT FROM OLD.exhausted_kind
+    OR NEW.exhausted_revision IS DISTINCT FROM OLD.exhausted_revision
+  THEN
+    IF NEW.exhausted_revision <> OLD.exhausted_revision + 1 THEN
+      RAISE EXCEPTION 'Codex cooldown metadata revision must advance exactly once';
+    END IF;
+  END IF;
+  RETURN NEW;
+END
+$function$;
+
+CREATE TRIGGER codex_cooldown_revision_guard
+  BEFORE UPDATE OF exhausted_until, exhausted_kind, exhausted_revision
+  ON "codex_subscription_credentials"
+  FOR EACH ROW
+  EXECUTE FUNCTION opengeni_private.codex_cooldown_revision_guard();

package/drizzle/0384_codex_cooldown_revision_guard_privileges.sql

@@ -0,0 +1,6 @@
+-- deployment-mode: rolling
+-- Trigger helpers are owner-internal implementation details. PostgreSQL grants
+-- PUBLIC execute on new functions by default, so remove the inherited privilege
+-- that exposed this guard to unrelated runtime roles.
+
+REVOKE ALL ON FUNCTION opengeni_private.codex_cooldown_revision_guard() FROM PUBLIC;

package/drizzle/0385_connected_machine_legacy_tilde_workdirs.sql

@@ -0,0 +1,25 @@
+-- deployment-mode: rolling
+-- Native Connected Machine workspace roots made tilde paths invalid. Repair
+-- only legacy sessions whose active machine has reported an exact root; leave
+-- ambiguous/offline legacy rows untouched rather than guessing a user home.
+
+-- Migrations run as the NOSUPERUSER/NOBYPASSRLS table owner. Temporarily let
+-- that owner see the joined rows; application roles remain policy-bound.
+ALTER TABLE "sessions" NO FORCE ROW LEVEL SECURITY;
+ALTER TABLE "sandboxes" NO FORCE ROW LEVEL SECURITY;
+ALTER TABLE "enrollments" NO FORCE ROW LEVEL SECURITY;
+
+UPDATE "sessions" AS session
+SET "working_dir" =
+  rtrim(enrollment."workspace_root", '/') || '/' || substring(session."working_dir" FROM 3)
+FROM "sandboxes" AS sandbox
+JOIN "enrollments" AS enrollment ON enrollment."id" = sandbox."enrollment_id"
+WHERE session."active_sandbox_id" = sandbox."id"
+  AND session."working_dir" LIKE '~/%'
+  AND enrollment."status" = 'active'
+  AND enrollment."workspace_root" IS NOT NULL
+  AND enrollment."workspace_root" <> '';
+
+ALTER TABLE "enrollments" FORCE ROW LEVEL SECURITY;
+ALTER TABLE "sandboxes" FORCE ROW LEVEL SECURITY;
+ALTER TABLE "sessions" FORCE ROW LEVEL SECURITY;

package/drizzle/0386_local_organization_administration.sql

@@ -0,0 +1,157 @@
+-- deployment-mode: maintenance
+--
+-- The canonical single-user local bootstrap already grants `dev` account-owner
+-- authority in the application, but its durable organization membership was
+-- left at the default member role. Converge that exact built-in identity and
+-- admit it to organization Codex administration without broadening configured,
+-- delegated, API-key, service, or agent principals.
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '10min';
+
+CREATE OR REPLACE FUNCTION opengeni_private.assign_managed_self_organization_owner()
+RETURNS trigger
+LANGUAGE plpgsql
+SECURITY DEFINER
+SET search_path FROM CURRENT
+AS $body$
+BEGIN
+  IF EXISTS (
+    SELECT 1 FROM managed_accounts account
+    WHERE account.id = NEW.account_id
+      AND (
+        (
+          account.external_source = 'better-auth:user'
+          AND NEW.subject_id = 'user:' || account.external_id
+        ) OR (
+          account.external_source = 'opengeni:local'
+          AND account.external_id = 'default'
+          AND NEW.subject_id = 'dev'
+        )
+      )
+  ) THEN
+    NEW.role := 'owner';
+  END IF;
+  RETURN NEW;
+END
+$body$;
+
+DO $pin_local_owner_trigger$
+DECLARE data_schema text := current_schema();
+BEGIN
+  EXECUTE format(
+    'ALTER FUNCTION opengeni_private.assign_managed_self_organization_owner() SET search_path = pg_catalog, %I, pg_temp',
+    data_schema
+  );
+END
+$pin_local_owner_trigger$;
+
+ALTER TABLE organization_memberships NO FORCE ROW LEVEL SECURITY;
+UPDATE organization_memberships membership
+SET role = 'owner',
+    authorization_revision = membership.authorization_revision + 1,
+    updated_at = clock_timestamp()
+FROM managed_accounts account
+WHERE account.id = membership.account_id
+  AND account.external_source = 'opengeni:local'
+  AND account.external_id = 'default'
+  AND membership.subject_id = 'dev'
+  AND membership.status = 'active'
+  AND membership.role <> 'owner';
+ALTER TABLE organization_memberships FORCE ROW LEVEL SECURITY;
+
+DO $codex_scope_visibility_schema$
+DECLARE data_schema text := current_schema();
+BEGIN
+  EXECUTE format($ddl$
+    CREATE OR REPLACE FUNCTION opengeni_private.codex_organization_scope_visible(
+      p_account_id uuid
+    ) RETURNS boolean
+    LANGUAGE plpgsql
+    SECURITY DEFINER
+    SET search_path = pg_catalog
+    AS $function$
+    DECLARE
+      workspace_value uuid := opengeni_private.current_workspace_id();
+      subject_value text := opengeni_private.current_subject_id();
+      visible boolean := false;
+      previous_lifecycle text := pg_catalog.current_setting(
+        'opengeni.organization_tenancy_lifecycle', true
+      );
+    BEGIN
+      IF p_account_id IS NULL
+        OR p_account_id IS DISTINCT FROM opengeni_private.current_account_id()
+      THEN
+        RETURN false;
+      END IF;
+      IF workspace_value IS NOT NULL THEN
+        PERFORM pg_catalog.set_config(
+          'opengeni.organization_tenancy_lifecycle',
+          'organization_membership_lifecycle', true
+        );
+        SELECT EXISTS (
+          SELECT 1 FROM %1$I.workspaces workspace
+          WHERE workspace.account_id = p_account_id AND workspace.id = workspace_value
+        ) AND NOT EXISTS (
+          SELECT 1 FROM %1$I.organization_memberships membership
+          WHERE membership.account_id = p_account_id
+            AND membership.personal_workspace_id = workspace_value
+        ) INTO visible;
+        PERFORM pg_catalog.set_config(
+          'opengeni.organization_tenancy_lifecycle', coalesce(previous_lifecycle, ''), true
+        );
+        RETURN coalesce(visible, false);
+      END IF;
+      IF subject_value IS NULL OR NOT (
+        subject_value LIKE 'user:%%'
+        OR (
+          subject_value = 'dev'
+          AND EXISTS (
+            SELECT 1 FROM %1$I.managed_accounts account
+            WHERE account.id = p_account_id
+              AND account.external_source = 'opengeni:local'
+              AND account.external_id = 'default'
+          )
+        )
+      ) THEN
+        RETURN false;
+      END IF;
+      PERFORM pg_catalog.set_config(
+        'opengeni.organization_tenancy_lifecycle',
+        'organization_membership_lifecycle', true
+      );
+      SELECT EXISTS (
+        SELECT 1 FROM %1$I.organization_memberships membership
+        WHERE membership.account_id = p_account_id
+          AND membership.subject_id = subject_value
+          AND membership.status = 'active'
+          AND membership.role IN ('owner', 'admin')
+      ) INTO visible;
+      PERFORM pg_catalog.set_config(
+        'opengeni.organization_tenancy_lifecycle', coalesce(previous_lifecycle, ''), true
+      );
+      RETURN coalesce(visible, false);
+    EXCEPTION WHEN OTHERS THEN
+      PERFORM pg_catalog.set_config(
+        'opengeni.organization_tenancy_lifecycle', coalesce(previous_lifecycle, ''), true
+      );
+      RAISE;
+    END
+    $function$
+  $ddl$, data_schema);
+END
+$codex_scope_visibility_schema$;
+
+REVOKE ALL ON FUNCTION opengeni_private.assign_managed_self_organization_owner() FROM PUBLIC;
+REVOKE ALL ON FUNCTION opengeni_private.codex_organization_scope_visible(uuid) FROM PUBLIC;
+
+DO $grants$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT EXECUTE ON FUNCTION opengeni_private.assign_managed_self_organization_owner()
+      TO opengeni_app;
+    GRANT EXECUTE ON FUNCTION opengeni_private.codex_organization_scope_visible(uuid)
+      TO opengeni_app;
+  END IF;
+END
+$grants$;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/db",
-  "version": "3.6.0",
+  "version": "3.7.3-canary.0",
   "description": "OpenGeni persistence: Drizzle schema, RLS-scoped query layer, the SQL migration runner, and role provisioning.",
   "license": "Apache-2.0",
   "repository": {
@@ -78,11 +78,11 @@
     "prepublishOnly": "bash ../../scripts/prepublish-guard"
   },
   "dependencies": {
-    "@opengeni/codemode": "^0.4.17",
-    "@opengeni/codex": "^0.2.19",
-    "@opengeni/config": "^0.22.0",
-    "@opengeni/contracts": "^2.7.0",
-    "@opengeni/network": "^0.2.3",
+    "@opengeni/codemode": "^0.4.22-canary.0",
+    "@opengeni/codex": "^0.2.20-canary.0",
+    "@opengeni/config": "^0.22.5-canary.0",
+    "@opengeni/contracts": "^2.9.2-canary.0",
+    "@opengeni/network": "^0.2.3-canary.5",
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.7"
   },

package/src/codex-token-resolver.ts

@@ -24,6 +24,7 @@ import {
   CODEX_REFRESH_FALLBACK_MS,
   CODEX_REFRESH_WINDOW_MS,
   CodexReloginRequired,
+  codexUsageConfirmsQuotaAvailable,
   type CodexTokenSnapshot,
   type CodexUsagePayload,
   type CodexFetch,
@@ -43,6 +44,8 @@ export type CodexCredentialTokens = {
   idToken: string;
 };
 
+export type CodexCredentialCooldownKind = "quota" | "rate_limit";
+
 export type CodexCredentialForRun = {
   id: string;
   version: number;
@@ -56,6 +59,9 @@ export type CodexCredentialForRun = {
   lastRefreshAt: Date | null;
   status: string;
   lastError: string | null;
+  exhaustedUntil: Date | null;
+  exhaustedKind: CodexCredentialCooldownKind | null;
+  exhaustedRevision: number;
 };
 
 export type CodexAccountUsageSnapshot = {
@@ -66,6 +72,12 @@ export type CodexAccountUsageSnapshot = {
   checkedAt?: Date;
   resetCreditAvailableCount?: number | null;
   resetCreditsCheckedAt?: Date | null;
+  /**
+   * Clear only a quota cooldown with this exact revision. Set solely after a
+   * live provider response proves allowance is open; a concurrent refusal
+   * advances the revision and makes this observation stale.
+   */
+  clearQuotaCooldownRevision?: number;
 };
 
 type CodexCredentialRefreshInput = {
@@ -375,7 +387,8 @@ function errorUsagePayload(reason?: "needs_relogin"): CodexUsagePayload {
  *      account's expired JWT from 401-ing the usage read.
  *   2. fetch GET /wham/usage with that bearer.
  *   3. normalize (§3) into the P2/P3 contract.
- *   4. on any windows present, write the five usage-cache columns (the TTL clock).
+ *   4. on any windows present, write the usage cache and conditionally reconcile
+ *      the exact older typed quota cooldown observed before provider I/O.
  *
  * A refresh that stamps needs_relogin returns { status:"error", reason } and never
  * hits the provider; a transient refresh error returns a plain error payload.
@@ -396,6 +409,13 @@ export async function fetchCodexUsageForAccount(
     return errorUsagePayload(error instanceof CodexReloginRequired ? "needs_relogin" : undefined);
   }
 
+  // Snapshot cooldown authority immediately before provider I/O. The usage
+  // write may clear only this exact revision; any concurrent refusal advances
+  // it and wins. A metadata-read failure must not sink the usage response.
+  const observedCredential = await deps
+    .loadCredential(db, settings, workspaceId, credentialId)
+    .catch(() => null);
+
   let normalized: CodexUsagePayload;
   try {
     const usage = await fetchCodexUsage(
@@ -438,6 +458,11 @@ export async function fetchCodexUsageForAccount(
               checkedAt,
             }
           : {}),
+        ...(observedCredential?.exhaustedUntil &&
+        observedCredential.exhaustedKind === "quota" &&
+        codexUsageConfirmsQuotaAvailable(normalized)
+          ? { clearQuotaCooldownRevision: observedCredential.exhaustedRevision }
+          : {}),
         ...(normalized.rateLimitResetCredits
           ? {
               resetCreditAvailableCount: normalized.rateLimitResetCredits.availableCount,

package/src/company-brain-governed-writes.ts

@@ -15,7 +15,11 @@ import {
 import { and, eq, inArray, sql } from "drizzle-orm";
 import type { Database } from "./database";
 import { rawRows, setSubjectRlsContext, withRlsContext } from "./database";
-import { sanitizePreferenceDescriptorText } from "./preference-registry";
+import {
+  PreferenceRegistryStableKeyConflictError,
+  sanitizePreferenceDescriptorText,
+} from "./preference-registry";
+import { nestedPostgresSqlState, safeDatabaseErrorFacts } from "./persistence-errors";
 import {
   appendKnowledgeClaim,
   appendKnowledgeClaimReview,
@@ -847,6 +851,26 @@ function isInstructionPolicyProposal(
   );
 }
 
+function isPreferenceProposal(
+  request: CompanyBrainGovernedWriteRequestType,
+): request is PreferenceProposalRequest {
+  return request.kind === "propose_preference" || request.kind === "promote_task_note_preference";
+}
+
+const PREFERENCE_PROPOSAL_STABLE_KEY_CONFLICT_DIAGNOSTIC =
+  "workspace preference key is bound to another proposal";
+
+function isPreferenceProposalStableKeyConflict(error: unknown): boolean {
+  if (nestedPostgresSqlState(error) !== "23505") return false;
+  const constraint = safeDatabaseErrorFacts(error).constraint ?? "";
+  if (constraint.startsWith("preference_registry_preferences_")) return true;
+  for (let current = error, depth = 0; current instanceof Error && depth < 8; depth += 1) {
+    if (current.message.includes(PREFERENCE_PROPOSAL_STABLE_KEY_CONFLICT_DIAGNOSTIC)) return true;
+    current = current.cause;
+  }
+  return false;
+}
+
 async function materializeWaysOfWorkingProposal(
   db: Database,
   input: {
@@ -1008,6 +1032,11 @@ export async function writeCompanyBrainGovernedProposal(
     ) {
       throw error;
     }
+    if (isPreferenceProposal(request) && isPreferenceProposalStableKeyConflict(error)) {
+      throw new PreferenceRegistryStableKeyConflictError(
+        "A preference with this stable key already exists for the workspace",
+      );
+    }
     if (error instanceof ScopedKnowledgeAuthorityError) {
       throw new CompanyBrainGovernedWriteAuthorityError(error.message);
     }

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

@@ -28,6 +28,7 @@ export class CompanyProfileAgentAdminError extends Error {
   constructor(
     readonly code:
       | "authority_unavailable"
+      | "policy_disabled"
       | "confirmation_unavailable"
       | "profile_conflict"
       | "operation_reused"
@@ -62,6 +63,13 @@ function translate(error: unknown, stage: "propose" | "confirm"): never {
       { cause: error },
     );
   }
+  if (state === "P1852") {
+    throw new CompanyProfileAgentAdminError(
+      "policy_disabled",
+      "Agent-authored company-profile changes are disabled by organization policy.",
+      { cause: error },
+    );
+  }
   if (state === "40001") {
     throw new CompanyProfileAgentAdminError(
       "profile_conflict",
@@ -86,6 +94,18 @@ function translate(error: unknown, stage: "propose" | "confirm"): never {
   throw error;
 }
 
+/** Deterministic UUID-shaped id for the activation stage of one proposal operation. */
+export function derivedCompanyProfileAutomaticActivationOperationId(operationId: string): string {
+  const bytes = createHash("sha256")
+    .update(`company-profile-agent-admin:v1:${operationId}:automatic-activation`, "utf8")
+    .digest()
+    .subarray(0, 16);
+  bytes[6] = (bytes[6]! & 0x0f) | 0x50;
+  bytes[8] = (bytes[8]! & 0x3f) | 0x80;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 async function withAgentAttemptContext<T>(
   db: Database,
   attempt: CompanyProfileAgentAttemptType,
@@ -119,10 +139,13 @@ export async function proposeCompanyProfileForAgent(
         receipt_id: string;
         revision_id: string;
         human_input: unknown;
+        policy_mode: "suggest" | "automatic";
+        automatic_activation_receipt_id: string | null;
+        activation_event_id: string | null;
         replayed: boolean;
       }>(
         scoped,
-        sql`select * from propose_company_profile_for_attempt(
+        sql`select * from propose_company_profile_for_attempt_v2(
           ${attempt.accountId}::uuid,
           ${attempt.workspaceId}::uuid,
           ${attempt.sessionId}::uuid,
@@ -130,6 +153,7 @@ export async function proposeCompanyProfileForAgent(
           ${attempt.attemptId}::uuid,
           ${attempt.executionGeneration},
           ${request.operationId}::uuid,
+          ${derivedCompanyProfileAutomaticActivationOperationId(request.operationId)}::uuid,
           ${contentJson},
           ${contentHash},
           ${request.reason}
@@ -138,6 +162,48 @@ export async function proposeCompanyProfileForAgent(
       if (!row) throw new Error("Company-profile proposal returned no receipt");
       return row;
     });
+    if (
+      result.policy_mode === "automatic" &&
+      result.automatic_activation_receipt_id &&
+      result.activation_event_id
+    ) {
+      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 automatic activation event is unavailable");
+      }
+      const revision = await getCompanyProfileRevision(db, {
+        accountId: attempt.accountId,
+        workspaceId: attempt.workspaceId,
+        revisionId: event.newRevision.id,
+      });
+      return CompanyProfileAgentProposalReceipt.parse({
+        status: "activated",
+        operationId: request.operationId,
+        proposalReceiptId: result.receipt_id,
+        automaticActivationReceiptId: result.automatic_activation_receipt_id,
+        policyMode: "automatic",
+        mutation: {
+          revision,
+          head: inventory.current?.revisionId === revision.id ? inventory.current : null,
+          event,
+        },
+        replayed: result.replayed,
+      });
+    }
+    if (result.policy_mode !== "suggest") {
+      throw new Error("Company-profile proposal returned an incomplete automatic activation");
+    }
     const revision = await getCompanyProfileRevision(db, {
       accountId: attempt.accountId,
       workspaceId: attempt.workspaceId,
@@ -148,6 +214,7 @@ export async function proposeCompanyProfileForAgent(
       operationId: request.operationId,
       proposalReceiptId: result.receipt_id,
       revision,
+      policyMode: "suggest",
       humanInput: CompanyProfileAgentHumanInputPrompt.parse(result.human_input),
       confirmWith: "company_profile_confirm",
       replayed: result.replayed,