@opengeni/core 4.0.1 → 4.0.3-canary.36079201993001

package/dist/index.js

@@ -1378,8 +1378,257 @@ async function knowledgeContextForAccess(deps, access, permission) {
 
 // src/domain/knowledge-search.ts
 import { KnowledgeEntryListRequest } from "@opengeni/contracts";
-import { listKnowledgeEntries } from "@opengeni/db";
-async function searchKnowledgeEntries(db, context, input, embedder) {
+import {
+  applyCreditDebitAfterUse,
+  getBillingBalance as getBillingBalance2,
+  listKnowledgeEntries,
+  recordUsageEvent as recordUsageEvent2,
+  sumUsageQuantity as sumUsageQuantity2,
+  withKnowledgeQueryAccountLock
+} from "@opengeni/db";
+
+// src/billing/limits.ts
+import {
+  configuredStaticUsageLimits,
+  resolveModelProviderForTurn
+} from "@opengeni/config";
+import {
+  countActiveApiKeysForWorkspace,
+  countActiveOrganizationApiKeysForAccount,
+  countScheduledTasksForWorkspace,
+  countWorkspacesForAccount,
+  getBillingBalance,
+  isCodexBilledTurn,
+  recordUsageEvent,
+  sumUsageQuantity
+} from "@opengeni/db";
+import { HTTPException as HTTPException4 } from "hono/http-exception";
+function paidDocumentEmbedding(settings) {
+  return settings.documentEmbeddingBillingMode === "credits" && settings.documentEmbeddingProvider === "openai";
+}
+function documentEmbeddingCostMicros(settings, inputBytes) {
+  if (!Number.isSafeInteger(inputBytes) || inputBytes < 0)
+    throw new Error("invalid embedding bytes");
+  const amount = (BigInt(inputBytes) * BigInt(settings.documentEmbeddingRateMicrosPerMillionBytes) + 999999n) / 1000000n;
+  if (amount > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new Error("embedding cost exceeds safe integer");
+  return Number(amount);
+}
+function modelFundingForAdmission(settings, model, codexBilled) {
+  const resolvedModel = model ? resolveModelProviderForTurn(settings, model)?.model : null;
+  const codexSubscriptionModel = resolvedModel?.credentialSource.kind === "connected_subscription" && resolvedModel.credentialSource.provider === "codex";
+  return {
+    // A Codex namespace/definition never bypasses credits by itself: the live
+    // workspace credential predicate above remains authoritative. SuperGrok's
+    // static overlay is likewise secret-free; its worker/provider admission
+    // owns live account selection before any upstream request can occur.
+    fundedWithoutCredits: codexBilled || resolvedModel != null && !codexSubscriptionModel && resolvedModel.cost !== "credits",
+    countsTowardTokenCap: !codexBilled && resolvedModel != null && resolvedModel.billing.upstreamPayer === "deployment"
+  };
+}
+async function requireLimit(deps, input) {
+  const decision = await checkLimit(deps, input);
+  if (decision.allowed) {
+    return;
+  }
+  throw new HTTPException4(decision.code === "insufficient_credits" ? 402 : 429, {
+    message: decision.message
+  });
+}
+async function checkLimit(deps, input) {
+  const codexBilled = input.workspaceId ? await isCodexBilledTurn({
+    db: deps.db,
+    settings: deps.settings,
+    workspaceId: input.workspaceId,
+    model: input.model
+  }) : false;
+  const { fundedWithoutCredits, countsTowardTokenCap } = modelFundingForAdmission(
+    deps.settings,
+    input.model,
+    codexBilled
+  );
+  const creditDecision = await checkCreditBalance(deps, input, fundedWithoutCredits);
+  if (!creditDecision.allowed) {
+    return creditDecision;
+  }
+  if (deps.settings.usageLimitsMode !== "static" && deps.settings.usageLimitsMode !== "managed") {
+    return { allowed: true };
+  }
+  return await checkStaticCaps(deps, input, {
+    fundedWithoutCredits,
+    countsTowardTokenCap
+  });
+}
+async function checkCreditBalance(deps, input, externallyBilled) {
+  if (externallyBilled) {
+    return { allowed: true };
+  }
+  if (!usesCreditLimits(deps) || !isCostlyAction(input.action)) {
+    return { allowed: true };
+  }
+  const balance = await getBillingBalance(deps.db, input.accountId);
+  if (balance.balanceMicros > 0) {
+    return { allowed: true };
+  }
+  return { allowed: false, code: "insufficient_credits", message: "insufficient OpenGeni credits" };
+}
+async function checkStaticCaps(deps, input, funding) {
+  const limits = configuredStaticUsageLimits(deps.settings);
+  if (limits.maxMonthlyCostMicrosPerAccount && isCostlyAction(input.action) && !funding.fundedWithoutCredits) {
+    const used = await sumUsageQuantity(deps.db, {
+      accountId: input.accountId,
+      eventType: "model.cost",
+      since: startOfUtcMonth()
+    });
+    if (used >= limits.maxMonthlyCostMicrosPerAccount) {
+      return blocked(
+        "max_monthly_cost_micros_per_account",
+        `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`
+      );
+    }
+  }
+  switch (input.action) {
+    case "workspace:create": {
+      if (!limits.maxWorkspacesPerAccount) {
+        return { allowed: true };
+      }
+      const count = await countWorkspacesForAccount(deps.db, input.accountId);
+      return count < limits.maxWorkspacesPerAccount ? { allowed: true } : blocked(
+        "max_workspaces_per_account",
+        `workspace limit reached (${limits.maxWorkspacesPerAccount})`
+      );
+    }
+    case "api_key:create": {
+      if (!limits.maxApiKeysPerWorkspace) {
+        return { allowed: true };
+      }
+      const count = input.workspaceId ? await countActiveApiKeysForWorkspace(deps.db, input.workspaceId) : await countActiveOrganizationApiKeysForAccount(deps.db, input.accountId);
+      return count < limits.maxApiKeysPerWorkspace ? { allowed: true } : blocked(
+        "max_api_keys_per_workspace",
+        `API key limit reached (${limits.maxApiKeysPerWorkspace})`
+      );
+    }
+    case "schedule:create": {
+      if (!limits.maxSchedulesPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const count = await countScheduledTasksForWorkspace(deps.db, input.workspaceId);
+      return count < limits.maxSchedulesPerWorkspace ? { allowed: true } : blocked(
+        "max_schedules_per_workspace",
+        `scheduled task limit reached (${limits.maxSchedulesPerWorkspace})`
+      );
+    }
+    case "file:upload": {
+      if (!limits.maxFileUploadBytes || !input.quantity) {
+        return { allowed: true };
+      }
+      return input.quantity <= limits.maxFileUploadBytes ? { allowed: true } : blocked(
+        "max_file_upload_bytes",
+        `file upload exceeds static limit of ${limits.maxFileUploadBytes} bytes`
+      );
+    }
+    case "agent_run:create": {
+      if (!limits.maxMonthlyAgentRunsPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const used = await sumUsageQuantity(deps.db, {
+        workspaceId: input.workspaceId,
+        eventType: "agent_run.created",
+        since: startOfUtcMonth()
+      });
+      const requested = input.quantity ?? 0;
+      return used + requested <= limits.maxMonthlyAgentRunsPerWorkspace ? { allowed: true } : blocked(
+        "max_monthly_agent_runs_per_workspace",
+        `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`
+      );
+    }
+    case "tokens:consume": {
+      if (!funding.countsTowardTokenCap || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const used = await sumUsageQuantity(deps.db, {
+        workspaceId: input.workspaceId,
+        eventType: "model.tokens",
+        since: startOfUtcMonth()
+      });
+      const requested = input.quantity ?? 0;
+      return used + requested <= limits.maxMonthlyTokensPerWorkspace ? { allowed: true } : blocked(
+        "max_monthly_tokens_per_workspace",
+        `monthly token limit reached (${limits.maxMonthlyTokensPerWorkspace})`
+      );
+    }
+    case "document:index": {
+      if (!limits.maxDocumentIndexedChunksPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const used = await sumUsageQuantity(deps.db, {
+        workspaceId: input.workspaceId,
+        eventType: "document.indexed",
+        since: startOfUtcMonth()
+      });
+      const requested = input.quantity ?? 0;
+      return used + requested <= limits.maxDocumentIndexedChunksPerWorkspace ? { allowed: true } : blocked(
+        "max_document_indexed_chunks_per_workspace",
+        `monthly document indexing limit reached (${limits.maxDocumentIndexedChunksPerWorkspace} chunks)`
+      );
+    }
+  }
+}
+async function recordWorkspaceUsage(deps, input) {
+  await recordUsageEvent(deps.db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    subjectId: input.subjectId ?? null,
+    eventType: input.eventType,
+    quantity: input.quantity,
+    unit: input.unit,
+    sourceResourceType: input.sourceResourceType,
+    sourceResourceId: input.sourceResourceId,
+    sessionId: input.sessionId ?? null,
+    turnId: input.turnId ?? null,
+    turnAttemptId: input.turnAttemptId ?? null,
+    initiator: input.initiator ?? (input.subjectId ? { kind: "subject", subjectId: input.subjectId } : null),
+    ...input.initiatorContext ? { initiatorContext: input.initiatorContext } : {},
+    origin: input.origin ?? null,
+    idempotencyKey: input.idempotencyKey
+  });
+}
+function usesCreditLimits(deps) {
+  return deps.settings.billingMode === "stripe" || deps.settings.usageLimitsMode === "managed";
+}
+function isCostlyAction(action) {
+  return action === "agent_run:create" || action === "tokens:consume";
+}
+function blocked(code, message) {
+  return { allowed: false, code, message };
+}
+function startOfUtcMonth() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+}
+
+// src/domain/knowledge-search.ts
+var MAX_PAID_QUERY_BYTES = 4096;
+var MAX_PAID_QUERY_MICROS = 1e3;
+var MAX_PAID_QUERY_BYTES_PER_MINUTE = 64 * 1024;
+var MAX_PAID_QUERY_BYTES_PER_MONTH = 8 * 1024 * 1024;
+var MAX_PAID_QUERY_MICROS_PER_MINUTE = 1e4;
+var MAX_PAID_QUERY_MICROS_PER_MONTH = 1e6;
+var KnowledgeVectorFundingError = class extends Error {
+  code = "knowledge_vector_funding_required";
+  constructor() {
+    super("Knowledge vector search needs OpenGeni credits; keyword search remains available.");
+    this.name = "KnowledgeVectorFundingError";
+  }
+};
+var KnowledgeVectorQueryRejectedError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "KnowledgeVectorQueryRejectedError";
+  }
+};
+async function searchKnowledgeEntries(db, context, input, embedder, settings) {
   const request = KnowledgeEntryListRequest.parse(input);
   if (!request.query || request.mode === "keyword") {
     return {
@@ -1390,25 +1639,119 @@ async function searchKnowledgeEntries(db, context, input, embedder) {
   const lexicalQuery = /^[\p{L}\p{N}\s]+$/u.test(request.query) && !/\bOR\b/i.test(request.query) ? [...new Set(request.query.trim().split(/\s+/u))].map((term) => `"${term}"`).join(" OR ") : request.query;
   const lexicalRequest = KnowledgeEntryListRequest.safeParse({ ...request, query: lexicalQuery });
   const retrievalRequest = request.mode === "hybrid" && lexicalRequest.success ? lexicalRequest.data : request;
-  let embedding;
-  try {
-    const provider = embedder();
-    const values = await provider.embedQuery(request.query);
-    if (values.length !== provider.dimensions || values.some((value) => !Number.isFinite(value)) || !values.some((value) => value !== 0)) {
-      throw new Error("Knowledge query embedding is unavailable");
-    }
-    embedding = { model: provider.model, values };
-  } catch (error) {
+  const keywordFallback = async (queryDb, error, fallbackReason) => {
     if (request.mode === "vector") throw error;
     return {
-      ...await listKnowledgeEntries(db, context, { ...retrievalRequest, mode: "keyword" }),
-      searchMode: "keyword"
+      ...await listKnowledgeEntries(queryDb, context, { ...retrievalRequest, mode: "keyword" }),
+      searchMode: "keyword",
+      fallbackReason
     };
-  }
-  return {
-    ...await listKnowledgeEntries(db, context, retrievalRequest, embedding),
-    searchMode: request.mode
   };
+  const bytes = Buffer.byteLength(request.query, "utf8");
+  const paidSettings = settings && paidDocumentEmbedding(settings) ? settings : void 0;
+  if (paidSettings && request.cursor)
+    throw new KnowledgeVectorQueryRejectedError(
+      "pagination_unavailable",
+      "Paid semantic Knowledge pagination is unavailable; use keyword mode"
+    );
+  const cost = paidSettings ? documentEmbeddingCostMicros(paidSettings, bytes) : 0;
+  if (paidSettings && (bytes > MAX_PAID_QUERY_BYTES || cost > MAX_PAID_QUERY_MICROS))
+    return keywordFallback(
+      db,
+      new KnowledgeVectorQueryRejectedError(
+        "query_limit",
+        "Paid Knowledge query exceeds the per-request limit"
+      ),
+      "query_limit"
+    );
+  const retrieveThenSettle = async (queryDb) => {
+    let embedding;
+    try {
+      const provider = embedder();
+      const values = await provider.embedQuery(request.query);
+      if (values.length !== provider.dimensions || values.some((value) => !Number.isFinite(value)) || !values.some((value) => value !== 0))
+        throw new Error("Knowledge query embedding is unavailable");
+      embedding = { model: provider.model, values };
+    } catch (error) {
+      return keywordFallback(queryDb, error, "provider_unavailable");
+    }
+    const found = await listKnowledgeEntries(queryDb, context, retrievalRequest, embedding);
+    if (settings) {
+      const usageId = crypto.randomUUID();
+      await recordUsageEvent2(queryDb, {
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        eventType: "document.query_embedding_bytes",
+        quantity: bytes,
+        unit: "byte",
+        sourceResourceType: "knowledge_query",
+        sourceResourceId: usageId,
+        idempotencyKey: `knowledge.query_bytes:${usageId}`
+      });
+      if (paidSettings && cost > 0)
+        await recordUsageEvent2(queryDb, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          eventType: "document.query_embedding_cost",
+          quantity: cost,
+          unit: "micro_usd",
+          sourceResourceType: "knowledge_query",
+          sourceResourceId: usageId,
+          idempotencyKey: `knowledge.query_cost:${usageId}`
+        });
+      if (paidSettings && cost > 0)
+        await applyCreditDebitAfterUse(queryDb, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          type: "document_embedding_debit",
+          amountMicros: cost,
+          sourceType: "knowledge_query",
+          sourceId: usageId,
+          idempotencyKey: `knowledge.query_embedding:${usageId}`,
+          metadata: { model: embedding.model, bytes }
+        });
+    }
+    return { ...found, searchMode: request.mode };
+  };
+  if (!paidSettings) return retrieveThenSettle(db);
+  return withKnowledgeQueryAccountLock(
+    db,
+    context.accountId,
+    context.workspaceId,
+    async (lockedDb) => {
+      const balance = await getBillingBalance2(lockedDb, context.accountId);
+      if (balance.balanceMicros <= 0)
+        return keywordFallback(lockedDb, new KnowledgeVectorFundingError(), "awaiting_funding");
+      const now = /* @__PURE__ */ new Date();
+      const minuteBytes = await sumUsageQuantity2(lockedDb, {
+        accountId: context.accountId,
+        eventType: "document.query_embedding_bytes",
+        since: new Date(now.getTime() - 6e4)
+      });
+      const monthBytes = await sumUsageQuantity2(lockedDb, {
+        accountId: context.accountId,
+        eventType: "document.query_embedding_bytes",
+        since: new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))
+      });
+      const minuteMicros = await sumUsageQuantity2(lockedDb, {
+        accountId: context.accountId,
+        eventType: "document.query_embedding_cost",
+        since: new Date(now.getTime() - 6e4)
+      });
+      const monthMicros = await sumUsageQuantity2(lockedDb, {
+        accountId: context.accountId,
+        eventType: "document.query_embedding_cost",
+        since: new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))
+      });
+      if (minuteBytes + bytes > MAX_PAID_QUERY_BYTES_PER_MINUTE || monthBytes + bytes > MAX_PAID_QUERY_BYTES_PER_MONTH || minuteMicros + cost > MAX_PAID_QUERY_MICROS_PER_MINUTE || monthMicros + cost > MAX_PAID_QUERY_MICROS_PER_MONTH)
+        return keywordFallback(
+          lockedDb,
+          new KnowledgeVectorQueryRejectedError("quota", "Paid Knowledge query rate limit reached"),
+          "quota"
+        );
+      return retrieveThenSettle(lockedDb);
+    }
+  );
 }
 
 // src/workflow-wake-contract.ts
@@ -3272,7 +3615,7 @@ async function provisionSandbox(services, ctx, input) {
 }
 
 // src/application/external-workspace-members.ts
-import { HTTPException as HTTPException4 } from "hono/http-exception";
+import { HTTPException as HTTPException5 } from "hono/http-exception";
 import {
   AddExternalWorkspaceMemberRequest,
   ExternalIdentityReference,
@@ -3308,12 +3651,12 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
   const context = await requireAccessContext(c, deps);
   const authority = accountScopedApiKeyWorkspaceAuthority(context);
   if (!authority)
-    throw new HTTPException4(403, {
+    throw new HTTPException5(403, {
       message: "external onboarding requires an organization service key"
     });
   const grant = await requireFreshAccessGrant(c, deps, workspaceId, "members:manage");
   if (grant.accountId !== authority.accountId || payload.permissions.some((permission) => !hasPermission(grant.permissions, permission))) {
-    throw new HTTPException4(403, { message: "membership exceeds key authority" });
+    throw new HTTPException5(403, { message: "membership exceeds key authority" });
   }
   if (payload.operationId) {
     try {
@@ -3339,11 +3682,11 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
       "members:manage"
     );
     if (live.accountId !== grant.accountId || live.subjectId !== grant.subjectId || payload.permissions.some((permission) => !hasPermission(live.permissions, permission))) {
-      throw new HTTPException4(403, { message: "membership authority changed" });
+      throw new HTTPException5(403, { message: "membership authority changed" });
     }
     const workspace = await requireWorkspace2(tx, workspaceId);
     if (workspace.kind !== "shared" || workspace.accountId !== authority.accountId)
-      throw new HTTPException4(403, {
+      throw new HTTPException5(403, {
         message: "external onboarding requires a shared organization workspace"
       });
     const identity = await ensureExternalIdentity2(tx, {
@@ -3357,7 +3700,7 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
     const permissions = [...new Set(payload.permissions)];
     if (existing) {
       if (existing.permissions.length !== permissions.length || existing.permissions.some((permission) => !permissions.includes(permission))) {
-        throw new HTTPException4(409, {
+        throw new HTTPException5(409, {
           message: "existing membership differs; onboarding does not overwrite permissions"
         });
       }
@@ -3376,7 +3719,7 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
 function rethrowExternalWorkspaceOperation(error) {
   const status = organizationMembershipHttpStatus(nestedPostgresSqlState2(error));
   if (status)
-    throw new HTTPException4(status, {
+    throw new HTTPException5(status, {
       message: status === 409 ? "External membership operation changed or was cancelled" : "External membership operation is not available"
     });
   throw error;
@@ -3385,7 +3728,7 @@ async function externalService(c, deps, organizationId) {
   const context = await requireAccessContext(c, deps);
   const authority = accountScopedApiKeyWorkspaceAuthority(context);
   if (!authority || authority.accountId !== organizationId || !hasPermission(authority.permissions, "members:manage")) {
-    throw new HTTPException4(403, {
+    throw new HTTPException5(403, {
       message: "External membership operation requires an organization service key"
     });
   }
@@ -3395,7 +3738,7 @@ async function lookupExternalIdentityForRequest(c, deps, organizationId, input)
   const service = await externalService(c, deps, organizationId);
   const identity = ExternalIdentityReference.safeParse(input);
   if (!identity.success)
-    throw new HTTPException4(422, { message: "Invalid external identity reference" });
+    throw new HTTPException5(422, { message: "Invalid external identity reference" });
   try {
     return await lookupExternalIdentity(deps.db, service, identity.data);
   } catch (error) {
@@ -3406,7 +3749,7 @@ async function cancelExternalWorkspaceMemberGrantForRequest(c, deps, organizatio
   const service = await externalService(c, deps, organizationId);
   const request = CancelExternalWorkspaceMemberGrantRequest.safeParse(input);
   if (!request.success)
-    throw new HTTPException4(422, { message: "Invalid external grant cancellation" });
+    throw new HTTPException5(422, { message: "Invalid external grant cancellation" });
   try {
     return await cancelExternalWorkspaceMemberGrant(
       deps.db,
@@ -3419,7 +3762,7 @@ async function cancelExternalWorkspaceMemberGrantForRequest(c, deps, organizatio
 }
 
 // src/application/external-identity-lifecycle.ts
-import { HTTPException as HTTPException5 } from "hono/http-exception";
+import { HTTPException as HTTPException6 } from "hono/http-exception";
 import { UpdateExternalIdentityMembershipRequest } from "@opengeni/contracts/external-identities";
 import { updateOrganizationMember } from "@opengeni/db";
 async function updateExternalIdentityMembershipForRequest(context, deps, organizationId, membershipId, input) {
@@ -3429,13 +3772,13 @@ async function updateExternalIdentityMembershipForRequest(context, deps, organiz
     (grant) => grant.accountId === organizationId && grant.subjectId === access.subjectId
   );
   if (!service || service.accountId !== organizationId || !account?.permissions.includes("account:admin")) {
-    throw new HTTPException5(403, {
+    throw new HTTPException6(403, {
       message: "external identity administration requires an organization service key"
     });
   }
   const parsed = UpdateExternalIdentityMembershipRequest.safeParse(input);
   if (!parsed.success)
-    throw new HTTPException5(422, { message: "invalid external identity transition" });
+    throw new HTTPException6(422, { message: "invalid external identity transition" });
   return updateOrganizationMember(deps.db, {
     organizationId,
     membershipId,
@@ -3457,7 +3800,7 @@ import {
   nestedPostgresSqlState as nestedPostgresSqlState3,
   withWorkspaceSubjectRls as withWorkspaceSubjectRls3
 } from "@opengeni/db";
-import { HTTPException as HTTPException6 } from "hono/http-exception";
+import { HTTPException as HTTPException7 } from "hono/http-exception";
 function externalContinuationCommitAuthorizer(authorization) {
   const continuation = authorization ? externalActorContinuationForAuthorization(authorization) : null;
   if (!continuation || !authorization) return void 0;
@@ -3472,7 +3815,7 @@ function externalContinuationCommitAuthorizer(authorization) {
       await requireExternalContinuationAuthority(tx, continuation, scope, permissions);
     } catch (error) {
       const denied2 = nestedPostgresSqlState3(error) === "42501" || error instanceof Error && error.message === "External continuation authority unavailable";
-      throw new HTTPException6(denied2 ? 403 : 503, {
+      throw new HTTPException7(denied2 ? 403 : 503, {
         message: denied2 ? "external authority changed" : "external authority is unavailable",
         cause: error
       });
@@ -3537,12 +3880,12 @@ import {
   variableSetVariableNameReservation
 } from "@opengeni/contracts";
 import { getVariableSet, recordAuditEvent } from "@opengeni/db";
-import { HTTPException as HTTPException7 } from "hono/http-exception";
+import { HTTPException as HTTPException8 } from "hono/http-exception";
 var MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
 var MAX_VARIABLES_PER_ENVIRONMENT = 100;
 function assertAllowedVariableSetVariableName(name) {
   if (variableSetVariableNameReservation(name)) {
-    throw new HTTPException7(422, {
+    throw new HTTPException8(422, {
       message: `reserved variable set variable name / reserved environment variable name: ${name}`
     });
   }
@@ -3551,7 +3894,7 @@ var assertAllowedEnvironmentVariableName = assertAllowedVariableSetVariableName;
 function requireVariableSetEncryption(settings) {
   const key = environmentsEncryptionKeyBytes(settings);
   if (!key) {
-    throw new HTTPException7(503, {
+    throw new HTTPException8(503, {
       message: "variable sets require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
     });
   }
@@ -3569,7 +3912,7 @@ async function requireVariableSetForApi(db, grant, variableSetId) {
     variableSetId
   );
   if (!variableSet) {
-    throw new HTTPException7(404, { message: "variableSet not found" });
+    throw new HTTPException8(404, { message: "variableSet not found" });
   }
   return variableSet;
 }
@@ -3583,7 +3926,7 @@ async function validateVariableSetAttachment(deps, grant, workspaceId, variableS
     variableSetId
   );
   if (!variableSet) {
-    throw new HTTPException7(422, { message: "unknown variableSetId" });
+    throw new HTTPException8(422, { message: "unknown variableSetId" });
   }
   return variableSet;
 }
@@ -3643,416 +3986,207 @@ async function fileOwnerContextForAgent(deps, grant, permission) {
       sessionId,
       turnId: attempt.turnId,
       attemptId: attempt.attemptId,
-      executionGeneration: attempt.executionGeneration
-    }
-  });
-  const sessionAuthority = await getSessionAuthorityProjection3(
-    deps.db,
-    grant.workspaceId,
-    sessionId
-  );
-  if (!sessionAuthority) throw new Error("File session authority unavailable");
-  return {
-    sessionAttachmentReadAccess: {
-      sessionId,
-      authorityEpoch: sessionAuthority.authorityEpoch,
-      actor: attempt
-    },
-    subjectId: grant.subjectId,
-    initiatingHumanSubjectId: attempt.initiatingHumanSubjectId,
-    privateFileOwnerSubjectId: snapshot.defaultScope === "personal" ? snapshot.subjectId : null
-  };
-}
-
-// src/domain/sessions.ts
-import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
-
-// src/site-session-origin.ts
-import { AsyncLocalStorage } from "async_hooks";
-var origins = new AsyncLocalStorage();
-function withSiteSessionOrigin(origin, run) {
-  return origins.run(origin, run);
-}
-function sessionCreationMetadata(metadata) {
-  const { _opengeniSiteOrigin: _ignored, ...rest } = metadata;
-  const origin = origins.getStore();
-  return origin ? { ...rest, _opengeniSiteOrigin: origin } : rest;
-}
-
-// src/domain/sessions.ts
-import {
-  canonicalizeConfiguredModelId,
-  configuredAllowedModels,
-  withCodexCatalogProvider as withCodexCatalogProvider2,
-  ORGANIZATION_GATEWAY_MODEL_ID_PREFIX as ORGANIZATION_GATEWAY_MODEL_ID_PREFIX2,
-  ORGANIZATION_OPENROUTER_MODEL_ID_PREFIX as ORGANIZATION_OPENROUTER_MODEL_ID_PREFIX2,
-  resolveFirstPartyMcpToolPolicy,
-  policyProviderIdForModel,
-  resolveTurnExecutionPolicyV1,
-  WORKSPACE_GATEWAY_MODEL_ID_PREFIX as WORKSPACE_GATEWAY_MODEL_ID_PREFIX2,
-  WORKSPACE_OPENROUTER_MODEL_ID_PREFIX as WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2,
-  XAI_SUBSCRIPTION_MODEL_ID_PREFIX
-} from "@opengeni/config";
-import {
-  AUTOMATIC_SESSION_TITLE_FALLBACK,
-  CreateSessionRequest,
-  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
-  DEFAULT_FIRST_PARTY_MCP_TOOLS,
-  currentAgentLearningToolSelection,
-  DraftTimelineAnnotations as DraftTimelineAnnotations2,
-  FIRST_PARTY_MCP_TOOL_NAMES as FIRST_PARTY_MCP_TOOL_NAMES2,
-  OPENGENI_SLACK_BOT_SESSION_METADATA_KEY as OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2,
-  SessionSkills,
-  resolveBundledSkillSelection,
-  SessionSpawnDenial,
-  ServiceTurnInitiator,
-  ServiceTurnInitiatorContext,
-  evaluateWorkspaceModelPolicy as evaluateWorkspaceModelPolicy2,
-  normalizeAutomaticSessionTitle,
-  resolveWorkspaceSessionToolDefaults as resolveWorkspaceSessionToolDefaults2,
-  metadataWithTurnExecutionPolicyV1,
-  readTurnExecutionPolicyV1,
-  stableJson as stableJson3,
-  SessionMcpApprovalPolicy
-} from "@opengeni/contracts";
-import {
-  assertExactNewSessionDraftInTransaction,
-  createSession,
-  createSessionWithIdempotencyKeyResult,
-  canonicalSessionCommandHash,
-  encryptVariableSetValue as encryptVariableSetValue2,
-  getAnySessionInGroup,
-  getEnrollment as getEnrollment2,
-  getChannel,
-  getRig as getRig2,
-  getWorkspaceDefaultRigId,
-  listDistinctVariableSetSelectionsInGroup,
-  listDistinctRigVersionIdsInGroup,
-  listInstalledPortableSkills,
-  listEnabledMcpCapabilityServers as listEnabledMcpCapabilityServers2,
-  requireApprovalWithFloor,
-  getSandbox as getSandbox3,
-  getSession as getSession2,
-  getInitializedSessionCreateReplay,
-  getSessionAuthorityProjection as getSessionAuthorityProjection4,
-  SessionIdConflictError,
-  NewSessionDraftConflictError,
-  getWorkspaceControlEvent,
-  getSessionLineage,
-  getSessionTurn,
-  getSessionTurnForAttempt as getSessionTurnForAttempt3,
-  getSessionTurnPersonalConnectionDelegations as getSessionTurnPersonalConnectionDelegations2,
-  getSessionTurnXaiProviderAccountAuthoritySnapshot,
-  getWorkspaceModelPolicy,
-  requireWorkspace as requireWorkspace4,
-  initializeSessionStartAtomically,
-  listSessionTurns,
-  listSessionMcpServersForChildInheritance,
-  requireSession as requireSession2,
-  setActiveSandbox as setActiveSandbox2,
-  setSubjectRlsContext,
-  replaySubmittedHumanPromptFromBoundaryReceipt,
-  submitHumanPromptInTransaction,
-  appendSessionEventsWithLockedSessionUpdate,
-  updateSessionTitleWithEvent,
-  withWorkspaceSubjectSessionActivityRls,
-  QueueCommandConflictError,
-  AgentCommandAuthorityError,
-  runIdempotentPersistenceTransaction,
-  SessionSpawnDeniedDbError,
-  SessionControlConflictError,
-  SessionToolPolicyVersionConflictError,
-  SessionCreateIdempotencyConflictError,
-  PersonalResourceAttachmentAcceptanceError,
-  sessionTenancyProductActivated as sessionTenancyProductActivated2,
-  workspaceControlRequestLockTimeoutMs,
-  WorkspaceControlBusyError
-} from "@opengeni/db";
-import {
-  publishDurableSessionEvents as publishDurableSessionEvents2,
-  publishDurableWorkspaceControlEvent
-} from "@opengeni/events";
-import { HTTPException as HTTPException15 } from "hono/http-exception";
-
-// src/domain/external-creation-attribution.ts
-import { HTTPException as HTTPException8 } from "hono/http-exception";
-var EXTERNAL_CREATION_ATTRIBUTION_KEY = "opengeniExternalCreationAttribution";
-function externalCreationMetadata(metadata, authorization, grant) {
-  if (metadata && Object.hasOwn(metadata, EXTERNAL_CREATION_ATTRIBUTION_KEY)) {
-    throw new HTTPException8(422, {
-      message: `${EXTERNAL_CREATION_ATTRIBUTION_KEY} is server-owned`
-    });
-  }
-  const attribution = externalAttributionForAuthorization(authorization, grant);
-  if (!attribution) return metadata;
-  return { ...metadata, [EXTERNAL_CREATION_ATTRIBUTION_KEY]: attribution };
-}
-
-// src/application/external-link-work-admission.ts
-import { ExternalLinkWorkSnapshot } from "@opengeni/contracts/external-identities";
-import {
-  captureExternalLinkTurnAuthority,
-  captureExternalLinkTaskAuthority,
-  getExternalLinkTurnSnapshot,
-  getSessionTurnForAttempt as getSessionTurnForAttempt2
-} from "@opengeni/db";
-function snapshotFor(authorization) {
-  const continuation = authorization ? externalActorContinuationForAuthorization(authorization) : null;
-  return continuation?.actor.actingMode === "linked_native" ? ExternalLinkWorkSnapshot.parse({
-    ...continuation,
-    permissions: [...authorization.grant.permissions]
-  }) : null;
-}
-function prepareExternalLinkTurnAdmission(authorization) {
-  const snapshot = snapshotFor(authorization);
-  if (!snapshot || !authorization) return void 0;
-  const workspaceId = authorization.grant.workspaceId;
-  const accountId = authorization.grant.accountId;
-  const commit = externalContinuationCommitAuthorizer(authorization);
-  return async (tx, sessionId, turnId) => {
-    await commit(tx);
-    await captureExternalLinkTurnAuthority(tx, {
-      accountId,
-      workspaceId,
-      sessionId,
-      turnId,
-      snapshot
-    });
-  };
-}
-function prepareExternalLinkTaskAdmission(authorization, actor) {
-  const snapshot = snapshotFor(authorization);
-  const commit = externalContinuationCommitAuthorizer(authorization);
-  if (snapshot)
-    return async (tx, task) => {
-      await commit?.(tx);
-      await captureExternalLinkTaskAuthority(tx, task, snapshot);
-    };
-  if (!actor) {
-    return authorization && hasVerifiedOwningUserAuthorization(authorization) ? async () => {
-    } : void 0;
-  }
-  return async (tx, task) => {
-    const turn = await getSessionTurnForAttempt2(
-      tx,
-      task.workspaceId,
-      actor.sessionId,
-      actor.attemptId
-    );
-    if (!turn || turn.id !== actor.turnId || turn.executionGeneration !== actor.executionGeneration)
-      throw new Error("Linked task creator attempt is no longer active");
-    const inherited = await getExternalLinkTurnSnapshot(tx, task, actor.turnId);
-    if (inherited) await captureExternalLinkTaskAuthority(tx, task, inherited);
-  };
-}
-
-// src/billing/limits.ts
-import {
-  configuredStaticUsageLimits,
-  resolveModelProviderForTurn
-} from "@opengeni/config";
-import {
-  countActiveApiKeysForWorkspace,
-  countActiveOrganizationApiKeysForAccount,
-  countScheduledTasksForWorkspace,
-  countWorkspacesForAccount,
-  getBillingBalance,
-  isCodexBilledTurn,
-  recordUsageEvent,
-  sumUsageQuantity
-} from "@opengeni/db";
-import { HTTPException as HTTPException9 } from "hono/http-exception";
-function modelFundingForAdmission(settings, model, codexBilled) {
-  const resolvedModel = model ? resolveModelProviderForTurn(settings, model)?.model : null;
-  const codexSubscriptionModel = resolvedModel?.credentialSource.kind === "connected_subscription" && resolvedModel.credentialSource.provider === "codex";
-  return {
-    // A Codex namespace/definition never bypasses credits by itself: the live
-    // workspace credential predicate above remains authoritative. SuperGrok's
-    // static overlay is likewise secret-free; its worker/provider admission
-    // owns live account selection before any upstream request can occur.
-    fundedWithoutCredits: codexBilled || resolvedModel != null && !codexSubscriptionModel && resolvedModel.cost !== "credits",
-    countsTowardTokenCap: !codexBilled && resolvedModel != null && resolvedModel.billing.upstreamPayer === "deployment"
-  };
-}
-async function requireLimit(deps, input) {
-  const decision = await checkLimit(deps, input);
-  if (decision.allowed) {
-    return;
-  }
-  throw new HTTPException9(decision.code === "insufficient_credits" ? 402 : 429, {
-    message: decision.message
-  });
-}
-async function checkLimit(deps, input) {
-  const codexBilled = input.workspaceId ? await isCodexBilledTurn({
-    db: deps.db,
-    settings: deps.settings,
-    workspaceId: input.workspaceId,
-    model: input.model
-  }) : false;
-  const { fundedWithoutCredits, countsTowardTokenCap } = modelFundingForAdmission(
-    deps.settings,
-    input.model,
-    codexBilled
-  );
-  const creditDecision = await checkCreditBalance(deps, input, fundedWithoutCredits);
-  if (!creditDecision.allowed) {
-    return creditDecision;
-  }
-  if (deps.settings.usageLimitsMode !== "static" && deps.settings.usageLimitsMode !== "managed") {
-    return { allowed: true };
-  }
-  return await checkStaticCaps(deps, input, {
-    fundedWithoutCredits,
-    countsTowardTokenCap
-  });
-}
-async function checkCreditBalance(deps, input, externallyBilled) {
-  if (externallyBilled) {
-    return { allowed: true };
-  }
-  if (!usesCreditLimits(deps) || !isCostlyAction(input.action)) {
-    return { allowed: true };
-  }
-  const balance = await getBillingBalance(deps.db, input.accountId);
-  if (balance.balanceMicros > 0) {
-    return { allowed: true };
-  }
-  return { allowed: false, code: "insufficient_credits", message: "insufficient OpenGeni credits" };
-}
-async function checkStaticCaps(deps, input, funding) {
-  const limits = configuredStaticUsageLimits(deps.settings);
-  if (limits.maxMonthlyCostMicrosPerAccount && isCostlyAction(input.action) && !funding.fundedWithoutCredits) {
-    const used = await sumUsageQuantity(deps.db, {
-      accountId: input.accountId,
-      eventType: "model.cost",
-      since: startOfUtcMonth()
-    });
-    if (used >= limits.maxMonthlyCostMicrosPerAccount) {
-      return blocked(
-        "max_monthly_cost_micros_per_account",
-        `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`
-      );
-    }
-  }
-  switch (input.action) {
-    case "workspace:create": {
-      if (!limits.maxWorkspacesPerAccount) {
-        return { allowed: true };
-      }
-      const count = await countWorkspacesForAccount(deps.db, input.accountId);
-      return count < limits.maxWorkspacesPerAccount ? { allowed: true } : blocked(
-        "max_workspaces_per_account",
-        `workspace limit reached (${limits.maxWorkspacesPerAccount})`
-      );
-    }
-    case "api_key:create": {
-      if (!limits.maxApiKeysPerWorkspace) {
-        return { allowed: true };
-      }
-      const count = input.workspaceId ? await countActiveApiKeysForWorkspace(deps.db, input.workspaceId) : await countActiveOrganizationApiKeysForAccount(deps.db, input.accountId);
-      return count < limits.maxApiKeysPerWorkspace ? { allowed: true } : blocked(
-        "max_api_keys_per_workspace",
-        `API key limit reached (${limits.maxApiKeysPerWorkspace})`
-      );
-    }
-    case "schedule:create": {
-      if (!limits.maxSchedulesPerWorkspace || !input.workspaceId) {
-        return { allowed: true };
-      }
-      const count = await countScheduledTasksForWorkspace(deps.db, input.workspaceId);
-      return count < limits.maxSchedulesPerWorkspace ? { allowed: true } : blocked(
-        "max_schedules_per_workspace",
-        `scheduled task limit reached (${limits.maxSchedulesPerWorkspace})`
-      );
-    }
-    case "file:upload": {
-      if (!limits.maxFileUploadBytes || !input.quantity) {
-        return { allowed: true };
-      }
-      return input.quantity <= limits.maxFileUploadBytes ? { allowed: true } : blocked(
-        "max_file_upload_bytes",
-        `file upload exceeds static limit of ${limits.maxFileUploadBytes} bytes`
-      );
-    }
-    case "agent_run:create": {
-      if (!limits.maxMonthlyAgentRunsPerWorkspace || !input.workspaceId) {
-        return { allowed: true };
-      }
-      const used = await sumUsageQuantity(deps.db, {
-        workspaceId: input.workspaceId,
-        eventType: "agent_run.created",
-        since: startOfUtcMonth()
-      });
-      const requested = input.quantity ?? 0;
-      return used + requested <= limits.maxMonthlyAgentRunsPerWorkspace ? { allowed: true } : blocked(
-        "max_monthly_agent_runs_per_workspace",
-        `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`
-      );
-    }
-    case "tokens:consume": {
-      if (!funding.countsTowardTokenCap || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
-        return { allowed: true };
-      }
-      const used = await sumUsageQuantity(deps.db, {
-        workspaceId: input.workspaceId,
-        eventType: "model.tokens",
-        since: startOfUtcMonth()
-      });
-      const requested = input.quantity ?? 0;
-      return used + requested <= limits.maxMonthlyTokensPerWorkspace ? { allowed: true } : blocked(
-        "max_monthly_tokens_per_workspace",
-        `monthly token limit reached (${limits.maxMonthlyTokensPerWorkspace})`
-      );
-    }
-    case "document:index": {
-      if (!limits.maxDocumentIndexedChunksPerWorkspace || !input.workspaceId) {
-        return { allowed: true };
-      }
-      const used = await sumUsageQuantity(deps.db, {
-        workspaceId: input.workspaceId,
-        eventType: "document.indexed",
-        since: startOfUtcMonth()
-      });
-      const requested = input.quantity ?? 0;
-      return used + requested <= limits.maxDocumentIndexedChunksPerWorkspace ? { allowed: true } : blocked(
-        "max_document_indexed_chunks_per_workspace",
-        `monthly document indexing limit reached (${limits.maxDocumentIndexedChunksPerWorkspace} chunks)`
-      );
-    }
-  }
-}
-async function recordWorkspaceUsage(deps, input) {
-  await recordUsageEvent(deps.db, {
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    subjectId: input.subjectId ?? null,
-    eventType: input.eventType,
-    quantity: input.quantity,
-    unit: input.unit,
-    sourceResourceType: input.sourceResourceType,
-    sourceResourceId: input.sourceResourceId,
-    sessionId: input.sessionId ?? null,
-    turnId: input.turnId ?? null,
-    turnAttemptId: input.turnAttemptId ?? null,
-    initiator: input.initiator ?? (input.subjectId ? { kind: "subject", subjectId: input.subjectId } : null),
-    ...input.initiatorContext ? { initiatorContext: input.initiatorContext } : {},
-    origin: input.origin ?? null,
-    idempotencyKey: input.idempotencyKey
+      executionGeneration: attempt.executionGeneration
+    }
   });
+  const sessionAuthority = await getSessionAuthorityProjection3(
+    deps.db,
+    grant.workspaceId,
+    sessionId
+  );
+  if (!sessionAuthority) throw new Error("File session authority unavailable");
+  return {
+    sessionAttachmentReadAccess: {
+      sessionId,
+      authorityEpoch: sessionAuthority.authorityEpoch,
+      actor: attempt
+    },
+    subjectId: grant.subjectId,
+    initiatingHumanSubjectId: attempt.initiatingHumanSubjectId,
+    privateFileOwnerSubjectId: snapshot.defaultScope === "personal" ? snapshot.subjectId : null
+  };
 }
-function usesCreditLimits(deps) {
-  return deps.settings.billingMode === "stripe" || deps.settings.usageLimitsMode === "managed";
+
+// src/domain/sessions.ts
+import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
+
+// src/site-session-origin.ts
+import { AsyncLocalStorage } from "async_hooks";
+var origins = new AsyncLocalStorage();
+function withSiteSessionOrigin(origin, run) {
+  return origins.run(origin, run);
 }
-function isCostlyAction(action) {
-  return action === "agent_run:create" || action === "tokens:consume" || action === "document:index";
+function sessionCreationMetadata(metadata) {
+  const { _opengeniSiteOrigin: _ignored, ...rest } = metadata;
+  const origin = origins.getStore();
+  return origin ? { ...rest, _opengeniSiteOrigin: origin } : rest;
 }
-function blocked(code, message) {
-  return { allowed: false, code, message };
+
+// src/domain/sessions.ts
+import {
+  canonicalizeConfiguredModelId,
+  configuredAllowedModels,
+  withCodexCatalogProvider as withCodexCatalogProvider2,
+  ORGANIZATION_GATEWAY_MODEL_ID_PREFIX as ORGANIZATION_GATEWAY_MODEL_ID_PREFIX2,
+  ORGANIZATION_OPENROUTER_MODEL_ID_PREFIX as ORGANIZATION_OPENROUTER_MODEL_ID_PREFIX2,
+  resolveFirstPartyMcpToolPolicy,
+  policyProviderIdForModel,
+  resolveTurnExecutionPolicyV1,
+  WORKSPACE_GATEWAY_MODEL_ID_PREFIX as WORKSPACE_GATEWAY_MODEL_ID_PREFIX2,
+  WORKSPACE_OPENROUTER_MODEL_ID_PREFIX as WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2,
+  XAI_SUBSCRIPTION_MODEL_ID_PREFIX
+} from "@opengeni/config";
+import {
+  AUTOMATIC_SESSION_TITLE_FALLBACK,
+  CreateSessionRequest,
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
+  DEFAULT_FIRST_PARTY_MCP_TOOLS,
+  currentAgentLearningToolSelection,
+  DraftTimelineAnnotations as DraftTimelineAnnotations2,
+  FIRST_PARTY_MCP_TOOL_NAMES as FIRST_PARTY_MCP_TOOL_NAMES2,
+  OPENGENI_SLACK_BOT_SESSION_METADATA_KEY as OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2,
+  SessionSkills,
+  resolveBundledSkillSelection,
+  SessionSpawnDenial,
+  ServiceTurnInitiator,
+  ServiceTurnInitiatorContext,
+  evaluateWorkspaceModelPolicy as evaluateWorkspaceModelPolicy2,
+  normalizeAutomaticSessionTitle,
+  resolveWorkspaceSessionToolDefaults as resolveWorkspaceSessionToolDefaults2,
+  metadataWithTurnExecutionPolicyV1,
+  readTurnExecutionPolicyV1,
+  stableJson as stableJson3,
+  SessionMcpApprovalPolicy
+} from "@opengeni/contracts";
+import {
+  assertExactNewSessionDraftInTransaction,
+  createSession,
+  createSessionWithIdempotencyKeyResult,
+  canonicalSessionCommandHash,
+  encryptVariableSetValue as encryptVariableSetValue2,
+  getAnySessionInGroup,
+  getEnrollment as getEnrollment2,
+  getChannel,
+  getRig as getRig2,
+  getWorkspaceDefaultRigId,
+  listDistinctVariableSetSelectionsInGroup,
+  listDistinctRigVersionIdsInGroup,
+  listInstalledPortableSkills,
+  listEnabledMcpCapabilityServers as listEnabledMcpCapabilityServers2,
+  requireApprovalWithFloor,
+  getSandbox as getSandbox3,
+  getSession as getSession2,
+  getInitializedSessionCreateReplay,
+  getSessionAuthorityProjection as getSessionAuthorityProjection4,
+  SessionIdConflictError,
+  NewSessionDraftConflictError,
+  getWorkspaceControlEvent,
+  getSessionLineage,
+  getSessionTurn,
+  getSessionTurnForAttempt as getSessionTurnForAttempt3,
+  getSessionTurnPersonalConnectionDelegations as getSessionTurnPersonalConnectionDelegations2,
+  getSessionTurnXaiProviderAccountAuthoritySnapshot,
+  getWorkspaceModelPolicy,
+  requireWorkspace as requireWorkspace4,
+  initializeSessionStartAtomically,
+  listSessionTurns,
+  listSessionMcpServersForChildInheritance,
+  requireSession as requireSession2,
+  setActiveSandbox as setActiveSandbox2,
+  setSubjectRlsContext,
+  replaySubmittedHumanPromptFromBoundaryReceipt,
+  submitHumanPromptInTransaction,
+  appendSessionEventsWithLockedSessionUpdate,
+  updateSessionTitleWithEvent,
+  withWorkspaceSubjectSessionActivityRls,
+  QueueCommandConflictError,
+  AgentCommandAuthorityError,
+  runIdempotentPersistenceTransaction,
+  SessionSpawnDeniedDbError,
+  SessionControlConflictError,
+  SessionToolPolicyVersionConflictError,
+  SessionCreateIdempotencyConflictError,
+  PersonalResourceAttachmentAcceptanceError,
+  sessionTenancyProductActivated as sessionTenancyProductActivated2,
+  workspaceControlRequestLockTimeoutMs,
+  WorkspaceControlBusyError
+} from "@opengeni/db";
+import {
+  publishDurableSessionEvents as publishDurableSessionEvents2,
+  publishDurableWorkspaceControlEvent
+} from "@opengeni/events";
+import { HTTPException as HTTPException15 } from "hono/http-exception";
+
+// src/domain/external-creation-attribution.ts
+import { HTTPException as HTTPException9 } from "hono/http-exception";
+var EXTERNAL_CREATION_ATTRIBUTION_KEY = "opengeniExternalCreationAttribution";
+function externalCreationMetadata(metadata, authorization, grant) {
+  if (metadata && Object.hasOwn(metadata, EXTERNAL_CREATION_ATTRIBUTION_KEY)) {
+    throw new HTTPException9(422, {
+      message: `${EXTERNAL_CREATION_ATTRIBUTION_KEY} is server-owned`
+    });
+  }
+  const attribution = externalAttributionForAuthorization(authorization, grant);
+  if (!attribution) return metadata;
+  return { ...metadata, [EXTERNAL_CREATION_ATTRIBUTION_KEY]: attribution };
 }
-function startOfUtcMonth() {
-  const now = /* @__PURE__ */ new Date();
-  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+
+// src/application/external-link-work-admission.ts
+import { ExternalLinkWorkSnapshot } from "@opengeni/contracts/external-identities";
+import {
+  captureExternalLinkTurnAuthority,
+  captureExternalLinkTaskAuthority,
+  getExternalLinkTurnSnapshot,
+  getSessionTurnForAttempt as getSessionTurnForAttempt2
+} from "@opengeni/db";
+function snapshotFor(authorization) {
+  const continuation = authorization ? externalActorContinuationForAuthorization(authorization) : null;
+  return continuation?.actor.actingMode === "linked_native" ? ExternalLinkWorkSnapshot.parse({
+    ...continuation,
+    permissions: [...authorization.grant.permissions]
+  }) : null;
+}
+function prepareExternalLinkTurnAdmission(authorization) {
+  const snapshot = snapshotFor(authorization);
+  if (!snapshot || !authorization) return void 0;
+  const workspaceId = authorization.grant.workspaceId;
+  const accountId = authorization.grant.accountId;
+  const commit = externalContinuationCommitAuthorizer(authorization);
+  return async (tx, sessionId, turnId) => {
+    await commit(tx);
+    await captureExternalLinkTurnAuthority(tx, {
+      accountId,
+      workspaceId,
+      sessionId,
+      turnId,
+      snapshot
+    });
+  };
+}
+function prepareExternalLinkTaskAdmission(authorization, actor) {
+  const snapshot = snapshotFor(authorization);
+  const commit = externalContinuationCommitAuthorizer(authorization);
+  if (snapshot)
+    return async (tx, task) => {
+      await commit?.(tx);
+      await captureExternalLinkTaskAuthority(tx, task, snapshot);
+    };
+  if (!actor) {
+    return authorization && hasVerifiedOwningUserAuthorization(authorization) ? async () => {
+    } : void 0;
+  }
+  return async (tx, task) => {
+    const turn = await getSessionTurnForAttempt2(
+      tx,
+      task.workspaceId,
+      actor.sessionId,
+      actor.attemptId
+    );
+    if (!turn || turn.id !== actor.turnId || turn.executionGeneration !== actor.executionGeneration)
+      throw new Error("Linked task creator attempt is no longer active");
+    const inherited = await getExternalLinkTurnSnapshot(tx, task, actor.turnId);
+    if (inherited) await captureExternalLinkTaskAuthority(tx, task, inherited);
+  };
 }
 
 // src/domain/native-mcp-connection-admission.ts
@@ -4071,6 +4205,7 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { isDeepStrictEqual } from "util";
 import { withLockedCapabilityInstallation } from "@opengeni/db/capability-reconciliation";
 import { environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes2 } from "@opengeni/config";
+import { pinnedFetch } from "@opengeni/network";
 import {
   CapabilityCatalogItem,
   capabilityCatalogItemIsTrustedForExposure,
@@ -4344,7 +4479,12 @@ async function prepareCapabilityEnable(input) {
     assertRequiredMcpCredentialHeaders(item, headers, connectionRef);
     installationMetadata = {
       ...installationMetadata,
-      ...connectionRef && !headers ? authDeferredMcpConnectivity() : await validateMcpCapabilityConnection(item, input.probeMcpServer, headers ?? void 0)
+      ...connectionRef && !headers ? authDeferredMcpConnectivity() : await validateMcpCapabilityConnection(
+        item,
+        input.probeMcpServer,
+        headers ?? void 0,
+        input.settings
+      )
     };
     if (connectionRef) {
       installationConfig.connectionRef = connectionRef;
@@ -4591,7 +4731,7 @@ function requireCapabilityHeaderEncryption(settings) {
   }
   return key;
 }
-async function validateMcpCapabilityConnection(item, probe = probeStreamableHttpMcpServer, headers) {
+async function validateMcpCapabilityConnection(item, probe = probeStreamableHttpMcpServer, headers, settings) {
   if (item.kind !== "mcp") {
     return {};
   }
@@ -4606,7 +4746,8 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
       name: item.name,
       url: item.endpointUrl,
       timeoutMs: mcpCapabilityProbeTimeoutMs,
-      ...headers ? { headers } : {}
+      ...headers ? { headers } : {},
+      ...settings ? { settings } : {}
     });
     return {
       mcpConnectivity: {
@@ -4622,6 +4763,8 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
   }
 }
 async function probeStreamableHttpMcpServer(input) {
+  const settings = input.settings;
+  if (!settings) throw new Error("Network policy is unavailable for MCP validation");
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
   const client = new Client(
@@ -4633,7 +4776,11 @@ async function probeStreamableHttpMcpServer(input) {
       requestInit: {
         signal: controller.signal,
         ...input.headers ? { headers: input.headers } : {}
-      }
+      },
+      fetch: (url, init) => pinnedFetch(url, init, settings, {
+        label: "MCP capability probe",
+        requireHttpsOutsideLocalTest: true
+      })
     });
     await client.connect(transport, {
       timeout: input.timeoutMs,
@@ -5048,6 +5195,7 @@ function fikenCatalogItem(fikenConnections) {
     metadata: {
       connectorMode: "first_party_fiken",
       ownership: "workspace",
+      connectionStatus: fikenConnection?.status ?? null,
       // Derived from the contracts catalog so a new fiken_* tool cannot be
       // registered without also appearing on the capability tile.
       firstPartyMcpTools: FIRST_PARTY_MCP_TOOL_NAMES.filter((name) => name.startsWith("fiken_"))
@@ -5249,15 +5397,15 @@ function socialProviderConnectionCounts(item) {
   };
 }
 function applyCapabilityEnablement(item, installation) {
+  if (item.surfaceType === "first_party_fiken") {
+    return { ...item, connectionRef: null };
+  }
   if (item.kind === "skill" || item.kind === "api" || item.kind === "plugin") {
     return { ...item, enabled: false, enabledReason: null, connectionRef: null };
   }
   if (isSocialProviderIntegration(item)) {
     return { ...item, connectionRef: null };
   }
-  if (item.surfaceType === "first_party_fiken") {
-    return { ...item, connectionRef: null };
-  }
   if (item.surfaceType === "codex_apps") {
     return { ...item, connectionRef: null };
   }
@@ -10136,6 +10284,39 @@ async function acceptSessionUserMessageWithOutcome(...args) {
   return withSessionRlsActorContext4(actor, () => acceptSessionUserMessageInFileScope(...args));
 }
 
+// src/domain/session-native-connection-replacement.ts
+import { connectionMetadataMatchesBinding } from "@opengeni/db/session-mcp-credential-rotation";
+function nativeSessionConnectionReplacement(input) {
+  const connection = input.connections.find(
+    (candidate) => candidate.id === input.nativeConnectionId
+  );
+  if (!connection || connection.accountId !== input.accountId || connection.status !== "active" || (connection.subjectId === null ? connection.workspaceId !== input.workspaceId : !input.subjectId || connection.subjectId !== input.subjectId || !connection.authorityId)) {
+    throw new Error("native connection unavailable");
+  }
+  const {
+    authoritySource: _authoritySource,
+    hostBinding: _hostBinding,
+    accountSelection: _accountSelection,
+    ...retained
+  } = input.currentRef ?? {};
+  if (input.currentRef && input.currentRef.providerDomain.toLowerCase() !== connection.providerDomain.toLowerCase())
+    throw new Error("native connection provider mismatch");
+  const ref = {
+    ...retained,
+    ...!input.currentRef?.resource && typeof connection.metadata.resource === "string" ? { resource: connection.metadata.resource } : {},
+    connectionId: connection.id,
+    providerDomain: connection.providerDomain,
+    kind: connection.kind,
+    subjectScope: connection.subjectId === null ? "workspace" : "subject"
+  };
+  const destination = input.replacementServerUrl ?? input.serverUrl;
+  if (input.replacementServerUrl && (typeof connection.metadata.mcpUrl !== "string" || !connection.metadata.mcpUrl.trim()))
+    throw new Error("native connection destination unavailable");
+  if (!connectionMetadataMatchesBinding(connection, ref, destination))
+    throw new Error("native connection binding mismatch");
+  return ref;
+}
+
 // src/application/session-mcp-credential-rotation.ts
 function sessionMcpRotationFingerprint(key, scope, request) {
   return {
@@ -10167,9 +10348,14 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
         id: update.id,
         expectedCredentialVersion: update.expectedCredentialVersion,
         expectedServerUrl: update.expectedServerUrl,
-        headers: Object.fromEntries(
-          Object.entries(normalizedSessionMcpCredentialHeaders(update.headers)).map(([name, value]) => [name.toLowerCase(), value]).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
-        )
+        ..."nativeConnectionId" in update ? {
+          nativeConnectionId: update.nativeConnectionId,
+          ...update.replacementServerUrl ? { replacementServerUrl: update.replacementServerUrl } : {}
+        } : {
+          headers: Object.fromEntries(
+            Object.entries(normalizedSessionMcpCredentialHeaders(update.headers)).map(([name, value]) => [name.toLowerCase(), value]).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+          )
+        }
       })).sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0)
     };
     if (new Set(request.updates.map((update) => update.id)).size !== request.updates.length)
@@ -10185,20 +10371,43 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
     actorType: grant.principalKind === "service" ? "service" : "human"
   };
   const externalAuthorize = externalContinuationCommitAuthorizer(authorization);
+  let authorizedGrant = grant;
   try {
     return await rotateSessionMcpCredentialsAtomically(deps.db, {
       ...scope,
       operationKey: request.operationKey,
       ...sessionMcpRotationFingerprint(encryptionKey, scope, request),
-      updates: request.updates.map(({ headers, ...update }) => ({
-        ...update,
-        headersEncrypted: Object.fromEntries(
-          Object.entries(headers).map(([name, value]) => [
-            name,
-            encryptVariableSetValue3(encryptionKey, value)
-          ])
-        )
-      })),
+      updates: request.updates.map(
+        (update) => "nativeConnectionId" in update ? update : {
+          id: update.id,
+          expectedCredentialVersion: update.expectedCredentialVersion,
+          expectedServerUrl: update.expectedServerUrl,
+          headersEncrypted: Object.fromEntries(
+            Object.entries(update.headers).map(([name, value]) => [
+              name,
+              encryptVariableSetValue3(encryptionKey, value)
+            ])
+          )
+        }
+      ),
+      resolveNativeConnection: async (tx, server, nativeConnectionId, replacementServerUrl) => {
+        const connections = await listOwnConnectionAccountsForGrant(tx, authorizedGrant);
+        const source = personalConnectionDelegationSourceForGrant(authorizedGrant);
+        try {
+          return nativeSessionConnectionReplacement({
+            accountId: grant.accountId,
+            workspaceId: grant.workspaceId,
+            subjectId: source.kind === "subject" ? source.subjectId : null,
+            serverUrl: server.url,
+            ...replacementServerUrl ? { replacementServerUrl } : {},
+            currentRef: server.connectionRef,
+            nativeConnectionId,
+            connections
+          });
+        } catch {
+          throw new SessionMcpCredentialRotationError("connection_unavailable");
+        }
+      },
       authorize: async (tx) => {
         await externalAuthorize?.(tx);
         const fresh = await reauthorize(tx);
@@ -10221,6 +10430,7 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
           operation: "session.mcp.credentials.rotate",
           surface: "http"
         });
+        authorizedGrant = fresh;
       }
     });
   } catch (error) {
@@ -10231,7 +10441,7 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
     if (error instanceof SessionAuthorizationUnavailableError)
       throw new HTTPException16(503, { message: "credential rotation authorization unavailable" });
     if (error instanceof SessionMcpCredentialRotationError) {
-      const status = error.code === "receipt_key_unavailable" ? 503 : error.code === "authority_revoked" ? 403 : error.code === "not_found" ? 404 : error.code === "invalid_request" || error.code === "brokered_server" ? 422 : 409;
+      const status = error.code === "receipt_key_unavailable" ? 503 : error.code === "authority_revoked" ? 403 : error.code === "not_found" ? 404 : error.code === "invalid_request" || error.code === "brokered_server" || error.code === "connection_unavailable" ? 422 : 409;
       throw new HTTPException16(status, { message: `credential_rotation_${error.code}` });
     }
     throw new HTTPException16(503, { message: "credential rotation unavailable" });
@@ -10672,7 +10882,7 @@ function sha256Hex2(bytes) {
 }
 
 // src/domain/skill-search.ts
-import { pinnedFetch, readResponseJsonBounded } from "@opengeni/network";
+import { pinnedFetch as pinnedFetch2, readResponseJsonBounded } from "@opengeni/network";
 var PublicSkillSearchError = class extends Error {
   constructor(code, message, retryAfterSeconds = null) {
     super(message);
@@ -10687,7 +10897,7 @@ var maxResponseBytes = 256 * 1024;
 var maxResults = 20;
 var ownerPattern = /^[a-z0-9](?:[a-z0-9-]{0,38})$/iu;
 var segmentPattern = /^[a-z0-9](?:[a-z0-9._-]{0,98}[a-z0-9])?$/iu;
-function createPublicSkillSearchClient(settings, fetcher = pinnedFetch) {
+function createPublicSkillSearchClient(settings, fetcher = pinnedFetch2) {
   return {
     async search(input) {
       const query = input.query.trim();
@@ -10814,7 +11024,7 @@ function parseRetryAfter(value) {
 
 // src/domain/github-skill-source.ts
 import { HTTPException as HTTPException19 } from "hono/http-exception";
-import { pinnedFetch as pinnedFetch2, readResponseJsonBounded as readResponseJsonBounded2, readResponseTextBounded } from "@opengeni/network";
+import { pinnedFetch as pinnedFetch3, readResponseJsonBounded as readResponseJsonBounded2, readResponseTextBounded } from "@opengeni/network";
 import {
   PORTABLE_SKILL_MAX_FILES as PORTABLE_SKILL_MAX_FILES2,
   PORTABLE_SKILL_MAX_FILE_BYTES as PORTABLE_SKILL_MAX_FILE_BYTES2,
@@ -10915,7 +11125,7 @@ function createGitHubSkillSourceClient(settings, requestJson = (path, maxBytes,
 }
 async function downloadSkillSnapshot(settings, owner, repository, slug) {
   const signal = AbortSignal.timeout(githubRequestTimeoutMs);
-  const response = await pinnedFetch2(
+  const response = await pinnedFetch3(
     `https://skills.sh/api/download/${[owner, repository, slug].map(encodeURIComponent).join("/")}`,
     { headers: { accept: "application/json" }, credentials: "omit", redirect: "manual", signal },
     settings,
@@ -10950,7 +11160,7 @@ async function githubJson(settings, path, maxBytes, label) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), githubRequestTimeoutMs);
   try {
-    const response = await pinnedFetch2(
+    const response = await pinnedFetch3(
       `${githubApiBase}${path}`,
       {
         method: "GET",
@@ -17339,7 +17549,7 @@ var CATALOG_PAGE_SIZE = 25;
 var CATALOG_PAGE_BUDGET = 40;
 var DESCRIPTION_CHARS = 2e3;
 var CATALOG_BYTES = 256 * 1024;
-async function prepareKnowledgeSave(db, context, input, embedder, services = defaults) {
+async function prepareKnowledgeSave(db, context, input, embedder, services = defaults, settings) {
   const request = KnowledgeSavePreparationRequest.parse(input);
   if (context.actor.kind !== "agent" && !(context.actor.kind === "human" && context.actor.review)) {
     throw Object.assign(
@@ -17364,20 +17574,31 @@ async function prepareKnowledgeSave(db, context, input, embedder, services = def
     complete: true,
     nextCursors: { published: null, needs_review: null }
   };
-  const matches = {
-    published: await services.search(
-      db,
-      context,
-      { query: request.query, limit: request.limit, view: "published" },
-      sharedEmbedder
-    ),
-    needs_review: await services.search(
-      db,
-      context,
-      { query: request.query, limit: request.limit, view: "needs_review" },
-      sharedEmbedder
-    )
-  };
+  const paid = settings != null && paidDocumentEmbedding(settings);
+  const published = await services.search(
+    db,
+    context,
+    {
+      query: request.query,
+      limit: request.limit,
+      view: "published",
+      ...paid ? { mode: "keyword" } : {}
+    },
+    sharedEmbedder,
+    paid ? void 0 : settings
+  );
+  const needsReview = await services.search(
+    db,
+    context,
+    {
+      query: request.query,
+      limit: request.limit,
+      view: "needs_review",
+      ...published.searchMode === "keyword" ? { mode: "keyword" } : {}
+    },
+    sharedEmbedder
+  );
+  const matches = { published, needs_review: needsReview };
   for (const view of ["published", "needs_review"]) {
     if (request.collectionCursors && request.collectionCursors[view] === null) continue;
     let cursor = request.collectionCursors?.[view] ?? void 0;
@@ -17786,6 +18007,8 @@ export {
   InMemoryEditableArtifactLiveTicketStore,
   InMemoryEditableArtifactStableIdFactory,
   InMemoryEditableArtifactStore,
+  KnowledgeVectorFundingError,
+  KnowledgeVectorQueryRejectedError,
   MAX_CHECKS_PER_RIG,
   MAX_CREDENTIAL_HOOKS_PER_RIG,
   MAX_DEFAULT_VARIABLE_SETS_PER_RIG,
@@ -17934,6 +18157,7 @@ export {
   directRetainedProcessMatchesBackend,
   disableCapability,
   discoverMcpRegistryCapabilities,
+  documentEmbeddingCostMicros,
   editHumanQueuePrompt,
   editableArtifactActorKey,
   editableArtifactAuthorizationRevisionPortFromPostgres,
@@ -18076,6 +18300,7 @@ export {
   openGeniSlackBotMetadata,
   organizationIntegrationCatalog,
   organizationMembershipHttpStatus,
+  paidDocumentEmbedding,
   parseGitHubRepositoryCoordinates,
   parseSkillSource,
   personalAtlassianDelegationsFromVisibleConnections,