@opengeni/db 5.0.1 → 6.0.0

package/dist/chunk-ZPJ6V2VG.js

@@ -0,0 +1,156 @@
+import {
+  external_exports
+} from "./chunk-4UJCXBR2.js";
+import {
+  rawRows,
+  rlsContextForWorkspace,
+  setSubjectRlsContext,
+  withRlsContext
+} from "./chunk-CJI6G254.js";
+
+// src/organization-integration-policy.ts
+import {
+  OrganizationIntegrationPolicy,
+  UpdateOrganizationIntegrationPolicyRequest,
+  assertOrganizationIntegrationAllowed
+} from "@opengeni/contracts";
+import { sql } from "drizzle-orm";
+var policyScope = external_exports.object({
+  accountId: external_exports.string().uuid().transform((value) => value.toLowerCase())
+});
+var acquisitionScope = policyScope.extend({
+  workspaceId: external_exports.string().uuid().transform((value) => value.toLowerCase())
+});
+async function requireReadCommitted(tx) {
+  const [isolation] = await rawRows(
+    tx,
+    sql`select current_setting('transaction_isolation') as level`
+  );
+  if (isolation?.level !== "read committed") {
+    throw new Error("Organization integration policy requires read committed isolation");
+  }
+}
+async function read(tx, scope) {
+  const [row] = await rawRows(
+    tx,
+    sql`select jsonb_build_object('mode', mode, 'allowedIntegrationKeys', allowed_integration_keys, 'revision', revision) as policy from organization_integration_policies where account_id = ${scope.accountId}::uuid`
+  );
+  return OrganizationIntegrationPolicy.parse(row?.policy ?? {});
+}
+async function withAdministratorSubject(tx, subjectId, use) {
+  const [previous] = await rawRows(
+    tx,
+    sql`select current_setting('opengeni.subject_id', true) as subject`
+  );
+  await setSubjectRlsContext(tx, subjectId);
+  const result = await use();
+  const expected = previous?.subject ?? "";
+  const [restored] = await rawRows(
+    tx,
+    sql`select set_config('opengeni.subject_id', ${expected}, true) as subject`
+  );
+  if (restored?.subject !== expected)
+    throw new Error("Integration policy subject scope was not restored");
+  return result;
+}
+async function getOrganizationIntegrationPolicy(db, inputScope, authorize) {
+  const scope = policyScope.parse(inputScope);
+  const actor = await authorize();
+  if (actor.accountId.toLowerCase() !== scope.accountId || !actor.subjectId)
+    throw new Error("Canonical organization administrator required");
+  return withRlsContext(
+    db,
+    { ...scope, workspaceId: null },
+    async (tx) => {
+      await requireReadCommitted(tx);
+      return withAdministratorSubject(tx, actor.subjectId, async () => {
+        await tx.execute(
+          sql`select opengeni_private.assert_organization_integration_policy_administrator(${scope.accountId}::uuid, ${actor.subjectId})`
+        );
+        return read(tx, scope);
+      });
+    },
+    void 0,
+    "none"
+  );
+}
+async function updateOrganizationIntegrationPolicy(db, inputScope, input, authorize) {
+  const scope = policyScope.parse(inputScope);
+  const request = UpdateOrganizationIntegrationPolicyRequest.parse(input);
+  const actor = await authorize();
+  if (actor.accountId.toLowerCase() !== scope.accountId || !actor.subjectId)
+    throw new Error("Canonical organization administrator required");
+  return withRlsContext(
+    db,
+    { ...scope, workspaceId: null },
+    async (tx) => {
+      await requireReadCommitted(tx);
+      return withAdministratorSubject(tx, actor.subjectId, async () => {
+        const [row] = await rawRows(
+          tx,
+          sql`select opengeni_private.update_organization_integration_policy(${scope.accountId}::uuid, ${actor.subjectId}, ${JSON.stringify(request)}::jsonb) as result`
+        );
+        return OrganizationIntegrationPolicy.parse(row?.result);
+      });
+    },
+    void 0,
+    "none"
+  );
+}
+async function withOrganizationIntegrationPolicyFence(db, inputScope, run) {
+  const requested = acquisitionScope.parse(inputScope);
+  const resolved = await rlsContextForWorkspace(db, requested.workspaceId);
+  if (resolved.accountId !== requested.accountId)
+    throw new Error("Organization integration policy workspace scope invalid");
+  const scope = { accountId: resolved.accountId, workspaceId: requested.workspaceId };
+  return withRlsContext(
+    db,
+    scope,
+    async (tx) => {
+      await requireReadCommitted(tx);
+      await tx.execute(
+        sql`select pg_advisory_xact_lock_shared(hashtextextended(${`organization-integration-policy:${scope.accountId}`}, 0))`
+      );
+      const [workspace] = await rawRows(
+        tx,
+        sql`select id from workspaces where id = ${scope.workspaceId}::uuid and account_id = ${scope.accountId}::uuid`
+      );
+      if (!workspace) throw new Error("Organization integration policy workspace scope invalid");
+      const policy = await read(tx, scope);
+      Object.freeze(policy.allowedIntegrationKeys);
+      Object.freeze(policy);
+      const result = await run(tx, policy);
+      const [finalWorkspace] = await rawRows(
+        tx,
+        sql`select id from workspaces where id = ${scope.workspaceId}::uuid and account_id = ${scope.accountId}::uuid for key share`
+      );
+      if (!finalWorkspace)
+        throw new Error("Organization integration policy workspace scope changed before commit");
+      return result;
+    },
+    void 0,
+    "none"
+  );
+}
+async function withOrganizationIntegrationAcquisition(db, inputScope, integrationKeys, acquire) {
+  const keys = [...integrationKeys];
+  if (!keys.length)
+    throw new Error("Acquisition requires at least one trusted integration classification");
+  return withOrganizationIntegrationPolicyFence(db, inputScope, async (tx, policy) => {
+    const assert = () => {
+      for (const key of keys) assertOrganizationIntegrationAllowed(policy, key);
+    };
+    assert();
+    const result = await acquire(tx);
+    assert();
+    return result;
+  });
+}
+
+export {
+  getOrganizationIntegrationPolicy,
+  updateOrganizationIntegrationPolicy,
+  withOrganizationIntegrationPolicyFence,
+  withOrganizationIntegrationAcquisition
+};
+//# sourceMappingURL=chunk-ZPJ6V2VG.js.map

package/dist/chunk-ZPJ6V2VG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/organization-integration-policy.ts"],"sourcesContent":["import {\n  OrganizationIntegrationPolicy,\n  UpdateOrganizationIntegrationPolicyRequest,\n  assertOrganizationIntegrationAllowed,\n} from \"@opengeni/contracts\";\nimport { sql } from \"drizzle-orm\";\nimport { z } from \"zod\";\nimport {\n  rawRows,\n  rlsContextForWorkspace,\n  setSubjectRlsContext,\n  withRlsContext,\n  type Database,\n} from \"./database\";\n\nexport type OrganizationIntegrationPolicyScope = { accountId: string };\nexport type OrganizationIntegrationAcquisitionScope = { accountId: string; workspaceId: string };\nconst policyScope = z.object({\n  accountId: z\n    .string()\n    .uuid()\n    .transform((value) => value.toLowerCase()),\n});\nconst acquisitionScope = policyScope.extend({\n  workspaceId: z\n    .string()\n    .uuid()\n    .transform((value) => value.toLowerCase()),\n});\n/** Trusted application adapter MUST verify canonical human/local organization-admin\n * provenance or accountScopedApiKeyWorkspaceAuthority (exact account + workspace:admin).\n * This callback is a server dependency, never deserialized request data. The returned\n * subject alone is NOT authentication. DB checks below are live authority fences only.\n */\nexport type AuthorizeOrganizationIntegrationPolicyAdministration = () => Promise<{\n  accountId: string;\n  subjectId: string;\n}>;\n\nasync function requireReadCommitted(tx: Database): Promise<void> {\n  const [isolation] = await rawRows<{ level: string }>(\n    tx,\n    sql`select current_setting('transaction_isolation') as level`,\n  );\n  if (isolation?.level !== \"read committed\") {\n    throw new Error(\"Organization integration policy requires read committed isolation\");\n  }\n}\n\nasync function read(\n  tx: Database,\n  scope: OrganizationIntegrationPolicyScope,\n): Promise<OrganizationIntegrationPolicy> {\n  const [row] = await rawRows<{ policy: unknown }>(\n    tx,\n    sql`select jsonb_build_object('mode', mode, 'allowedIntegrationKeys', allowed_integration_keys, 'revision', revision) as policy from organization_integration_policies where account_id = ${scope.accountId}::uuid`,\n  );\n  return OrganizationIntegrationPolicy.parse(row?.policy ?? {});\n}\n\n/** Own only the subject setting this policy operation changes. The enclosing\n * withRlsContext transaction/savepoint restores all settings on failure; on\n * success it restores account/workspace only, so restore our subject explicitly.\n * Do not run restoration after a failed SQL statement in an aborted transaction.\n */\nasync function withAdministratorSubject<T>(\n  tx: Database,\n  subjectId: string,\n  use: () => Promise<T>,\n): Promise<T> {\n  const [previous] = await rawRows<{ subject: string | null }>(\n    tx,\n    sql`select current_setting('opengeni.subject_id', true) as subject`,\n  );\n  await setSubjectRlsContext(tx, subjectId);\n  const result = await use();\n  const expected = previous?.subject ?? \"\";\n  const [restored] = await rawRows<{ subject: string }>(\n    tx,\n    sql`select set_config('opengeni.subject_id', ${expected}, true) as subject`,\n  );\n  if (restored?.subject !== expected)\n    throw new Error(\"Integration policy subject scope was not restored\");\n  return result;\n}\n\nexport async function getOrganizationIntegrationPolicy(\n  db: Database,\n  inputScope: OrganizationIntegrationPolicyScope,\n  authorize: AuthorizeOrganizationIntegrationPolicyAdministration,\n): Promise<OrganizationIntegrationPolicy> {\n  const scope = policyScope.parse(inputScope);\n  const actor = await authorize();\n  if (actor.accountId.toLowerCase() !== scope.accountId || !actor.subjectId)\n    throw new Error(\"Canonical organization administrator required\");\n  return withRlsContext(\n    db,\n    { ...scope, workspaceId: null },\n    async (tx) => {\n      await requireReadCommitted(tx);\n      return withAdministratorSubject(tx, actor.subjectId, async () => {\n        // Live authority only: no policy or organization advisory lock on reads.\n        await tx.execute(\n          sql`select opengeni_private.assert_organization_integration_policy_administrator(${scope.accountId}::uuid, ${actor.subjectId})`,\n        );\n        return read(tx, scope);\n      });\n    },\n    undefined,\n    \"none\",\n  );\n}\n\n/** Call before acquiring membership/workspace/credential locks in any enclosing\n * transaction. The SQL operation owns policy-exclusive -> membership -> admin\n * row order; it never locks a workspace and rejects acquisition-lock upgrades.\n */\nexport async function updateOrganizationIntegrationPolicy(\n  db: Database,\n  inputScope: OrganizationIntegrationPolicyScope,\n  input: UpdateOrganizationIntegrationPolicyRequest,\n  authorize: AuthorizeOrganizationIntegrationPolicyAdministration,\n): Promise<OrganizationIntegrationPolicy> {\n  const scope = policyScope.parse(inputScope);\n  const request = UpdateOrganizationIntegrationPolicyRequest.parse(input);\n  const actor = await authorize();\n  if (actor.accountId.toLowerCase() !== scope.accountId || !actor.subjectId)\n    throw new Error(\"Canonical organization administrator required\");\n  return withRlsContext(\n    db,\n    { ...scope, workspaceId: null },\n    async (tx) => {\n      await requireReadCommitted(tx);\n      return withAdministratorSubject(tx, actor.subjectId, async () => {\n        const [row] = await rawRows<{ result: unknown }>(\n          tx,\n          sql`select opengeni_private.update_organization_integration_policy(${scope.accountId}::uuid, ${actor.subjectId}, ${JSON.stringify(request)}::jsonb) as result`,\n        );\n        return OrganizationIntegrationPolicy.parse(row?.result);\n      });\n    },\n    undefined,\n    \"none\",\n  );\n}\n\n/** Internal serialization primitive, NOT acquisition authorization. Authenticate\n * the caller normally. A callback may first return an exact completed receipt;\n * before any new claim, uncommitted progress, or commit it MUST assert the trusted\n * integration classification against the supplied runtime-frozen policy snapshot.\n * Do not put network operations or retries inside this transaction.\n *\n * Requires read committed isolation. The shared policy fence precedes EVERY\n * organization-membership, workspace/tenancy, and credential lock. In particular,\n * persistProviderOAuthConnection may take the membership fence inside acquire.\n * Policy writers take exclusive policy -> membership -> live administrator rows,\n * and never workspace rows. Ordinary connection lifecycle writers do not take\n * the policy fence. A caller passing an existing transaction must honor this\n * prefix. Never administer policy inside or after an acquisition in that transaction:\n * the SQL writer rejects shared-to-exclusive upgrades rather than risking deadlock.\n * All final persistence must use tx, never a separate connection. No automatic\n * retries: external effects cannot be rolled back. For slow external preparation,\n * preflight separately and use this guard for final persistence. Existing execution,\n * refresh, credential lifecycle, and cleanup do not belong behind this guard.\n */\nexport async function withOrganizationIntegrationPolicyFence<T>(\n  db: Database,\n  inputScope: OrganizationIntegrationAcquisitionScope,\n  run: (tx: Database, policy: OrganizationIntegrationPolicy) => Promise<T>,\n): Promise<T> {\n  const requested = acquisitionScope.parse(inputScope);\n  // Non-locking authoritative resolution before any new lock; repeat under the\n  // policy fence below so a moved/deleted workspace cannot retain stale scope.\n  const resolved = await rlsContextForWorkspace(db, requested.workspaceId);\n  if (resolved.accountId !== requested.accountId)\n    throw new Error(\"Organization integration policy workspace scope invalid\");\n  const scope = { accountId: resolved.accountId, workspaceId: requested.workspaceId };\n  return withRlsContext(\n    db,\n    scope,\n    async (tx) => {\n      await requireReadCommitted(tx);\n      await tx.execute(\n        sql`select pg_advisory_xact_lock_shared(hashtextextended(${`organization-integration-policy:${scope.accountId}`}, 0))`,\n      );\n      // No row lock here: the existing writer owns its canonical membership ->\n      // workspace prefix. All policy checks and callback writes share this tx.\n      const [workspace] = await rawRows(\n        tx,\n        sql`select id from workspaces where id = ${scope.workspaceId}::uuid and account_id = ${scope.accountId}::uuid`,\n      );\n      if (!workspace) throw new Error(\"Organization integration policy workspace scope invalid\");\n      const policy = await read(tx, scope);\n      Object.freeze(policy.allowedIntegrationKeys);\n      Object.freeze(policy);\n      const result = await run(tx, policy);\n      const [finalWorkspace] = await rawRows(\n        tx,\n        sql`select id from workspaces where id = ${scope.workspaceId}::uuid and account_id = ${scope.accountId}::uuid for key share`,\n      );\n      if (!finalWorkspace)\n        throw new Error(\"Organization integration policy workspace scope changed before commit\");\n      return result;\n    },\n    undefined,\n    \"none\",\n  );\n}\n\n/** New acquisitions always assert before effects and before returning to commit.\n * The immutable snapshot stays authoritative through commit: the shared fence\n * excludes policy writers and the SQL writer rejects same-transaction upgrades.\n * Receipt-aware callers instead use withOrganizationIntegrationPolicyFence and\n * assert only after distinguishing completed replay from new workflow progress.\n */\nexport async function withOrganizationIntegrationAcquisition<T>(\n  db: Database,\n  inputScope: OrganizationIntegrationAcquisitionScope,\n  integrationKeys: readonly (string | null)[],\n  acquire: (tx: Database) => Promise<T>,\n): Promise<T> {\n  // Snapshot classifications before the first await, including workspace lookup.\n  const keys = [...integrationKeys];\n  if (!keys.length)\n    throw new Error(\"Acquisition requires at least one trusted integration classification\");\n  return withOrganizationIntegrationPolicyFence(db, inputScope, async (tx, policy) => {\n    const assert = () => {\n      for (const key of keys) assertOrganizationIntegrationAllowed(policy, key);\n    };\n    assert();\n    const result = await acquire(tx);\n    assert();\n    return result;\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/codex-capacity-recovery.d.ts

@@ -0,0 +1,12 @@
+/** Durable logical-turn state; checks and quota/account signals never spend this budget. */
+export declare const CODEX_CAPACITY_RECOVERY_KEY = "codexCapacityRecoveryV1";
+export declare const CODEX_CAPACITY_FALSE_RESUMPTION_LIMIT = 10;
+export type CodexCapacityRecovery = {
+    falseResumptions: number;
+    resumeGeneration: number | null;
+    retryNotBefore: string | null;
+};
+export declare function readCodexCapacityRecovery(metadata: Record<string, unknown> | null | undefined): CodexCapacityRecovery;
+/** Equal jitter, 30–60 seconds initially, capped at 15 minutes. Persist the chosen deadline. */
+export declare function codexFalseResumptionBackoffMs(count: number, random?: number): number;
+export declare function clearCodexCapacityRecovery(metadata: Record<string, unknown>): Record<string, unknown>;

package/dist/codex-failure-eligibility.d.ts

@@ -0,0 +1,9 @@
+/** Refusal-specific, ordered recovery evidence; never erase the failure ledger. */
+export declare function unresolvedCodexCredentialFailures(metadata: Record<string, unknown> | null | undefined, accounts: readonly {
+    id: string;
+    status: string;
+    exhaustedUntil: Date | null;
+    exhaustedKind: string | null;
+    exhaustedRevision?: number;
+    credentialVersion?: number;
+}[], now?: Date): string[];

package/dist/company-profile-schema.d.ts

@@ -1362,12 +1362,13 @@ export declare const companyProfileAgentProposalReceipts: import("drizzle-orm/pg
                     label?: string | null | undefined;
                     helpText?: string | null | undefined;
                     skillReview?: {
+                        removalOperationId?: string | undefined;
                         sourceOperationId: string;
                         skillId: string;
                         revisionId: string;
                         expectedRevisionId: string | null;
                         expectedScopeVersion: number;
-                    } | undefined;
+                    } | null | undefined;
                     options: {
                         id: string;
                         label: string;
@@ -1401,12 +1402,13 @@ export declare const companyProfileAgentProposalReceipts: import("drizzle-orm/pg
                     label?: string | null | undefined;
                     helpText?: string | null | undefined;
                     skillReview?: {
+                        removalOperationId?: string | undefined;
                         sourceOperationId: string;
                         skillId: string;
                         revisionId: string;
                         expectedRevisionId: string | null;
                         expectedScopeVersion: number;
-                    } | undefined;
+                    } | null | undefined;
                     options: {
                         id: string;
                         label: string;

package/dist/connect-attempts.d.ts

@@ -20,12 +20,22 @@ export declare class ConnectAttemptNotFoundError extends Error {
 }
 /** Caller must establish live workspace/actor authority before this storage
  * seam. RLS scope is a consistency boundary, not proof of authentication. */
+type ConnectBeginIdentity = {
+    idempotencyKey: string;
+    requestDigest: string;
+    returnUrl: string;
+    externalContinuation?: ExternalActorContinuation;
+};
+/** Recover only an exact saved begin request, under the caller's live actor
+ * admission. This performs no provider work or acquisition. */
+export declare function getConnectBeginReplay(db: Database, scope: ConnectActorScope, input: ConnectBeginIdentity): Promise<Attempt | null>;
 export declare function beginConnectAttempt(db: Database, scope: ConnectActorScope, input: {
     idempotencyKey: string;
     requestDigest: string;
     returnUrl: string;
     attempt: Attempt;
     externalContinuation?: ExternalActorContinuation;
+    authorizeAcquisition?: (tx: Database) => Promise<void>;
 }): Promise<Attempt>;
 export declare function getConnectAttempt(db: Database, scope: ConnectActorScope, id: string): Promise<{
     attempt: Attempt;
@@ -41,6 +51,8 @@ export declare function claimConnectOperation(db: Database, scope: ConnectActorS
     operationId: string;
     inputDigest: string;
     authorize?: ConnectOperationAuthorization;
+    /** Additional acquisition admission, only after exact no-effect receipt replay. */
+    authorizeAcquisition?: (tx: Database, attempt: Attempt) => Promise<void>;
 }): Promise<{
     status: "claimed";
     attempt: Attempt;
@@ -57,4 +69,7 @@ export declare function finishConnectOperation(db: Database, scope: ConnectActor
     inputDigest: string;
     commit: (tx: Database, current: Attempt) => Promise<Attempt>;
     authorize?: ConnectOperationAuthorization;
+    /** Additional acquisition admission, only after exact no-effect receipt replay. */
+    authorizeAcquisition?: (tx: Database, attempt: Attempt) => Promise<void>;
 }): Promise<Attempt>;
+export {};

package/dist/connect-attempts.js

@@ -0,0 +1,25 @@
+import {
+  ConnectAttemptConflictError,
+  ConnectAttemptNotFoundError,
+  beginConnectAttempt,
+  claimConnectOperation,
+  finishConnectOperation,
+  getConnectAttempt,
+  getConnectBeginReplay,
+  listPendingConnectAttempts
+} from "./chunk-AJA2ZIUW.js";
+import "./chunk-CJI6G254.js";
+import "./chunk-MN5PZMEK.js";
+import "./chunk-S2TZ3F4L.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ConnectAttemptConflictError,
+  ConnectAttemptNotFoundError,
+  beginConnectAttempt,
+  claimConnectOperation,
+  finishConnectOperation,
+  getConnectAttempt,
+  getConnectBeginReplay,
+  listPendingConnectAttempts
+};
+//# sourceMappingURL=connect-attempts.js.map

package/dist/connect-attempts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/connection-authority.d.ts

@@ -1,71 +1,15 @@
-import { ConnectionAuthoritySummary, ConnectionUseAttribution, ConnectionUseAuthorizationResult, type IssueConnectionUseGrantRequest, type ConnectionUseDenialReason as ConnectionUseDenialReasonValue } from "@opengeni/contracts/connection-authority";
-import { type ConnectionKind as ConnectionKindValue, type UserResourceDelegation } from "@opengeni/contracts";
+import { ConnectionUseAttribution, type ConnectionUseDenialReason as ConnectionUseDenialReasonValue } from "@opengeni/contracts/connection-authority";
+import { type ConnectionKind as ConnectionKindValue } from "@opengeni/contracts";
 import { type Database } from "./database.js";
-export declare function listSelfConnectionAuthorities(db: Database, input: {
+/** Called only after the core layer has established the authenticated sender. */
+export declare function listOwnedConnectionAccounts(db: Database, input: {
     accountId: string;
     workspaceId: string;
     subjectId: string;
-}): Promise<ConnectionAuthoritySummary[]>;
-export declare function issueSelfConnectionUseGrant(db: Database, input: {
-    accountId: string;
-    workspaceId: string;
-    subjectId: string;
-    authorityId: string;
-    request: IssueConnectionUseGrantRequest;
-}): Promise<{
-    grantId: string;
-    targetWorkspaceId: string;
-    targetSessionId: string | null;
-    mode: "always" | "once" | "session";
-    context: "user_private" | "workspace_shared";
-    authorityEpoch: number | null;
-    generation: number;
-    status: "active" | "consumed" | "expired" | "revoked";
-    expiresAt: string | null;
-    delegation: {
-        authorityId: string;
-        grantId: string;
-        organizationId: string;
-        workspaceId: string;
-        sessionId: string | null;
-        action: string;
-        mode: "always" | "once" | "session";
-        context: "user_private" | "workspace_shared";
-        authorityEpoch: number | null;
-        authorityGeneration: number;
-        grantGeneration: number;
-        resourceVersionId?: string | null | undefined;
-    };
-    action: "connection.use";
-}>;
-export declare function revokeSelfConnectionUseGrant(db: Database, input: {
-    accountId: string;
-    workspaceId: string;
-    subjectId: string;
-    grantId: string;
-}): Promise<{
-    grantId: string;
-    generation: number;
-    status: "revoked";
-    revokedAt: string;
-}>;
-/**
- * Resolves the immutable physical origin for one explicit common-user
- * connection selection. The SECURITY DEFINER database boundary proves the
- * owning human, active organization membership, target-workspace access, and
- * exact authority/grant generations without exposing credentials or allowing
- * an ambient cross-workspace inventory.
- */
-export declare function resolvePersonalConnectionAuthoritySelectionOrigin(db: Database, input: {
-    accountId: string;
-    targetWorkspaceId: string;
-    subjectId: string;
+}): Promise<Array<{
     connectionId: string;
-    delegation: UserResourceDelegation;
-}): Promise<string | null>;
-export declare function resolveConnectionUseAuthority(db: Database, input: {
-    snapshot: unknown;
-}): Promise<ConnectionUseAuthorizationResult>;
+    originWorkspaceId: string;
+}>>;
 export type AcceptedConnectionUseContext = {
     accountId: string;
     workspaceId: string;

package/dist/connection-refresh-lock.d.ts

@@ -0,0 +1,4 @@
+import { type Database } from "./database.js";
+import type { ConnectionCredentialForBroker } from "./connection-token-resolver.js";
+/** Serialize rotating-token exchange across workers, not only within one process. */
+export declare function withConnectionRefreshLock<T>(db: Database, credential: ConnectionCredentialForBroker, work: (lockedDb: Database) => Promise<T>): Promise<T>;

package/dist/connection-token-resolver.d.ts

@@ -1,10 +1,11 @@
 import { environmentsEncryptionKeyBytes, type McpServerConnectionRef, type Settings } from "@opengeni/config";
-import type { ConnectionCredentialPlacement, ConnectionKind, ConnectionCredentialsPort, ConnectionStatus, McpConnectionResourceScope, McpCredentialAuthNeededReason, McpCredentialsRequest, McpGatewayCredentialsRequest, TurnInitiator, TurnInitiatorContext } from "@opengeni/contracts";
-import { type ConnectionUseAttribution, type ConnectionUseAuthorizationResult } from "@opengeni/contracts/connection-authority";
+import type { ConnectionCredentialPlacement, ConnectionKind, ConnectionStatus, McpConnectionResourceScope, McpCredentialAuthNeededReason } from "@opengeni/contracts";
+import { type ConnectionUseAttribution } from "@opengeni/contracts/connection-authority";
 import { type DnsLookup, type FetchLike } from "@opengeni/network";
 export { isPrivateAddress } from "@opengeni/network";
 import { encryptEnvironmentValue } from "./environment-crypto.js";
 import type { Database } from "./database.js";
+import { withConnectionRefreshLock } from "./connection-refresh-lock.js";
 import type { AcceptedConnectionUseContext, AcceptedConnectionUseResolution } from "./connection-authority.js";
 export type ConnectionCredentialForBroker = {
     id: string;
@@ -99,59 +100,23 @@ export type ResolveConnectionCredentialInput = {
     credentialResolutionMode?: "execution" | "preflight";
     /** Frozen provider authority generation captured by the calling integration/catalog. */
     expectedAuthorityGeneration?: number;
-    /** Exact immutable accepted-work authority; never credential-bearing. */
-    connectionUseAuthority?: unknown;
+    /** Attribution already authorized for forwarding to a host resolver; never authorizes local use. */
+    hostConnectionUseAttribution?: ConnectionUseAttribution;
     /** Exact accepted attempt plus one stable physical-provider request id. */
     connectionUseContext?: AcceptedConnectionUseContext;
 };
-export type HostMcpCredentialResolverContext = {
-    accountId: string;
-    workspaceId: string;
-    sessionId: string;
-    rootSessionId: string;
-    turnId: string;
-    attemptId: string | null;
-    executionGeneration: number;
-    initiator: TurnInitiator;
-    initiatorContext: TurnInitiatorContext;
-    surface: McpCredentialsRequest["surface"];
-    /** Backend-owned attempt liveness, independent of binding delegation. */
-    authorizeExecution?: (request: McpCredentialsRequest) => Promise<boolean>;
-    /** Backend-owned live validator. Never populate from caller JSON or a host
-     * credential response. Omission denies every explicit durable reference. */
-    authorizeDurableBinding?: (request: McpCredentialsRequest) => Promise<boolean>;
-    /** Backend-only accepted-work lookup, not a host response or registry fallback. */
-    resolveAcceptedBinding?: (request: McpCredentialsRequest) => Promise<McpServerConnectionRef | null>;
-};
-export declare class HostMcpCredentialScopeError extends Error {
-    constructor(field: "accountId" | "workspaceId" | "sessionId");
-}
-export declare class HostMcpCredentialBindingError extends Error {
-    constructor(field: "provider" | "providerDomain" | "connectionId" | "scopes" | "resource" | "selectedResources" | "destinationUrl" | "credentialPlacements");
-}
-/**
- * Adapts the public embedding credential port to the runtime's connection
- * resolver contract. Scope echoes are checked before credential headers can
- * reach a request; the returned object is a fresh copy so a host cannot mutate
- * headers after resolution.
- */
-export declare function buildHostConnectionTokenResolver(resolve: NonNullable<ConnectionCredentialsPort["mcpCredentials"]>, suppliedContext: HostMcpCredentialResolverContext): (input: ResolveConnectionCredentialInput) => Promise<ResolveConnectionCredentialResult>;
-/** Authenticated request-time adapter. No synthetic session/turn authority and
- * no durable binding admission; every physical use must retain live API proof. */
-export declare function buildHostGatewayConnectionTokenResolver(resolve: NonNullable<ConnectionCredentialsPort["mcpGatewayCredentials"]>, suppliedContext: Pick<McpGatewayCredentialsRequest, "accountId" | "workspaceId" | "authority">, reauthorize: () => Promise<void>): (input: ResolveConnectionCredentialInput) => Promise<ResolveConnectionCredentialResult>;
-export declare function normalizedHostCredentialHeaders(headers: Record<string, string>, allowEmpty?: boolean): Record<string, string>;
+export declare function normalizedCredentialHeaders(headers: Record<string, string>, allowEmpty?: boolean): Record<string, string>;
 export type ConnectionBrokerDeps = {
     loadCredential: (db: Database, settings: Settings, input: ConnectionCredentialLookupInput) => Promise<ConnectionCredentialForBroker | null>;
     recordRefresh: (db: Database, input: ConnectionTokenRefreshInput) => Promise<boolean>;
     setStatus: (db: Database, workspaceId: string, status: ConnectionStatus, lastError: string | null, guard: ConnectionStatusGuard) => Promise<boolean>;
     recordUsed: (db: Database, workspaceId: string, connectionId: string, subjectId?: string | null) => Promise<void>;
     refresh: typeof refreshOAuthConnectionCredential;
+    /** Test/adapter seam; standalone defaults to the database-backed refresh lock. */
+    withRefreshLock?: typeof withConnectionRefreshLock;
     encrypt: typeof encryptEnvironmentValue;
     keyBytes: typeof environmentsEncryptionKeyBytes;
     now: () => Date;
-    authorizeUse?: (db: Database, input: {
-        snapshot: unknown;
-    }) => Promise<ConnectionUseAuthorizationResult>;
     authorizeAcceptedUse?: (db: Database, input: AcceptedConnectionUseContext & {
         serverId: string;
         connectionId?: string;

package/dist/database-timing.d.ts

@@ -0,0 +1,10 @@
+export type DatabaseTimingStage = "transaction_admission" | "savepoint_admission" | "rls_setup" | "scoped_callback";
+export type DatabaseTimingObservation = {
+    stage: DatabaseTimingStage;
+    outcome: "completed" | "failed";
+    durationMs: number;
+};
+export type DatabaseTimingObserver = (observation: DatabaseTimingObservation) => void;
+/** Opt-in, async-local diagnostics only; no identity or query payload is retained. */
+export declare function withDatabaseTimingObserver<T>(observer: DatabaseTimingObserver, work: () => Promise<T>): Promise<T>;
+export declare function startDatabaseTiming(stage: DatabaseTimingStage): (outcome: DatabaseTimingObservation["outcome"]) => void;

package/dist/database.d.ts

@@ -1,3 +1,4 @@
+import type { SessionAttachmentReadAccess } from "./session-file-attachments.js";
 import { type SQL } from "drizzle-orm";
 import type { PgDatabase, PgTransactionConfig } from "drizzle-orm/pg-core";
 import postgres from "postgres";
@@ -22,11 +23,14 @@ export type RlsContext = {
     workspaceId?: string | null;
 };
 export type SessionRlsActorContext = {
+    /** Server-authorized session attachment scope; never taken from request JSON. */
+    sessionAttachmentReadAccess?: SessionAttachmentReadAccess;
     subjectId: string;
     /** Host-verified personal file ownership, never a request-supplied subject. */
     privateFileOwnerSubjectId?: string | null;
     initiatingHumanSubjectId?: string | null;
 };
+export declare function currentSessionAttachmentReadAccess(): SessionAttachmentReadAccess | undefined;
 export declare function withSessionRlsActorContext<T>(actor: SessionRlsActorContext, fn: () => Promise<T>): Promise<T>;
 /**
  * RLS posture for the connection OpenGeni's query layer runs over (Step I, §7.7).

package/dist/editable-artifact-durable-export.js

@@ -1,8 +1,8 @@
 import {
   rawRows,
   withRlsContext
-} from "./chunk-DPONPYJD.js";
-import "./chunk-F73UKJY6.js";
+} from "./chunk-CJI6G254.js";
+import "./chunk-MN5PZMEK.js";
 import "./chunk-S2TZ3F4L.js";
 import "./chunk-PZ5AY32C.js";
 

package/dist/editable-artifacts.d.ts

@@ -607,4 +607,13 @@ export declare class PostgresEditableArtifactLiveReadStore {
     }): Promise<void>;
     private readVerifiedSnapshotBytes;
 }
+export declare function transactionallyAuthorizeEditableArtifactActor(tx: Database, input: Readonly<{
+    scope: PersistedEditableArtifactScope;
+    artifactId: string;
+    actor: PersistedEditableArtifactActor;
+    permission: "create" | "import" | "read" | "edit" | "manage";
+}>): Promise<Readonly<{
+    allowed: boolean;
+    revision: number;
+}>>;
 export {};

package/dist/editable-artifacts.js

@@ -7,10 +7,11 @@ import {
   PostgresEditableArtifactLiveTicketStore,
   PostgresEditableArtifactStore,
   listEditableArtifactIdsForSession,
-  touchEditableArtifactSessionLink
-} from "./chunk-HQDVI2DB.js";
-import "./chunk-DPONPYJD.js";
-import "./chunk-F73UKJY6.js";
+  touchEditableArtifactSessionLink,
+  transactionallyAuthorizeEditableArtifactActor
+} from "./chunk-SYKHLPTK.js";
+import "./chunk-CJI6G254.js";
+import "./chunk-MN5PZMEK.js";
 import "./chunk-S2TZ3F4L.js";
 import "./chunk-PZ5AY32C.js";
 export {
@@ -22,6 +23,7 @@ export {
   PostgresEditableArtifactLiveTicketStore,
   PostgresEditableArtifactStore,
   listEditableArtifactIdsForSession,
-  touchEditableArtifactSessionLink
+  touchEditableArtifactSessionLink,
+  transactionallyAuthorizeEditableArtifactActor
 };
 //# sourceMappingURL=editable-artifacts.js.map