@opengeni/core 0.24.1 → 0.28.1

package/dist/index.js

@@ -116,6 +116,9 @@ import {
   ogatxEditableArtifactMutationIntentCodec,
   validateEditableArtifactActor
 } from "./chunk-JJU6I5XD.js";
+import {
+  getManagedSession
+} from "./chunk-IBOEYG6N.js";
 
 // src/workflow-wake-contract.ts
 var SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wake-dispatcher";
@@ -123,26 +126,6 @@ var SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE = "sessionWorkflowWakeDispatc
 var SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS = 1e4;
 var TURN_ACTIVITY_CANCELLATION_HEARTBEAT_INTERVAL_MS = 500;
 
-// src/managed-session.ts
-async function getManagedSession(c, auth) {
-  const result = await auth.api.getSession({
-    headers: c.req.raw.headers,
-    returnHeaders: true
-  });
-  for (const cookie of setCookieHeaders(result.headers)) {
-    c.header("set-cookie", cookie, { append: true });
-  }
-  return result.response;
-}
-function setCookieHeaders(headers) {
-  const getSetCookie = headers.getSetCookie;
-  if (getSetCookie) {
-    return getSetCookie.call(headers);
-  }
-  const cookie = headers.get("set-cookie");
-  return cookie ? [cookie] : [];
-}
-
 // src/transcription.ts
 var TRANSCRIPTION_PROVIDER_REQUEST_TIMEOUT_MILLISECONDS = 10 * 60 * 1e3;
 var TranscriptionServiceError = class extends Error {
@@ -234,7 +217,6 @@ import {
   SelfhostedSession,
   swapTargetEstablishability
 } from "@opengeni/runtime/sandbox";
-import { HTTPException } from "hono/http-exception";
 
 // src/sandbox/routing.ts
 import { sandboxLifecycleTransitionWaitMs } from "@opengeni/config";
@@ -553,11 +535,6 @@ function wrapChannelABoxWithRouting(services, ids, established) {
 // src/sandbox/fleet.ts
 async function buildFleetContextForSession(deps, ctx) {
   const session = await requireSession(deps.db, ctx.workspaceId, ctx.sessionId);
-  if (session.sandboxBackend === "none") {
-    throw new HTTPException(422, {
-      message: "this session has no sandbox (backend: none); the fleet is unavailable"
-    });
-  }
   return {
     accountId: ctx.accountId,
     workspaceId: ctx.workspaceId,
@@ -613,40 +590,42 @@ async function listFleet(services, ctx) {
     activeEpoch: 0
   };
   const entries = [];
-  const groupActive = pointer.activeSandboxId === null;
-  const groupLease = await readLease(db, ctx.workspaceId, ctx.sessionGroupId);
-  const groupOnline = Boolean(
-    groupLease?.liveness === "warm" && groupLease.recovery.provider.status === "exists" && groupLease.recovery.workspace.status === "ready"
-  );
-  const groupRecovering = Boolean(
-    groupLease && (groupLease.liveness === "warming" || groupLease.recovery.restore.status === "pending" || groupLease.recovery.restore.status === "restoring" || groupLease.recovery.restore.status === "verifying")
-  );
-  const groupRecoveryUnavailable = Boolean(
-    groupLease && (groupLease.recovery.restore.status === "degraded" || groupLease.recovery.restore.status === "unrecoverable" || groupLease.recovery.workspace.status === "degraded" || groupLease.recovery.workspace.status === "unrecoverable")
-  );
-  const groupOperationAvailability = groupOnline ? "ready" : groupRecoveryUnavailable ? "unavailable" : groupRecovering ? "recovering" : ctx.sessionBackend === "selfhosted" ? "unavailable" : "wakeable";
-  entries.push({
-    id: ctx.sessionGroupId,
-    kind: ctx.sessionBackend === "selfhosted" ? "selfhosted" : "modal",
-    name: "session sandbox",
-    liveness: groupOnline ? "online" : groupRecovering ? "reconnecting" : "offline",
-    active: groupActive,
-    isSessionGroup: true,
-    enrollmentId: null,
-    attachable: groupOnline,
-    operationAvailability: groupOperationAvailability,
-    providerStatus: groupLease?.recovery.provider.status ?? "not_created",
-    leaseLiveness: groupLease?.liveness ?? null,
-    routeStatus: groupActive ? "attached" : "detached",
-    archiveStatus: groupLease?.recovery.archive.status ?? "none",
-    restoreStatus: groupLease?.recovery.restore.status ?? "not_required",
-    workspaceStatus: groupLease?.recovery.workspace.status ?? "unknown",
-    leaseEpoch: groupLease?.leaseEpoch ?? null,
-    routeEpoch: pointer.activeEpoch,
-    workspaceGeneration: groupLease?.workspaceGeneration ?? null,
-    archiveGeneration: groupLease?.archiveGeneration ?? null,
-    archiveComplete: groupLease?.archiveComplete ?? false
-  });
+  if (ctx.sessionBackend !== "none") {
+    const groupActive = pointer.activeSandboxId === null;
+    const groupLease = await readLease(db, ctx.workspaceId, ctx.sessionGroupId);
+    const groupOnline = Boolean(
+      groupLease?.liveness === "warm" && groupLease.recovery.provider.status === "exists" && groupLease.recovery.workspace.status === "ready"
+    );
+    const groupRecovering = Boolean(
+      groupLease && (groupLease.liveness === "warming" || groupLease.recovery.restore.status === "pending" || groupLease.recovery.restore.status === "restoring" || groupLease.recovery.restore.status === "verifying")
+    );
+    const groupRecoveryUnavailable = Boolean(
+      groupLease && (groupLease.recovery.restore.status === "degraded" || groupLease.recovery.restore.status === "unrecoverable" || groupLease.recovery.workspace.status === "degraded" || groupLease.recovery.workspace.status === "unrecoverable")
+    );
+    const groupOperationAvailability = groupOnline ? "ready" : groupRecoveryUnavailable ? "unavailable" : groupRecovering ? "recovering" : ctx.sessionBackend === "selfhosted" ? "unavailable" : "wakeable";
+    entries.push({
+      id: ctx.sessionGroupId,
+      kind: ctx.sessionBackend === "selfhosted" ? "selfhosted" : "modal",
+      name: "session sandbox",
+      liveness: groupOnline ? "online" : groupRecovering ? "reconnecting" : "offline",
+      active: groupActive,
+      isSessionGroup: true,
+      enrollmentId: null,
+      attachable: groupOnline,
+      operationAvailability: groupOperationAvailability,
+      providerStatus: groupLease?.recovery.provider.status ?? "not_created",
+      leaseLiveness: groupLease?.liveness ?? null,
+      routeStatus: groupActive ? "attached" : "detached",
+      archiveStatus: groupLease?.recovery.archive.status ?? "none",
+      restoreStatus: groupLease?.recovery.restore.status ?? "not_required",
+      workspaceStatus: groupLease?.recovery.workspace.status ?? "unknown",
+      leaseEpoch: groupLease?.leaseEpoch ?? null,
+      routeEpoch: pointer.activeEpoch,
+      workspaceGeneration: groupLease?.workspaceGeneration ?? null,
+      archiveGeneration: groupLease?.archiveGeneration ?? null,
+      archiveComplete: groupLease?.archiveComplete ?? false
+    });
+  }
   const sandboxes = await listSandboxes(db, ctx.workspaceId);
   for (const sandbox of sandboxes) {
     if (sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
@@ -691,6 +670,13 @@ async function listFleet(services, ctx) {
 }
 async function resolveTarget(services, ctx, target) {
   if (target === ctx.sessionGroupId || target === "session" || target === "default") {
+    if (ctx.sessionBackend === "none") {
+      return {
+        ok: false,
+        reason: "this session has no home sandbox; attach a Connected Machine",
+        code: "unsupported_backend_context"
+      };
+    }
     return { ok: true, targetSandboxId: null };
   }
   const sandbox = await getSandbox2(services.db, ctx.workspaceId, target);
@@ -955,12 +941,18 @@ import {
   getWorkspaceGrant,
   requireWorkspace
 } from "@opengeni/db";
-import { HTTPException as HTTPException2 } from "hono/http-exception";
+import { HTTPException } from "hono/http-exception";
 var bearerPrefix = "Bearer ";
+var accessContextByRequest = /* @__PURE__ */ new WeakMap();
 async function requireAccessContext(c, deps) {
-  const context = await resolveAccessContext(c, deps);
+  let pending = accessContextByRequest.get(c.req.raw);
+  if (!pending) {
+    pending = resolveAccessContext(c, deps);
+    accessContextByRequest.set(c.req.raw, pending);
+  }
+  const context = await pending;
   if (!context) {
-    throw new HTTPException2(401, { message: "authentication required" });
+    throw new HTTPException(401, { message: "authentication required" });
   }
   return context;
 }
@@ -996,9 +988,9 @@ async function requireAccessGrantAuthorization(c, deps, workspaceId, permission)
   if (!grant) {
     const workspace = await requireWorkspace(deps.db, workspaceId).catch(() => null);
     if (!workspace) {
-      throw new HTTPException2(404, { message: "workspace not found" });
+      throw new HTTPException(404, { message: "workspace not found" });
     }
-    throw new HTTPException2(403, { message: "workspace access denied" });
+    throw new HTTPException(403, { message: "workspace access denied" });
   }
   if (permission) {
     requirePermission(grant, permission);
@@ -1016,23 +1008,23 @@ function hostedHumanSessionPrincipalKind(context) {
 function requirePermission(grant, permission) {
   if (!hasPermission(grant.permissions, permission)) {
     if (permission === "variable-sets:use") {
-      throw new HTTPException2(403, {
+      throw new HTTPException(403, {
         message: "missing permission: variable-sets:use (deprecated alias: environments:use)"
       });
     }
     if (permission === "variable-sets:manage") {
-      throw new HTTPException2(403, {
+      throw new HTTPException(403, {
         message: "missing permission: variable-sets:manage (deprecated alias: environments:manage)"
       });
     }
-    throw new HTTPException2(403, {
+    throw new HTTPException(403, {
       message: `missing permission: ${permission}`
     });
   }
 }
 function requireLiteralPermission(grant, permission) {
   if (!hasLiteralPermission(grant.permissions, permission)) {
-    throw new HTTPException2(403, {
+    throw new HTTPException(403, {
       message: `missing literal permission: ${permission}`
     });
   }
@@ -1122,7 +1114,7 @@ async function resolveAccessContext(c, deps) {
     }
   }
   if (deps.managedAuth) {
-    const session = await getManagedSession(c, deps.managedAuth);
+    const session = await getManagedSession(c, deps.managedAuth, { db: deps.db });
     if (session?.user) {
       return await ensureManagedAccessForUser(deps.db, {
         userId: session.user.id,
@@ -1207,6 +1199,8 @@ async function delegatedAccessContext(c, deps, mode, token = bearerToken(c)) {
           delegated: true,
           ...payload.sessionId ? { sessionId: payload.sessionId } : {},
           ...payload.firstPartyMcpTools !== void 0 ? { firstPartyMcpTools: payload.firstPartyMcpTools } : {},
+          ...payload.nestedAgentDepth !== void 0 ? { nestedAgentDepth: payload.nestedAgentDepth } : {},
+          ...payload.effectiveMaxNestedAgentDepth !== void 0 ? { effectiveMaxNestedAgentDepth: payload.effectiveMaxNestedAgentDepth } : {},
           // Caller identity: the turn that minted this token. Tools classify the
           // CALLER from this instead of re-reading the live active pointer.
           ...payload.turnId ? { turnId: payload.turnId } : {},
@@ -1241,10 +1235,11 @@ import {
   SessionAuthorizationListScope
 } from "@opengeni/contracts";
 import {
+  getSessionAuthorityProjection,
   getSession,
-  getSessionRootId,
   getSessionTurnForAttempt,
-  getSlackInteractionSessionAccessForSession
+  getSlackInteractionSessionAccessForSession,
+  withSessionRlsActorContext
 } from "@opengeni/db";
 var SESSION_AUTHORIZATION_DEFAULT_REAUTHORIZE_MS = 15e3;
 var SessionAuthorizationDeniedError = class extends Error {
@@ -1262,8 +1257,48 @@ var SessionAuthorizationUnavailableError = class extends Error {
     this.name = "SessionAuthorizationUnavailableError";
   }
 };
+function grantHasAgentAttemptAuthority(grant) {
+  const hasAgentAttemptClaim = grant.metadata?.["turnId"] !== void 0 || grant.metadata?.["attemptId"] !== void 0 || grant.metadata?.["executionGeneration"] !== void 0;
+  return grant.principalKind ? grant.principalKind === "agent_attempt" : hasAgentAttemptClaim;
+}
+var AGENT_PARENT_READ_OPERATIONS = /* @__PURE__ */ new Set([
+  "session.read",
+  "session.events.read",
+  "session.stream.read",
+  "session.turns.read",
+  "session.queue.read",
+  "session.composer.read",
+  "session.lineage.read",
+  "session.capture.read",
+  "session.files.read",
+  "session.git.read",
+  "session.terminal.read",
+  "session.viewer.read",
+  "session.goal.read",
+  "session.human_input.read"
+]);
+function enforceAgentSessionHierarchy(actor, callerParentSessionId, target, operation) {
+  if (target.target.sessionId === actor.callerSessionId) return "root";
+  if (target.parentSessionId === actor.callerSessionId) return "target";
+  if (callerParentSessionId === target.target.sessionId) {
+    if (operation === "session.append" || AGENT_PARENT_READ_OPERATIONS.has(operation)) {
+      return "target";
+    }
+    throw new SessionAuthorizationDeniedError("forbidden");
+  }
+  throw new SessionAuthorizationDeniedError("forbidden");
+}
+function sessionRlsActorForAuthorization(authorization) {
+  return authorization.actor.kind === "agent_attempt" ? {
+    subjectId: authorization.actor.subjectId,
+    initiatingHumanSubjectId: authorization.actor.initiatingHumanSubjectId
+  } : { subjectId: authorization.actor.subjectId };
+}
+async function withResolvedSessionAuthorization(authorization, fn) {
+  return await withSessionRlsActorContext(sessionRlsActorForAuthorization(authorization), fn);
+}
 async function requireLiveAgentAttemptAuthorization(db, grant, callerSessionId) {
-  const actor = await resolveSessionAuthorizationActor(db, grant);
+  const { actor } = await resolveSessionAuthorizationActor(db, grant);
   if (actor.kind !== "agent_attempt" || actor.callerSessionId !== callerSessionId) {
     throw new SessionAuthorizationDeniedError("caller_stale");
   }
@@ -1271,19 +1306,47 @@ async function requireLiveAgentAttemptAuthorization(db, grant, callerSessionId)
 }
 async function requireSessionAuthorization(deps, grant, input) {
   const port = deps.sessionAuthorization;
-  const slackAccess = await getSlackInteractionSessionAccessForSession(deps.db, {
-    accountId: grant.accountId,
-    workspaceId: grant.workspaceId,
-    sessionId: input.sessionId
-  });
-  if (!port && slackAccess?.visibility !== "private") return null;
-  const actor = await resolveSessionAuthorizationActor(deps.db, grant);
-  const target = slackAccess ? { sessionId: input.sessionId, rootSessionId: slackAccess.rootSessionId } : await resolveSessionAuthorizationTarget(deps.db, grant, input.sessionId);
+  const isAgentAttempt = grantHasAgentAttemptAuthority(grant);
+  const [slackAccess, authority] = await Promise.all([
+    getSlackInteractionSessionAccessForSession(deps.db, {
+      accountId: grant.accountId,
+      workspaceId: grant.workspaceId,
+      sessionId: input.sessionId
+    }),
+    getSessionAuthorityProjection(deps.db, grant.workspaceId, input.sessionId)
+  ]);
+  if (!port && !isAgentAttempt && slackAccess?.visibility !== "private" && authority?.visibility !== "user_private") {
+    return null;
+  }
+  if (!authority) throw new SessionAuthorizationDeniedError("not_found");
+  const [resolvedActor, resolvedTarget] = await Promise.all([
+    resolveSessionAuthorizationActor(deps.db, grant),
+    resolveSessionAuthorizationTarget(deps.db, grant, input.sessionId)
+  ]);
+  const actor = resolvedActor.actor;
+  const target = resolvedTarget.target;
+  const agentRelatedSessionAccess = actor.kind === "agent_attempt" ? enforceAgentSessionHierarchy(
+    actor,
+    resolvedActor.callerParentSessionId,
+    resolvedTarget,
+    input.operation
+  ) : null;
+  if (authority.visibility === "user_private") {
+    const allowed = authority.ownerSubjectId !== null && (actor.kind === "subject" ? actor.subjectId === authority.ownerSubjectId : actor.initiatingHumanSubjectId === authority.ownerSubjectId);
+    if (!allowed) throw new SessionAuthorizationDeniedError("forbidden");
+  }
   if (slackAccess?.visibility === "private") {
     const allowed = actor.kind === "subject" ? actor.subjectId === slackAccess.owningSubjectId : actor.callerRootSessionId === target.rootSessionId;
     if (!allowed) throw new SessionAuthorizationDeniedError("forbidden");
   }
-  if (!port) return null;
+  if (!port) {
+    return {
+      actor,
+      target,
+      relatedSessionAccess: agentRelatedSessionAccess ?? "root",
+      reauthorizeAfterMs: null
+    };
+  }
   let rawDecision;
   try {
     rawDecision = await port.authorizeSession({
@@ -1307,14 +1370,16 @@ async function requireSessionAuthorization(deps, grant, input) {
   return {
     actor,
     target,
-    relatedSessionAccess: parsed.data.relatedSessionAccess ?? "target",
+    relatedSessionAccess: agentRelatedSessionAccess === "target" ? "target" : parsed.data.relatedSessionAccess ?? "target",
     reauthorizeAfterMs: parsed.data.reauthorizeAfterMs ?? null
   };
 }
 async function requireSessionAuthorizationListScope(deps, grant, surface) {
   const port = deps.sessionAuthorization;
+  const isAgentAttempt = grantHasAgentAttemptAuthority(grant);
+  if (!port && !isAgentAttempt) return null;
+  const { actor } = await resolveSessionAuthorizationActor(deps.db, grant);
   if (!port) return null;
-  const actor = await resolveSessionAuthorizationActor(deps.db, grant);
   let rawScope;
   try {
     rawScope = await port.resolveListScope({
@@ -1342,53 +1407,52 @@ async function resolveSessionAuthorizationTarget(db, grant, sessionId) {
   if (!session || session.accountId !== grant.accountId) {
     throw new SessionAuthorizationDeniedError("not_found");
   }
-  let rootSessionId;
-  try {
-    rootSessionId = await getSessionRootId(db, grant.workspaceId, session.id);
-  } catch (error) {
-    throw new SessionAuthorizationUnavailableError({ cause: error });
-  }
-  if (!rootSessionId) {
-    throw new SessionAuthorizationDeniedError("not_found");
-  }
-  return { sessionId: session.id, rootSessionId };
+  return {
+    target: { sessionId: session.id, rootSessionId: session.rootSessionId },
+    parentSessionId: session.parentSessionId
+  };
 }
 async function resolveSessionAuthorizationActor(db, grant) {
   const callerSessionId = grant.metadata?.["sessionId"];
   const turnId = grant.metadata?.["turnId"];
   const attemptId = grant.metadata?.["attemptId"];
   const executionGeneration = grant.metadata?.["executionGeneration"];
-  const hasAttemptClaim = turnId !== void 0 || attemptId !== void 0 || executionGeneration !== void 0;
-  if (!hasAttemptClaim) {
-    return SessionAuthorizationActor.parse({
-      kind: "subject",
-      subjectId: grant.subjectId,
-      ...grant.subjectLabel ? { subjectLabel: grant.subjectLabel } : {}
-    });
+  const isAgentAttempt = grantHasAgentAttemptAuthority(grant);
+  if (!isAgentAttempt) {
+    return {
+      actor: SessionAuthorizationActor.parse({
+        kind: "subject",
+        subjectId: grant.subjectId,
+        ...grant.subjectLabel ? { subjectLabel: grant.subjectLabel } : {}
+      }),
+      callerParentSessionId: null
+    };
   }
   if (typeof callerSessionId !== "string" || typeof turnId !== "string" || typeof attemptId !== "string" || typeof executionGeneration !== "number" || !Number.isSafeInteger(executionGeneration) || executionGeneration < 1) {
     throw new SessionAuthorizationDeniedError("caller_stale");
   }
-  const [callerSession, turn, callerRootSessionId] = await Promise.all([
+  const [callerSession, turn] = await Promise.all([
     getSession(db, grant.workspaceId, callerSessionId),
-    getSessionTurnForAttempt(db, grant.workspaceId, callerSessionId, attemptId),
-    getSessionRootId(db, grant.workspaceId, callerSessionId).catch(() => null)
+    getSessionTurnForAttempt(db, grant.workspaceId, callerSessionId, attemptId)
   ]);
-  if (!callerSession || callerSession.accountId !== grant.accountId || !turn || turn.id !== turnId || turn.executionGeneration !== executionGeneration || callerSession.activeTurnId !== turn.id || !callerRootSessionId) {
+  if (!callerSession || callerSession.accountId !== grant.accountId || !turn || turn.id !== turnId || turn.executionGeneration !== executionGeneration || callerSession.activeTurnId !== turn.id) {
     throw new SessionAuthorizationDeniedError("caller_stale");
   }
-  return SessionAuthorizationActor.parse({
-    kind: "agent_attempt",
-    subjectId: grant.subjectId,
-    callerSessionId,
-    callerRootSessionId,
-    turnId,
-    attemptId,
-    executionGeneration,
-    initiator: turn.initiator,
-    initiatorContext: turn.initiatorContext,
-    initiatingHumanSubjectId: turn.initiatingHumanSubjectId ?? (turn.initiator.kind === "subject" ? turn.initiator.subjectId : null)
-  });
+  return {
+    actor: SessionAuthorizationActor.parse({
+      kind: "agent_attempt",
+      subjectId: grant.subjectId,
+      callerSessionId,
+      callerRootSessionId: callerSession.rootSessionId,
+      turnId,
+      attemptId,
+      executionGeneration,
+      initiator: turn.initiator,
+      initiatorContext: turn.initiatorContext,
+      initiatingHumanSubjectId: turn.initiatingHumanSubjectId ?? (turn.initiator.kind === "subject" ? turn.initiator.subjectId : null)
+    }),
+    callerParentSessionId: callerSession.parentSessionId
+  };
 }
 
 // src/billing/limits.ts
@@ -1402,13 +1466,13 @@ import {
   recordUsageEvent,
   sumUsageQuantity
 } from "@opengeni/db";
-import { HTTPException as HTTPException3 } from "hono/http-exception";
+import { HTTPException as HTTPException2 } from "hono/http-exception";
 async function requireLimit(deps, input) {
   const decision = await checkLimit(deps, input);
   if (decision.allowed) {
     return;
   }
-  throw new HTTPException3(decision.code === "insufficient_credits" ? 402 : 429, {
+  throw new HTTPException2(decision.code === "insufficient_credits" ? 402 : 429, {
     message: decision.message
   });
 }
@@ -1579,10 +1643,12 @@ function startOfUtcMonth() {
 // src/domain/capabilities.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes2 } from "@opengeni/config";
+import { environmentsEncryptionKeyBytes } from "@opengeni/config";
 import {
   CapabilityCatalogItem,
-  capabilityCatalogItemIsTrustedForExposure
+  capabilityCatalogItemIsTrustedForExposure,
+  FIKEN_PROVIDER_DOMAIN as FIKEN_PROVIDER_DOMAIN2,
+  FIRST_PARTY_MCP_TOOL_NAMES
 } from "@opengeni/contracts";
 import {
   CODEX_APPS_MCP_SERVER_ID,
@@ -1595,120 +1661,63 @@ import {
   decryptedCapabilityHeaders,
   disableCapabilityInstallation,
   enableCapabilityInstallation,
-  enablePackInstallation,
   encryptVariableSetValue,
   getCapabilityCatalogItem,
   getCapabilityInstallation,
   getConnectionMetadata,
   getCodexAppsCredentialAuthorizationForRun,
   getWorkspaceGrant as getWorkspaceGrant2,
-  getPackInstallation as getPackInstallation2,
   getStoredCapabilityHeaderCiphertext,
-  getVariableSet as getVariableSet3,
   listCapabilityCatalogItems,
   listCapabilityInstallations,
   listConnectionsMetadata,
   listEnabledMcpCapabilityServers,
   listInstalledApiIntegrations,
+  listInstalledSkills,
   listPackInstallations as listPackInstallations2,
   listSocialConnections,
   mcpServerIdForCapability,
-  updatePackInstallationStatus,
   upsertCapabilityCatalogItem
 } from "@opengeni/db";
-import { HTTPException as HTTPException6 } from "hono/http-exception";
-import {
-  getSkillLibraryEntry,
-  listSkillLibraryEntries
-} from "@opengeni/runtime/skill-library";
-
-// src/domain/environments.ts
-import { environmentsEncryptionKeyBytes } from "@opengeni/config";
-import { getVariableSet, recordAuditEvent } from "@opengeni/db";
 import { HTTPException as HTTPException4 } from "hono/http-exception";
-var MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
-var MAX_VARIABLES_PER_ENVIRONMENT = 100;
-var reservedExactNames = /* @__PURE__ */ new Set([
-  "HOME",
-  "PATH",
-  "SHELL",
-  "USER",
-  "LOGNAME",
-  "TMPDIR",
-  "IFS",
-  "ENV",
-  "BASH_ENV",
-  "NODE_OPTIONS",
-  "PYTHONPATH",
-  "PYTHONSTARTUP",
-  "PERL5OPT",
-  "PERL5LIB",
-  "GH_TOKEN",
-  "GITHUB_TOKEN",
-  "GITLAB_TOKEN",
-  "AZURE_DEVOPS_EXT_PAT",
-  "GIT_ASKPASS",
-  "GIT_TERMINAL_PROMPT"
-]);
-var reservedPrefixes = [
-  "OPENGENI_",
-  "GIT_CONFIG_",
-  "GIT_AUTHOR_",
-  "GIT_COMMITTER_",
-  "LD_",
-  "DYLD_"
-];
-function assertAllowedVariableSetVariableName(name) {
-  if (reservedExactNames.has(name) || reservedPrefixes.some((prefix) => name.startsWith(prefix))) {
-    throw new HTTPException4(422, {
-      message: `reserved variable set variable name / reserved environment variable name: ${name}`
-    });
-  }
+
+// src/domain/fiken.ts
+import {
+  FIKEN_CREDENTIAL_LABEL,
+  FIKEN_CREDENTIAL_ROLE,
+  FIKEN_PROVIDER_DOMAIN,
+  FikenConnectionMetadata
+} from "@opengeni/contracts";
+function fikenConnectionMetadata(metadata) {
+  const parsed = FikenConnectionMetadata.safeParse(metadata);
+  return parsed.success ? parsed.data : null;
 }
-var assertAllowedEnvironmentVariableName = assertAllowedVariableSetVariableName;
-function requireVariableSetEncryption(settings) {
-  const key = environmentsEncryptionKeyBytes(settings);
-  if (!key) {
-    throw new HTTPException4(503, {
-      message: "variable sets require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
-    });
-  }
-  return key;
+function isFikenConnection(connection) {
+  return connection.subjectId === null && connection.providerDomain === FIKEN_PROVIDER_DOMAIN && (connection.kind === "api_key" || connection.kind === "oauth2") && fikenConnectionMetadata(connection.metadata)?.credentialRole === FIKEN_CREDENTIAL_ROLE;
 }
-var requireEnvironmentEncryption = requireVariableSetEncryption;
-async function requireVariableSetForApi(db, workspaceId, variableSetId) {
-  const variableSet = await getVariableSet(db, workspaceId, variableSetId);
-  if (!variableSet) {
-    throw new HTTPException4(404, { message: "variableSet not found" });
-  }
-  return variableSet;
+function hasReservedFikenMetadata(metadata) {
+  return metadata?.credentialRole === FIKEN_CREDENTIAL_ROLE || metadata?.credentialLabel === FIKEN_CREDENTIAL_LABEL;
 }
-async function validateVariableSetAttachment(deps, grant, workspaceId, variableSetId, options = {}) {
-  requireVariableSetEncryption(deps.settings);
-  if (!options.preauthorized) {
-    requirePermission(grant, "variable-sets:use");
+function resolveFikenDefaultCompanySlug(input) {
+  const accessible = (slug) => slug !== null && input.companies.some((company) => company.slug === slug);
+  if (input.requested !== null) {
+    return accessible(input.requested) ? input.requested : null;
   }
-  const variableSet = await getVariableSet(deps.db, workspaceId, variableSetId);
-  if (!variableSet) {
-    throw new HTTPException4(422, { message: "unknown variableSetId" });
+  if (accessible(input.previous)) {
+    return input.previous;
   }
-  return variableSet;
+  return input.companies.length === 1 ? input.companies[0].slug : null;
 }
-async function recordVariableSetAuditEvent(db, input) {
-  await recordAuditEvent(db, {
-    accountId: input.grant.accountId,
-    workspaceId: input.grant.workspaceId,
-    subjectId: input.grant.subjectId,
-    action: input.action,
-    targetType: "workspace_variable_set",
-    targetId: input.variableSetId,
-    metadata: {
-      variableSetId: input.variableSetId,
-      ...input.variableName ? { name: input.variableName } : {}
-    }
-  });
+function preferredFikenConnection(connections) {
+  const statusRank = (status) => status === "active" ? 0 : status === "needs_reauth" ? 1 : 2;
+  return [...connections].sort(
+    (left, right) => statusRank(left.status) - statusRank(right.status) || right.updatedAt.localeCompare(left.updatedAt) || right.id.localeCompare(left.id)
+  )[0] ?? null;
 }
 
+// src/domain/capabilities.ts
+import { listSkillLibraryEntries } from "@opengeni/runtime/skill-library";
+
 // src/domain/packs.ts
 import { createHash } from "crypto";
 import {
@@ -1718,7 +1727,7 @@ import {
 import {
   getPackInstallation,
   getRig,
-  getVariableSet as getVariableSet2,
+  getVariableSet,
   getWorkspacePack,
   listPackInstallations,
   listWorkspacePacks,
@@ -1726,7 +1735,7 @@ import {
   resolvePackInlineSkillReferences
 } from "@opengeni/db";
 import { buildPortableSkillArtifact } from "@opengeni/runtime/skill-library";
-import { HTTPException as HTTPException5 } from "hono/http-exception";
+import { HTTPException as HTTPException3 } from "hono/http-exception";
 var MARKETING_SOCIAL_PACK_ID = "marketing-social-daily-analysis";
 var marketingSocialPack = {
   id: MARKETING_SOCIAL_PACK_ID,
@@ -1915,7 +1924,7 @@ function capabilityPackRequiresInstallationPlan(pack) {
 function inlinePackSkillInstall(pack, skill) {
   const artifact = buildPortableSkillArtifact(skill.files);
   if (artifact.name.toLowerCase() !== skill.name.toLowerCase()) {
-    throw new HTTPException5(422, {
+    throw new HTTPException3(422, {
       message: `Pack Skill ${skill.name} has SKILL.md name ${artifact.name}; the names must match`
     });
   }
@@ -1979,7 +1988,7 @@ async function previewCapabilityPackInstallation(db, workspaceId, pack, options
   if (pack.variableSet?.required && !variableSetId) {
     blockers.push("Choose saved configuration before installing this Pack");
   } else if (variableSetId) {
-    const variableSet = await getVariableSet2(db, workspaceId, variableSetId);
+    const variableSet = await getVariableSet(db, workspaceId, variableSetId);
     if (!variableSet) {
       blockers.push("The selected configuration no longer exists in this workspace");
     } else {
@@ -2094,7 +2103,7 @@ async function assertPackSandboxImageCompatible(db, workspaceId, pack) {
     }
     const other = await resolveCapabilityPack(db, workspaceId, installation.packId);
     if (other?.sandboxImage) {
-      throw new HTTPException5(409, {
+      throw new HTTPException3(409, {
         message: `pack ${pack.id} declares a sandbox image, but enabled pack ${other.id} already declares one; only one enabled pack per workspace may declare sandboxImage \u2014 disable ${other.id} first`
       });
     }
@@ -2159,7 +2168,9 @@ async function buildCapabilityCatalog(input) {
     packInstallations,
     workspacePacks,
     socialConnections,
+    workspaceConnections,
     curatedLibrarySkills,
+    installedSkills,
     codexAppsCredentialId
   ] = await Promise.all([
     listCapabilityCatalogItems(input.db, input.workspaceId),
@@ -2167,11 +2178,19 @@ async function buildCapabilityCatalog(input) {
     listPackInstallations2(input.db, input.workspaceId),
     listWorkspaceCapabilityPacks(input.db, input.workspaceId),
     listSocialConnections(input.db, input.workspaceId, 500, input.subjectId),
+    listConnectionsMetadata(input.db, input.workspaceId, null),
     discoverCuratedSkillLibraryItems(),
+    listInstalledSkills(input.db, input.workspaceId),
     input.settings.codexConnectedAppsEnabled ? resolveCodexAppsCredentialIdForRun(input.db, input.workspaceId) : Promise.resolve(null)
   ]);
+  const catalogInstallations = capabilityInstallations.filter(
+    (installation) => installation.kind === "mcp"
+  );
   const capabilityInstallationById = new Map(
-    capabilityInstallations.map((installation) => [installation.capabilityId, installation])
+    catalogInstallations.map((installation) => [installation.capabilityId, installation])
+  );
+  const installedSkillById = new Map(
+    installedSkills.filter((skill) => skill.owners.some((owner) => owner.kind === "direct")).map((skill) => [skill.capabilityId, skill])
   );
   const activePackIds = new Set(
     packInstallations.filter((installation) => installation.status === "active").map((installation) => installation.packId)
@@ -2183,66 +2202,54 @@ async function buildCapabilityCatalog(input) {
     ),
     ...configuredMcpCatalogItems(input.settings),
     ...providerIntegrationCatalogItems(socialConnections),
-    ...curatedLibrarySkills
+    fikenCatalogItem(workspaceConnections.filter(isFikenConnection)),
+    ...curatedLibrarySkills,
+    ...installedSkills.filter(
+      (skill) => skill.source !== "library" && skill.owners.some((owner) => owner.kind === "direct")
+    ).map(installedSkillCatalogItem)
   ];
   const codexApps = input.settings.codexConnectedAppsEnabled ? codexAppsCatalogItem(codexAppsCredentialId !== null) : null;
   const items = dedupeCatalogItems([
     ...builtIns,
-    ...persistedItems.filter((item) => !isReservedCodexAppsCatalogItem(item)),
+    ...persistedItems.filter(
+      (item) => item.kind !== "skill" && item.kind !== "api" && item.kind !== "plugin" && !isReservedCodexAppsCatalogItem(item)
+    ),
     // Keep the reserved, server-derived item authoritative over any stale
     // legacy catalog row with the same id.
     ...codexApps ? [codexApps] : []
   ]).map((item) => {
-    const runtimeItem = applyInstalledArtifactRuntime(item);
-    const projected = applyCapabilityEnablement(
-      runtimeItem,
-      capabilityInstallationById.get(runtimeItem.id),
-      activePackIds
-    );
+    const projected = item.kind === "skill" ? applyInstalledSkillEnablement(item, installedSkillById.get(item.id)) : applyCapabilityEnablement(item, capabilityInstallationById.get(item.id), activePackIds);
     return applyCapabilityLifecycle(projected);
   }).sort(compareCatalogItems);
   return {
     items,
-    installations: capabilityInstallations
-  };
-}
-function applyInstalledArtifactRuntime(item) {
-  if (item.kind === "api" && item.metadata.platformVersion === 2 && typeof item.metadata.pluginVersionId === "string" && typeof item.metadata.apiFacetId === "string" && typeof item.metadata.revisionId === "string" && typeof item.metadata.serverId === "string") {
-    return {
-      ...item,
-      runtime: {
-        available: true,
-        mcpServerId: item.metadata.serverId,
-        transport: "local-adapter",
-        notes: "Available through an immutable workspace API Integration revision."
-      }
-    };
-  }
-  if (item.kind !== "skill" || item.metadata.platformVersion !== 2 || typeof item.metadata.pluginVersionId !== "string" || typeof item.metadata.facetId !== "string" || typeof item.metadata.sourceCommit !== "string" || typeof item.metadata.contentSha256 !== "string") {
-    return item;
-  }
-  return {
-    ...item,
-    runtime: {
-      available: true,
-      notes: "Installed from an immutable workspace Skill artifact."
-    }
+    installations: catalogInstallations
   };
 }
 async function createCatalogItem(input) {
   const id = input.payload.id?.trim() || generatedCapabilityId(input.payload);
   if (id.startsWith("pack:")) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "packs are managed by OpenGeni and cannot be manually created"
     });
   }
   if (id.startsWith("skill:")) {
-    throw new HTTPException6(422, {
-      message: "skill ids are managed by the OpenGeni skill library or runtime adapters"
+    throw new HTTPException4(422, {
+      message: "Skills are installed through the Skill library or source import flow"
+    });
+  }
+  if (id.startsWith("api:")) {
+    throw new HTTPException4(422, {
+      message: "API Integrations are installed from typed Integration Definitions"
+    });
+  }
+  if (id.startsWith("plugin:")) {
+    throw new HTTPException4(422, {
+      message: "Plugins are installed through the Plugin Package flow"
     });
   }
   if (input.payload.kind === "mcp" && (id === `mcp:${CODEX_APPS_MCP_SERVER_ID}` || typeof input.payload.metadata.mcpServerId === "string" && input.payload.metadata.mcpServerId.trim() === CODEX_APPS_MCP_SERVER_ID)) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `${CODEX_APPS_MCP_SERVER_ID} is reserved for the canonical Codex Apps service`
     });
   }
@@ -2275,8 +2282,28 @@ async function enableCapability(input) {
     input.settings,
     input.capabilityId
   );
+  if (item.kind === "skill") {
+    throw new HTTPException4(409, {
+      message: "Install Skills through the Skill library or source import flow"
+    });
+  }
+  if (item.kind === "api") {
+    throw new HTTPException4(409, {
+      message: "Install API Integrations through the Integration Definitions flow"
+    });
+  }
+  if (item.kind === "plugin") {
+    throw new HTTPException4(409, {
+      message: "Install Plugins through the Plugin Package flow"
+    });
+  }
+  if (item.kind === "pack") {
+    throw new HTTPException4(409, {
+      message: "Install Packs through the Pack installation preview flow"
+    });
+  }
   if (item.kind === "mcp" && !item.runtime.available) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled"
     });
   }
@@ -2286,41 +2313,6 @@ async function enableCapability(input) {
   delete installationConfig.headersEncrypted;
   delete installationConfig.headerNames;
   delete installationConfig.connectionRef;
-  if (item.kind === "skill" && item.source === "library") {
-    const libraryId = stringMetadata(item.metadata.libraryId);
-    const catalogVersion = stringMetadata(item.metadata.version);
-    if (!libraryId || !catalogVersion) {
-      throw new HTTPException6(422, {
-        message: `skill library metadata is incomplete for ${item.id}`
-      });
-    }
-    const requestedVersion = input.payload.config.version;
-    if (requestedVersion !== void 0 && typeof requestedVersion !== "string") {
-      throw new HTTPException6(422, {
-        message: "skill activation config.version must be a string"
-      });
-    }
-    const normalizedVersion = requestedVersion?.trim() || catalogVersion;
-    if (normalizedVersion !== catalogVersion) {
-      throw new HTTPException6(422, {
-        message: `skill ${libraryId} only supports immutable version ${catalogVersion}`
-      });
-    }
-    const entry = getSkillLibraryEntry(libraryId, normalizedVersion);
-    if (!entry) {
-      throw new HTTPException6(422, {
-        message: `skill library entry is unavailable: ${libraryId}@${normalizedVersion}`
-      });
-    }
-    installationConfig = { version: entry.version };
-    installationMetadata = {
-      libraryId: entry.id,
-      libraryVersion: entry.version,
-      contentSha256: entry.contentSha256,
-      sourceCommit: entry.sourceCommit,
-      provenance: entry.provenance
-    };
-  }
   if (item.kind === "mcp") {
     const headers = await resolveMcpCredentialHeaders(input, item);
     const connectionRef = input.payload.connectionRef ? await validateMcpCapabilityConnectionRef(input, item, input.payload.connectionRef) : null;
@@ -2339,71 +2331,6 @@ async function enableCapability(input) {
       );
     }
   }
-  if (item.kind === "pack") {
-    const packId = packIdFromCapabilityId(item.id);
-    const pack = await resolveCapabilityPack(input.db, input.workspaceId, packId);
-    if (!pack) {
-      throw new HTTPException6(404, { message: "pack not found" });
-    }
-    if (capabilityPackRequiresInstallationPlan(pack)) {
-      throw new HTTPException6(409, {
-        message: "This Pack uses component or Rig requirements. Preview and install it through the Pack installation flow."
-      });
-    }
-    await assertPackSandboxImageCompatible(input.db, input.workspaceId, pack);
-    const existing = await getPackInstallation2(input.db, input.workspaceId, packId);
-    const storedVariableSetId2 = typeof existing?.metadata.variableSetId === "string" ? existing.metadata.variableSetId : typeof existing?.metadata.environmentId === "string" ? existing.metadata.environmentId : void 0;
-    const requestedVariableSetId = input.payload.variableSetId;
-    const variableSetId = requestedVariableSetId ?? storedVariableSetId2;
-    if (pack.variableSet?.required && !variableSetId) {
-      throw new HTTPException6(422, {
-        message: `pack ${packId} requires an variableSet attachment; pass variableSetId`
-      });
-    }
-    if (variableSetId) {
-      if (requestedVariableSetId) {
-        const variableSet = await validateVariableSetAttachment(
-          { settings: input.settings, db: input.db },
-          input.grant,
-          input.workspaceId,
-          requestedVariableSetId
-        );
-        const missing = (pack.variableSet?.requiredVariables ?? []).filter(
-          (name) => !variableSet.variables.some((variable) => variable.name === name)
-        );
-        if (missing.length > 0) {
-          throw new HTTPException6(422, {
-            message: `variable set is missing required variable(s): ${missing.join(", ")}`
-          });
-        }
-      } else {
-        const variableSet = await getVariableSet3(input.db, input.workspaceId, variableSetId);
-        if (!variableSet) {
-          throw new HTTPException6(422, {
-            message: `the stored variableSet attachment for pack ${packId} no longer exists; re-enable it with variableSetId`
-          });
-        }
-        const missing = (pack.variableSet?.requiredVariables ?? []).filter(
-          (name) => !variableSet.variables.some((variable) => variable.name === name)
-        );
-        if (missing.length > 0) {
-          throw new HTTPException6(422, {
-            message: `variable set is missing required variable(s): ${missing.join(", ")}`
-          });
-        }
-      }
-    }
-    await enablePackInstallation(input.db, {
-      accountId: input.accountId,
-      workspaceId: input.workspaceId,
-      packId,
-      metadata: {
-        ...input.payload.metadata,
-        packVersion: pack.version,
-        ...variableSetId ? { variableSetId } : {}
-      }
-    });
-  }
   return await enableCapabilityInstallation(input.db, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -2436,7 +2363,7 @@ async function resolveMcpCredentialHeaders(input, item) {
       ])
     );
   } catch {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `stored credential headers for "${item.name}" could not be decrypted; supply them again in the enable request "headers" field`
     });
   }
@@ -2447,31 +2374,31 @@ function normalizedMcpCredentialHeaders(headers) {
     return null;
   }
   if (entries.length > maxMcpCredentialHeaders) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `an MCP capability supports at most ${maxMcpCredentialHeaders} credential headers`
     });
   }
   const seen = /* @__PURE__ */ new Set();
   for (const [name, value] of entries) {
     if (!mcpCredentialHeaderName.test(name)) {
-      throw new HTTPException6(422, {
+      throw new HTTPException4(422, {
         message: `invalid credential header name: ${name}`
       });
     }
     const lower = name.toLowerCase();
     if (seen.has(lower)) {
-      throw new HTTPException6(422, {
+      throw new HTTPException4(422, {
         message: `duplicate credential header name: ${name}`
       });
     }
     seen.add(lower);
     if (value.length === 0 || value.length > maxMcpCredentialHeaderValueLength) {
-      throw new HTTPException6(422, {
+      throw new HTTPException4(422, {
         message: `credential header ${name} must be 1-${maxMcpCredentialHeaderValueLength} characters`
       });
     }
     if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
-      throw new HTTPException6(422, {
+      throw new HTTPException4(422, {
         message: `credential header ${name} contains forbidden control characters`
       });
     }
@@ -2482,7 +2409,7 @@ async function validateMcpCapabilityConnectionRef(input, item, ref) {
   const subjectScope = ref.subjectScope ?? "workspace";
   const personalOnly = item.metadata.connectionOwnership === "personal_only" || item.endpointUrl?.replace(/\/+$/, "") === officialGmailMcpUrl;
   if (personalOnly && subjectScope !== "subject") {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "this capability requires a personal connection; each workspace member must connect their own account"
     });
   }
@@ -2501,12 +2428,12 @@ async function validateMcpCapabilityConnectionRef(input, item, ref) {
     } : {}
   };
   if (!normalized.providerDomain) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "connectionRef.providerDomain is required"
     });
   }
   if (!item.endpointUrl || !item.runtime.mcpServerId) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "MCP capabilities need a remote streamable HTTP endpoint before they can use a connectionRef"
     });
   }
@@ -2527,27 +2454,27 @@ async function validateMcpCapabilityConnectionRef(input, item, ref) {
     ) ?? null;
   }
   if (!connection) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "connectionRef does not reference a visible active connection"
     });
   }
   if (subjectScope === "subject" && connection.subjectId !== input.grant.subjectId || subjectScope === "workspace" && connection.subjectId !== null) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `connectionRef does not reference a ${subjectScope}-owned connection`
     });
   }
   if (connection.status !== "active") {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `connectionRef.connectionId is not active (${connection.status})`
     });
   }
   if (connection.providerDomain !== normalized.providerDomain) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "connectionRef.providerDomain does not match the referenced connection"
     });
   }
   if (normalized.kind && connection.kind !== normalized.kind) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "connectionRef.kind does not match the referenced connection"
     });
   }
@@ -2574,12 +2501,12 @@ function assertRequiredMcpCredentialHeaders(item, headers, connectionRef) {
   const names = new Set(Object.keys(headers ?? {}).map((name) => name.toLowerCase()));
   const missing = required.filter((name) => !names.has(name.toLowerCase()));
   if (missing.length > 0) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `MCP capability "${item.name}" requires credential header(s) ${missing.join(", ")}; pass them in the enable request "headers" field`
     });
   }
   if (item.authModel && names.size === 0) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `MCP capability "${item.name}" requires credentials; pass them in the enable request "headers" field`
     });
   }
@@ -2592,9 +2519,9 @@ function requiredCapabilityHeaders(metadata) {
   return value.filter((name) => typeof name === "string" && name.trim().length > 0).map((name) => name.trim());
 }
 function requireCapabilityHeaderEncryption(settings) {
-  const key = environmentsEncryptionKeyBytes2(settings);
+  const key = environmentsEncryptionKeyBytes(settings);
   if (!key) {
-    throw new HTTPException6(503, {
+    throw new HTTPException4(503, {
       message: "MCP credential headers require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
     });
   }
@@ -2605,7 +2532,7 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
     return {};
   }
   if (!item.endpointUrl || !item.runtime.mcpServerId) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled"
     });
   }
@@ -2625,7 +2552,7 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
       }
     };
   } catch (error) {
-    throw new HTTPException6(422, {
+    throw new HTTPException4(422, {
       message: `MCP capability "${item.name}" could not be enabled because ${mcpProbeErrorMessage(error, item.endpointUrl)}`
     });
   }
@@ -2683,40 +2610,33 @@ async function disableCapability(input) {
     input.settings,
     input.capabilityId
   );
-  if ((item.source === "built_in" || item.source === "configured") && item.kind !== "pack") {
-    throw new HTTPException6(409, {
-      message: "built-in and configured capabilities are always available; remove them from configuration to disable them"
+  if (item.kind === "skill") {
+    throw new HTTPException4(409, {
+      message: "Uninstall Skills through the Skill uninstall preview flow"
+    });
+  }
+  if (item.kind === "api") {
+    throw new HTTPException4(409, {
+      message: "Remove API Integrations through the Integration instance flow"
+    });
+  }
+  if (item.kind === "plugin") {
+    throw new HTTPException4(409, {
+      message: "Remove Plugins through the Plugin Package flow"
     });
   }
   if (item.kind === "pack") {
-    const packInstallation = await getPackInstallation2(
-      input.db,
-      input.workspaceId,
-      packIdFromCapabilityId(item.id)
-    );
-    if (packInstallation && (packInstallation.manifestDigest !== null || packInstallation.manifestSnapshot !== null)) {
-      throw new HTTPException6(409, {
-        message: "This Pack owns explicit components. Uninstall it through the Pack uninstall preview flow."
-      });
-    }
-    await updatePackInstallationStatus(
-      input.db,
-      input.workspaceId,
-      packIdFromCapabilityId(item.id),
-      "disabled"
-    ).catch(() => void 0);
-    if (!await getCapabilityInstallation(input.db, input.workspaceId, item.id)) {
-      await enableCapabilityInstallation(input.db, {
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        capabilityId: item.id,
-        kind: "pack",
-        metadata: {},
-        config: {}
-      });
-    }
-  } else if (!await getCapabilityInstallation(input.db, input.workspaceId, item.id)) {
-    throw new HTTPException6(409, {
+    throw new HTTPException4(409, {
+      message: "Uninstall Packs through the Pack uninstall preview flow"
+    });
+  }
+  if (item.source === "built_in" || item.source === "configured") {
+    throw new HTTPException4(409, {
+      message: "built-in and configured capabilities are always available; remove them from configuration to disable them"
+    });
+  }
+  if (!await getCapabilityInstallation(input.db, input.workspaceId, item.id)) {
+    throw new HTTPException4(409, {
       message: "capability is not currently enabled"
     });
   }
@@ -2836,7 +2756,7 @@ function settingsWithMcpCapabilityServers(settings, enabled) {
   if (enabled.length === 0) {
     return settings;
   }
-  const encryptionKey = environmentsEncryptionKeyBytes2(settings);
+  const encryptionKey = environmentsEncryptionKeyBytes(settings);
   const existingIds = new Set(settings.mcpServers.map((server) => server.id));
   const dynamicServers = enabled.filter((server) => !existingIds.has(server.id)).flatMap((server) => {
     const headers = decryptedCapabilityHeaders(server, encryptionKey);
@@ -2916,21 +2836,21 @@ async function fetchMcpRegistryPage(url, options = {}) {
   try {
     const response = await fetchImpl(url, { signal: controller.signal });
     if (!response.ok) {
-      throw new HTTPException6(502, {
+      throw new HTTPException4(502, {
         message: `MCP registry returned ${response.status}`
       });
     }
     return await response.json();
   } catch (error) {
-    if (error instanceof HTTPException6) {
+    if (error instanceof HTTPException4) {
       throw error;
     }
     if (error instanceof Error && error.name === "AbortError") {
-      throw new HTTPException6(504, {
+      throw new HTTPException4(504, {
         message: "MCP registry request timed out"
       });
     }
-    throw new HTTPException6(502, {
+    throw new HTTPException4(502, {
       message: `MCP registry request failed: ${error instanceof Error ? error.message : String(error)}`
     });
   } finally {
@@ -2941,7 +2861,7 @@ async function requireCatalogItem(db, workspaceId, settings, capabilityId) {
   const catalog = await buildCapabilityCatalog({ db, workspaceId, settings });
   const item = catalog.items.find((candidate) => candidate.id === capabilityId) ?? await getCapabilityCatalogItem(db, workspaceId, capabilityId);
   if (!item) {
-    throw new HTTPException6(404, { message: "capability not found" });
+    throw new HTTPException4(404, { message: "capability not found" });
   }
   return item;
 }
@@ -3083,6 +3003,39 @@ var SOCIAL_PROVIDER_TOOL_NAMES = {
     "reddit_post_reply"
   ]
 };
+function fikenCatalogItem(fikenConnections) {
+  const fikenConnection = preferredFikenConnection(fikenConnections);
+  const fikenEnabled = fikenConnection?.status === "active" || fikenConnection?.status === "needs_reauth";
+  return CapabilityCatalogItem.parse({
+    id: "api:fiken",
+    kind: "api",
+    source: "built_in",
+    name: "Fiken",
+    description: "Connect Fiken accounting for contacts, products, invoices, invoice drafts, purchases, sales, and bank accounts.",
+    category: "finance",
+    tags: ["api", "fiken", "accounting", "invoicing", "norway"],
+    homepageUrl: "https://fiken.no",
+    authModel: "personal_api_token",
+    providerDomain: FIKEN_PROVIDER_DOMAIN2,
+    surfaceType: "first_party_fiken",
+    authKind: "api_key",
+    tools: [{ kind: "mcp", id: "opengeni" }],
+    runtime: {
+      available: true,
+      mcpServerId: "opengeni",
+      notes: "Fiken access is provided through OpenGeni's first-party fiken tools."
+    },
+    enabled: fikenEnabled,
+    enabledReason: fikenEnabled ? fikenConnection.status === "active" ? "workspace Fiken connection active" : "workspace Fiken connection needs reconnection" : null,
+    metadata: {
+      connectorMode: "first_party_fiken",
+      ownership: "workspace",
+      // 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_"))
+    }
+  });
+}
 function providerIntegrationCatalogItems(socialConnections) {
   return SOCIAL_PROVIDER_INTEGRATIONS.map((definition) => {
     const counts = socialConnectionCounts(socialConnections, definition.provider);
@@ -3212,6 +3165,51 @@ function curatedSkillCatalogItem(entry) {
     }
   });
 }
+function installedSkillCatalogItem(skill) {
+  return CapabilityCatalogItem.parse({
+    id: skill.capabilityId,
+    kind: "skill",
+    source: skill.source === "library" ? "library" : "manual",
+    name: skill.name,
+    description: skill.description,
+    category: skill.category,
+    tags: skill.tags,
+    homepageUrl: skill.repositoryUrl,
+    installUrl: skill.sourceUrl,
+    provenance: skill.provenance,
+    tier: skill.source === "library" ? "verified" : "community",
+    runtime: {
+      available: true,
+      notes: "Available from an immutable Skill installation."
+    },
+    metadata: {
+      version: skill.version,
+      contentSha256: skill.contentSha256,
+      sourceCommit: skill.sourceCommit,
+      sourcePath: skill.sourcePath,
+      sourceUrl: skill.sourceUrl,
+      repositoryUrl: skill.repositoryUrl,
+      provenance: skill.provenance,
+      license: skill.license,
+      installedSkill: installedSkillMetadata(skill)
+    }
+  });
+}
+function installedSkillMetadata(skill) {
+  return {
+    pluginKey: skill.pluginKey,
+    installationVersion: skill.installationVersion,
+    source: skill.source,
+    version: skill.version,
+    sourceCommit: skill.sourceCommit,
+    contentSha256: skill.contentSha256,
+    fileCount: skill.fileCount,
+    totalBytes: skill.totalBytes,
+    installedAt: skill.installedAt,
+    updatedAt: skill.updatedAt,
+    owners: skill.owners.map((owner) => ({ ...owner }))
+  };
+}
 function stringMetadata(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -3233,8 +3231,11 @@ function socialProviderConnectionCounts(item) {
   };
 }
 function applyCapabilityEnablement(item, installation, activePackIds) {
+  if (item.kind === "skill" || item.kind === "api" || item.kind === "plugin") {
+    return { ...item, enabled: false, enabledReason: null, connectionRef: null };
+  }
   if (item.kind === "pack") {
-    const enabled2 = activePackIds.has(packIdFromCapabilityId(item.id)) || installation?.status === "active";
+    const enabled2 = activePackIds.has(packIdFromCapabilityId(item.id));
     return {
       ...item,
       enabled: enabled2,
@@ -3244,6 +3245,9 @@ function applyCapabilityEnablement(item, installation, activePackIds) {
   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 };
   }
@@ -3258,33 +3262,8 @@ function applyCapabilityEnablement(item, installation, activePackIds) {
   if (item.source === "built_in") {
     return { ...item, connectionRef: null };
   }
-  if (item.source === "library") {
-    const enabled2 = installation?.status === "active" && skillLibraryInstallationRuntimeReady(item, installation);
-    return {
-      ...item,
-      enabled: enabled2,
-      enabledReason: enabled2 ? "explicitly selected" : null,
-      connectionRef: null
-    };
-  }
   const activeInstallation = installation?.status === "active";
   const enabled = !!activeInstallation && capabilityInstallationRuntimeReady(item, installation);
-  if (item.kind === "api" && item.metadata.platformVersion === 2) {
-    const connectionBound = installation?.metadata.connectionBound === true;
-    const providerDomain = stringMetadata(installation?.metadata.providerDomain);
-    const connectionKind = stringMetadata(installation?.metadata.connectionKind);
-    const connectionOwnership = stringMetadata(installation?.metadata.connectionOwnership);
-    return {
-      ...item,
-      enabled,
-      enabledReason: enabled ? "installed immutable Integration revision" : null,
-      connectionRef: enabled && connectionBound && providerDomain && connectionKind ? {
-        providerDomain,
-        kind: connectionKind,
-        ...connectionOwnership === "subject" ? { subjectScope: "subject" } : {}
-      } : null
-    };
-  }
   return {
     ...item,
     enabled,
@@ -3357,23 +3336,23 @@ function applyCapabilityLifecycle(item) {
     actions
   };
 }
-function skillLibraryInstallationRuntimeReady(item, installation) {
-  if (item.kind !== "skill" || item.source !== "library" || installation.kind !== "skill") {
-    return false;
-  }
-  const libraryId = stringMetadata(item.metadata.libraryId);
-  const version = stringMetadata(item.metadata.version);
-  const contentSha256 = stringMetadata(item.metadata.contentSha256);
-  const sourceCommit = stringMetadata(item.metadata.sourceCommit);
-  const provenance = stringMetadata(item.metadata.provenance);
-  if (!libraryId || !version || !contentSha256 || !sourceCommit || !provenance) {
-    return false;
+function applyInstalledSkillEnablement(item, installation) {
+  if (!installation) {
+    return { ...item, enabled: false, enabledReason: null, connectionRef: null };
   }
-  const entry = getSkillLibraryEntry(libraryId, version);
-  if (!entry || item.id !== `skill:${entry.id}` || installation.capabilityId !== `skill:${entry.id}` || contentSha256 !== entry.contentSha256 || sourceCommit !== entry.sourceCommit || provenance !== entry.provenance) {
-    return false;
-  }
-  return installation.config.version === entry.version && stringMetadata(installation.metadata.libraryId) === entry.id && stringMetadata(installation.metadata.libraryVersion) === entry.version && stringMetadata(installation.metadata.contentSha256) === entry.contentSha256 && stringMetadata(installation.metadata.sourceCommit) === entry.sourceCommit && stringMetadata(installation.metadata.provenance) === entry.provenance;
+  const catalogVersion = stringMetadata(item.metadata.version);
+  const current = catalogVersion === null || catalogVersion === installation.version && stringMetadata(item.metadata.contentSha256) === installation.contentSha256 && stringMetadata(item.metadata.sourceCommit) === installation.sourceCommit;
+  return {
+    ...item,
+    enabled: true,
+    enabledReason: current ? "explicitly installed" : `version ${installation.version} installed; update available`,
+    connectionRef: null,
+    metadata: {
+      ...item.metadata,
+      installedSkill: installedSkillMetadata(installation),
+      updateAvailable: !current
+    }
+  };
 }
 function installationConnectionRef(config) {
   const ref = config.connectionRef;
@@ -3611,7 +3590,7 @@ import {
   PORTABLE_SKILL_MAX_FILES,
   PORTABLE_SKILL_MAX_TOTAL_BYTES
 } from "@opengeni/runtime/skill-library";
-import { HTTPException as HTTPException7 } from "hono/http-exception";
+import { HTTPException as HTTPException5 } from "hono/http-exception";
 var githubSegment = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,98}[A-Za-z0-9])?$/u;
 var gitCommit = /^[0-9a-f]{40,64}$/u;
 var maxConcurrentBlobReads = 8;
@@ -3619,19 +3598,19 @@ async function resolveSkillImport(rawUrl, client) {
   const parsed = parseSkillSource(rawUrl);
   const sourceCommit = await client.resolveCommit(parsed.owner, parsed.repository, parsed.ref);
   if (!gitCommit.test(sourceCommit)) {
-    throw new HTTPException7(422, { message: "GitHub returned an invalid source commit" });
+    throw new HTTPException5(422, { message: "GitHub returned an invalid source commit" });
   }
   const tree = await client.listTree(parsed.owner, parsed.repository, sourceCommit);
   const sourcePath = selectSkillRoot(parsed, tree);
   const entries = skillFilesUnderRoot(tree, sourcePath);
   const declaredBytes = entries.reduce((sum, entry) => sum + (entry.size ?? 0), 0);
   if (entries.length > PORTABLE_SKILL_MAX_FILES) {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: `Skill contains more than ${PORTABLE_SKILL_MAX_FILES} files`
     });
   }
   if (declaredBytes > PORTABLE_SKILL_MAX_TOTAL_BYTES) {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: `Skill exceeds ${PORTABLE_SKILL_MAX_TOTAL_BYTES} bytes`
     });
   }
@@ -3642,7 +3621,7 @@ async function resolveSkillImport(rawUrl, client) {
         await client.readBlob(parsed.owner, parsed.repository, entry.sha)
       );
     } catch {
-      throw new HTTPException7(422, {
+      throw new HTTPException5(422, {
         message: `Skill file is not valid UTF-8 text: ${relativeSkillPath(entry.path, sourcePath)}`
       });
     }
@@ -3652,7 +3631,7 @@ async function resolveSkillImport(rawUrl, client) {
   try {
     artifact = buildPortableSkillArtifact2(files);
   } catch (error) {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: error instanceof Error ? error.message : "Skill artifact is invalid"
     });
   }
@@ -3709,24 +3688,24 @@ function parseSkillSource(rawUrl) {
   try {
     url = new URL(rawUrl);
   } catch {
-    throw new HTTPException7(422, { message: "Enter a valid GitHub or skills.sh URL" });
+    throw new HTTPException5(422, { message: "Enter a valid GitHub or skills.sh URL" });
   }
   if (url.protocol !== "https:" || url.username || url.password || url.hash) {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: "Skill imports require a credential-free HTTPS URL without a fragment"
     });
   }
   const segments = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
   if (url.hostname === "skills.sh" || url.hostname === "www.skills.sh") {
     if (segments.length !== 3) {
-      throw new HTTPException7(422, {
+      throw new HTTPException5(422, {
         message: "A skills.sh URL must identify one owner, repository, and Skill"
       });
     }
     const [owner2, repository2, skillSlug] = segments;
     assertGitHubRepository(owner2, repository2);
     if (!skillSlug || !githubSegment.test(skillSlug)) {
-      throw new HTTPException7(422, { message: "The skills.sh Skill name is invalid" });
+      throw new HTTPException5(422, { message: "The skills.sh Skill name is invalid" });
     }
     return {
       source: "skills_sh",
@@ -3739,12 +3718,12 @@ function parseSkillSource(rawUrl) {
     };
   }
   if (url.hostname !== "github.com" && url.hostname !== "www.github.com") {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: "Only github.com and skills.sh imports are supported"
     });
   }
   if (segments.length < 2) {
-    throw new HTTPException7(422, { message: "A GitHub URL must identify a repository" });
+    throw new HTTPException5(422, { message: "A GitHub URL must identify a repository" });
   }
   const owner = segments[0];
   const repository = stripGitSuffix(segments[1]);
@@ -3762,15 +3741,15 @@ function parseSkillSource(rawUrl) {
   }
   const mode = segments[2];
   if (mode !== "tree" && mode !== "blob") {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: "Use a GitHub repository, tree, folder, or SKILL.md URL"
     });
   }
   const ref = segments[3];
-  if (!ref) throw new HTTPException7(422, { message: "The GitHub URL is missing a revision" });
+  if (!ref) throw new HTTPException5(422, { message: "The GitHub URL is missing a revision" });
   const pathSegments = segments.slice(4);
   if (pathSegments.length === 0) {
-    throw new HTTPException7(422, { message: "The GitHub URL is missing a Skill folder" });
+    throw new HTTPException5(422, { message: "The GitHub URL is missing a Skill folder" });
   }
   const requestedPath = normalizeGitHubPath(
     mode === "blob" && pathSegments.at(-1)?.toLowerCase() === "skill.md" ? pathSegments.slice(0, -1) : pathSegments
@@ -3792,7 +3771,7 @@ function selectSkillRoot(source, tree) {
   if (source.requestedPath) {
     const root = source.requestedPath;
     if (!skillFiles.includes(root)) {
-      throw new HTTPException7(422, {
+      throw new HTTPException5(422, {
         message: `No top-level SKILL.md was found in ${root}`
       });
     }
@@ -3800,10 +3779,10 @@ function selectSkillRoot(source, tree) {
   }
   const candidates = source.skillSlug ? skillFiles.filter((path) => path.split("/").at(-1) === source.skillSlug) : skillFiles;
   if (candidates.length === 0) {
-    throw new HTTPException7(422, { message: "No Skill folder with SKILL.md was found" });
+    throw new HTTPException5(422, { message: "No Skill folder with SKILL.md was found" });
   }
   if (candidates.length > 1) {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: "This source contains multiple Skills; paste the exact GitHub folder URL"
     });
   }
@@ -3816,13 +3795,13 @@ function skillFilesUnderRoot(tree, root) {
     (entry) => entry.type === "commit" || entry.type === "blob" && entry.mode === "120000"
   );
   if (unsupported) {
-    throw new HTTPException7(422, {
+    throw new HTTPException5(422, {
       message: `Skill folders may not contain symbolic links or submodules (${unsupported.path})`
     });
   }
   const files = inside.filter((entry) => entry.type === "blob").sort((left, right) => left.path.localeCompare(right.path));
   if (files.length === 0) {
-    throw new HTTPException7(422, { message: "The selected Skill folder is empty" });
+    throw new HTTPException5(422, { message: "The selected Skill folder is empty" });
   }
   return files;
 }
@@ -3833,7 +3812,7 @@ function normalizeGitHubPath(segments) {
   if (segments.length === 0 || segments.some(
     (segment) => segment.length === 0 || segment === "." || segment === ".." || segment.includes("\\") || /[\u0000-\u001f\u007f]/u.test(segment)
   )) {
-    throw new HTTPException7(422, { message: "The GitHub Skill path is invalid" });
+    throw new HTTPException5(422, { message: "The GitHub Skill path is invalid" });
   }
   return segments.join("/");
 }
@@ -3845,7 +3824,7 @@ function stripGitSuffix(value) {
 }
 function assertGitHubRepository(owner, repository) {
   if (!githubSegment.test(owner) || !githubSegment.test(stripGitSuffix(repository))) {
-    throw new HTTPException7(422, { message: "The GitHub owner or repository name is invalid" });
+    throw new HTTPException5(422, { message: "The GitHub owner or repository name is invalid" });
   }
 }
 async function mapConcurrent(values, concurrency, map) {
@@ -3867,6 +3846,93 @@ function sha256Hex2(bytes) {
   return createHash2("sha256").update(bytes).digest("hex");
 }
 
+// src/domain/environments.ts
+import { environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes2 } from "@opengeni/config";
+import { getVariableSet as getVariableSet2, recordAuditEvent } from "@opengeni/db";
+import { HTTPException as HTTPException6 } from "hono/http-exception";
+var MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
+var MAX_VARIABLES_PER_ENVIRONMENT = 100;
+var reservedExactNames = /* @__PURE__ */ new Set([
+  "HOME",
+  "PATH",
+  "SHELL",
+  "USER",
+  "LOGNAME",
+  "TMPDIR",
+  "IFS",
+  "ENV",
+  "BASH_ENV",
+  "NODE_OPTIONS",
+  "PYTHONPATH",
+  "PYTHONSTARTUP",
+  "PERL5OPT",
+  "PERL5LIB",
+  "GH_TOKEN",
+  "GITHUB_TOKEN",
+  "GITLAB_TOKEN",
+  "AZURE_DEVOPS_EXT_PAT",
+  "GIT_ASKPASS",
+  "GIT_TERMINAL_PROMPT"
+]);
+var reservedPrefixes = [
+  "OPENGENI_",
+  "GIT_CONFIG_",
+  "GIT_AUTHOR_",
+  "GIT_COMMITTER_",
+  "LD_",
+  "DYLD_"
+];
+function assertAllowedVariableSetVariableName(name) {
+  if (reservedExactNames.has(name) || reservedPrefixes.some((prefix) => name.startsWith(prefix))) {
+    throw new HTTPException6(422, {
+      message: `reserved variable set variable name / reserved environment variable name: ${name}`
+    });
+  }
+}
+var assertAllowedEnvironmentVariableName = assertAllowedVariableSetVariableName;
+function requireVariableSetEncryption(settings) {
+  const key = environmentsEncryptionKeyBytes2(settings);
+  if (!key) {
+    throw new HTTPException6(503, {
+      message: "variable sets require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
+    });
+  }
+  return key;
+}
+var requireEnvironmentEncryption = requireVariableSetEncryption;
+async function requireVariableSetForApi(db, workspaceId, variableSetId) {
+  const variableSet = await getVariableSet2(db, workspaceId, variableSetId);
+  if (!variableSet) {
+    throw new HTTPException6(404, { message: "variableSet not found" });
+  }
+  return variableSet;
+}
+async function validateVariableSetAttachment(deps, grant, workspaceId, variableSetId, options = {}) {
+  requireVariableSetEncryption(deps.settings);
+  if (!options.preauthorized) {
+    requirePermission(grant, "variable-sets:use");
+  }
+  const variableSet = await getVariableSet2(deps.db, workspaceId, variableSetId);
+  if (!variableSet) {
+    throw new HTTPException6(422, { message: "unknown variableSetId" });
+  }
+  return variableSet;
+}
+async function recordVariableSetAuditEvent(db, input) {
+  await recordAuditEvent(db, {
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    subjectId: input.grant.subjectId,
+    action: input.action,
+    targetType: "workspace_variable_set",
+    targetId: input.variableSetId,
+    metadata: {
+      variableSetId: input.variableSetId,
+      ...input.variableName ? { name: input.variableName } : {}
+    }
+  });
+}
+
 // src/rigs/index.ts
 import {
   activateRigVersion,
@@ -3880,7 +3946,7 @@ import {
   getRigByName,
   getRigChange,
   getRigVersion,
-  getVariableSet as getVariableSet4,
+  getVariableSet as getVariableSet3,
   listRigChanges,
   listRigVersions,
   recordAuditEvent as recordAuditEvent2,
@@ -3888,7 +3954,7 @@ import {
   RigChangeTransitionError,
   updateRig
 } from "@opengeni/db";
-import { HTTPException as HTTPException8 } from "hono/http-exception";
+import { HTTPException as HTTPException7 } from "hono/http-exception";
 
 // src/rigs/provider-images.ts
 import { createHash as createHash3 } from "crypto";
@@ -3962,21 +4028,21 @@ function rigActorForGrant(grant) {
 async function requireRigForApi(db, workspaceId, rigId) {
   const rig = await getRig2(db, workspaceId, rigId);
   if (!rig) {
-    throw new HTTPException8(404, { message: "rig not found" });
+    throw new HTTPException7(404, { message: "rig not found" });
   }
   return rig;
 }
 async function requireRigChangeForApi(db, workspaceId, rigId, changeId) {
   const change = await getRigChange(db, workspaceId, changeId);
   if (!change || change.rigId !== rigId) {
-    throw new HTTPException8(404, { message: "rig change not found" });
+    throw new HTTPException7(404, { message: "rig change not found" });
   }
   return change;
 }
 function trimmedRigName(name) {
   const trimmed = name.trim();
   if (!trimmed) {
-    throw new HTTPException8(422, { message: "rig name is required" });
+    throw new HTTPException7(422, { message: "rig name is required" });
   }
   return trimmed;
 }
@@ -3987,7 +4053,7 @@ function assertUniqueCheckNames(checks) {
   const seen = /* @__PURE__ */ new Set();
   for (const check of checks) {
     if (seen.has(check.name)) {
-      throw new HTTPException8(422, { message: `duplicate rig check name: ${check.name}` });
+      throw new HTTPException7(422, { message: `duplicate rig check name: ${check.name}` });
     }
     seen.add(check.name);
   }
@@ -3998,9 +4064,9 @@ async function assertVariableSetsExist(db, workspaceId, ids) {
   }
   const unique = [...new Set(ids)];
   for (const id of unique) {
-    const variableSet = await getVariableSet4(db, workspaceId, id);
+    const variableSet = await getVariableSet3(db, workspaceId, id);
     if (!variableSet) {
-      throw new HTTPException8(422, { message: `unknown defaultVariableSetId: ${id}` });
+      throw new HTTPException7(422, { message: `unknown defaultVariableSetId: ${id}` });
     }
   }
 }
@@ -4010,12 +4076,12 @@ async function createRigForApi(deps, grant, payload) {
   assertUniqueCheckNames(payload.checks);
   await assertVariableSetsExist(deps.db, workspaceId, payload.defaultVariableSetIds);
   if (await countRigs(deps.db, workspaceId) >= MAX_RIGS_PER_WORKSPACE) {
-    throw new HTTPException8(422, {
+    throw new HTTPException7(422, {
       message: `a workspace supports at most ${MAX_RIGS_PER_WORKSPACE} rigs`
     });
   }
   if (await getRigByName(deps.db, workspaceId, name)) {
-    throw new HTTPException8(409, { message: `rig name is already in use: ${name}` });
+    throw new HTTPException7(409, { message: `rig name is already in use: ${name}` });
   }
   const createdBy = rigActorForGrant(grant);
   const rig = await createRig(deps.db, {
@@ -4043,7 +4109,7 @@ async function updateRigForApi(deps, grant, rig, payload) {
   if (name !== void 0 && name !== rig.name) {
     const existing = await getRigByName(deps.db, workspaceId, name);
     if (existing && existing.id !== rig.id) {
-      throw new HTTPException8(409, { message: `rig name is already in use: ${name}` });
+      throw new HTTPException7(409, { message: `rig name is already in use: ${name}` });
     }
   }
   const updated = await updateRig(deps.db, workspaceId, rig.id, {
@@ -4057,19 +4123,19 @@ async function deleteRigForApi(deps, grant, rig) {
   const workspaceId = grant.workspaceId;
   const deleted = await deleteRigIfNoActiveSessions(deps.db, workspaceId, rig.id);
   if (deleted.activeSessionCount > 0) {
-    throw new HTTPException8(409, {
+    throw new HTTPException7(409, {
       message: `rig is referenced by ${deleted.activeSessionCount} active session(s); it cannot be deleted`
     });
   }
   if (!deleted.deleted) {
-    throw new HTTPException8(404, { message: "rig not found" });
+    throw new HTTPException7(404, { message: "rig not found" });
   }
   await recordRigAuditEvent(deps.db, { grant, action: "rig.deleted", rigId: rig.id });
 }
 async function proposeRigChangeForApi(deps, grant, rig, request, options = {}) {
   const workspaceId = grant.workspaceId;
   if (!rig.activeVersion) {
-    throw new HTTPException8(422, { message: "rig has no active version to base a change on" });
+    throw new HTTPException7(422, { message: "rig has no active version to base a change on" });
   }
   if (request.kind === "definition_edit") {
     assertUniqueCheckNames(request.payload.checks);
@@ -4118,35 +4184,35 @@ async function promoteChangeWithActiveCas(deps, workspaceId, rigId, changeId, in
     return await createRigVersionForChangePromotion(deps.db, workspaceId, rigId, changeId, input);
   } catch (error) {
     if (error instanceof RigActiveVersionChangedError) {
-      throw new HTTPException8(409, {
+      throw new HTTPException7(409, {
         message: `rig moved since this change was verified (base ${error.expectedVersionId}, now ${error.actualVersionId ?? "none"}); re-verify before promoting`
       });
     }
     if (error instanceof RigChangeTransitionError) {
-      throw new HTTPException8(409, { message: error.message });
+      throw new HTTPException7(409, { message: error.message });
     }
     throw error;
   }
 }
 async function promoteSetupAppendChange(deps, grant, rig, change) {
   if (change.kind !== "setup_append") {
-    throw new HTTPException8(422, {
+    throw new HTTPException7(422, {
       message: "only setup_append changes auto-promote through this path"
     });
   }
   if (change.status !== "proposed" && change.status !== "verifying") {
-    throw new HTTPException8(409, { message: `rig change is ${change.status}; cannot promote` });
+    throw new HTTPException7(409, { message: `rig change is ${change.status}; cannot promote` });
   }
   if (!change.baseVersionId) {
-    throw new HTTPException8(422, { message: "rig change has no base version" });
+    throw new HTTPException7(422, { message: "rig change has no base version" });
   }
   const base = await getRigVersion(deps.db, grant.workspaceId, rig.id, change.baseVersionId);
   if (!base) {
-    throw new HTTPException8(404, { message: "base rig version not found" });
+    throw new HTTPException7(404, { message: "base rig version not found" });
   }
   const payload = change.payload;
   if (typeof payload.command !== "string" || !payload.command.trim()) {
-    throw new HTTPException8(422, { message: "setup_append change is missing command" });
+    throw new HTTPException7(422, { message: "setup_append change is missing command" });
   }
   const nextDefinition = {
     image: base.image,
@@ -4184,22 +4250,22 @@ async function promoteSetupAppendChange(deps, grant, rig, change) {
 }
 async function promoteVerifiedDefinitionEditChangeForApi(deps, grant, rig, change) {
   if (change.kind !== "definition_edit") {
-    throw new HTTPException8(422, { message: "only definition_edit changes use explicit promote" });
+    throw new HTTPException7(422, { message: "only definition_edit changes use explicit promote" });
   }
   if (change.status !== "proposed") {
-    throw new HTTPException8(409, { message: `rig change is ${change.status}; cannot promote` });
+    throw new HTTPException7(409, { message: `rig change is ${change.status}; cannot promote` });
   }
   if (change.verification?.passed !== true) {
-    throw new HTTPException8(422, {
+    throw new HTTPException7(422, {
       message: "definition_edit change must pass verification before promote"
     });
   }
   if (!change.baseVersionId) {
-    throw new HTTPException8(422, { message: "rig change has no base version" });
+    throw new HTTPException7(422, { message: "rig change has no base version" });
   }
   const base = await getRigVersion(deps.db, grant.workspaceId, rig.id, change.baseVersionId);
   if (!base) {
-    throw new HTTPException8(404, { message: "base rig version not found" });
+    throw new HTTPException7(404, { message: "base rig version not found" });
   }
   const payload = change.payload;
   const nextDefinition = {
@@ -4238,7 +4304,7 @@ async function promoteVerifiedDefinitionEditChangeForApi(deps, grant, rig, chang
 }
 async function createRigVersionForApi(deps, grant, rig, payload) {
   if (!rig.activeVersion) {
-    throw new HTTPException8(422, { message: "rig has no active version" });
+    throw new HTTPException7(422, { message: "rig has no active version" });
   }
   assertUniqueCheckNames(payload.checks);
   await assertVariableSetsExist(
@@ -4594,13 +4660,13 @@ import {
   stableJson as stableJson3
 } from "@opengeni/contracts";
 import { areGitHubRepositoriesAllowedForWorkspace, requireFile } from "@opengeni/db";
-import { HTTPException as HTTPException9 } from "hono/http-exception";
+import { HTTPException as HTTPException8 } from "hono/http-exception";
 function validateToolRefs(tools, settings) {
   const mcpServerIds = new Set(settings.mcpServers.map((server) => server.id));
   const out = [];
   for (const tool of tools) {
     if (tool.kind !== "mcp") {
-      throw new HTTPException9(422, {
+      throw new HTTPException8(422, {
         message: `unsupported tool kind: ${tool.kind}`
       });
     }
@@ -4609,7 +4675,7 @@ function validateToolRefs(tools, settings) {
       if (optional) {
         continue;
       }
-      throw new HTTPException9(422, { message: `unknown MCP server id: ${tool.id}` });
+      throw new HTTPException8(422, { message: `unknown MCP server id: ${tool.id}` });
     }
     out.push(
       optional ? { kind: "mcp", id: tool.id, optional: true } : { kind: "mcp", id: tool.id }
@@ -4632,7 +4698,7 @@ function assertToolRefsSubset(requested, allowed, message = "requested tools exc
   const allowedIds = new Set(allowed.map((tool) => `${tool.kind}:${tool.id}`));
   const widened = requested.find((tool) => !allowedIds.has(`${tool.kind}:${tool.id}`));
   if (widened) {
-    throw new HTTPException9(403, { message: `${message}: ${widened.id}` });
+    throw new HTTPException8(403, { message: `${message}: ${widened.id}` });
   }
 }
 function validateToolRefsForSessionPolicy(input) {
@@ -4661,7 +4727,7 @@ function normalizeResources(resources) {
       try {
         normalizedUri = normalizeRepositoryTransportUri(resource.uri);
       } catch (error) {
-        throw new HTTPException9(422, {
+        throw new HTTPException8(422, {
           message: error instanceof Error ? error.message : "invalid repository URI"
         });
       }
@@ -4670,14 +4736,14 @@ function normalizeResources(resources) {
       );
       const credentialBindingId = gitCredentialBindingIdForRepository(resource, credentialProvider);
       if ((resource.credentialBindingId || resource.connectionId || resource.access) && !credentialProvider) {
-        throw new HTTPException9(422, {
+        throw new HTTPException8(422, {
           message: "repository credential bindings and access intent require a Git provider"
         });
       }
       if (credentialProvider && credentialBindingId) {
         const boundProvider = credentialBindingProviders.get(credentialBindingId);
         if (boundProvider && boundProvider !== credentialProvider) {
-          throw new HTTPException9(422, {
+          throw new HTTPException8(422, {
             message: `credential binding ${credentialBindingId} is assigned to multiple Git providers`
           });
         }
@@ -4704,7 +4770,7 @@ function normalizeResources(resources) {
     const mountCollisionKey = normalized.mountPath ? resourceMountPathCollisionKey(normalized.mountPath) : void 0;
     const mounted = mountCollisionKey ? mountPaths.get(mountCollisionKey) : void 0;
     if (mounted && mounted !== key) {
-      throw new HTTPException9(422, {
+      throw new HTTPException8(422, {
         message: `duplicate resource mount path: ${normalized.mountPath}`
       });
     }
@@ -4714,7 +4780,7 @@ function normalizeResources(resources) {
     const identity = resourceIdentityKey(normalized);
     const seenIdentity = identities.get(identity);
     if (seenIdentity && seenIdentity !== key) {
-      throw new HTTPException9(422, {
+      throw new HTTPException8(422, {
         message: `duplicate resource with different settings: ${identity}`
       });
     }
@@ -4731,7 +4797,7 @@ function mergeResourceRefs(existing, additions) {
     return mergeContractResourceRefs(existing, additions, { rejectConflicts: true });
   } catch (error) {
     if (error instanceof ResourceRefConflictError) {
-      throw new HTTPException9(422, { message: error.message });
+      throw new HTTPException8(422, { message: error.message });
     }
     throw error;
   }
@@ -4746,7 +4812,7 @@ function validateGitHubRepositorySelectionShapes(resources) {
 function validateGitHubRepositorySelectionShape(resources) {
   const installationIds = validateGitHubRepositorySelectionShapes(resources);
   if (installationIds.length > 1) {
-    throw new HTTPException9(422, {
+    throw new HTTPException8(422, {
       message: "GitHub App repository resources must belong to one installation"
     });
   }
@@ -4768,7 +4834,7 @@ function gitHubRepositorySelections(resources) {
     const installationId = positiveInteger(installationRaw);
     const repositoryId = positiveInteger(repositoryRaw);
     if (!installationId || !repositoryId) {
-      throw new HTTPException9(422, {
+      throw new HTTPException8(422, {
         message: "GitHub App repository resources require positive github_installation_id and github_repository_id"
       });
     }
@@ -4789,14 +4855,14 @@ async function validateGitHubRepositorySelection(db, workspaceId, resources) {
       installationId,
       repositoryIds
     )) {
-      throw new HTTPException9(422, {
+      throw new HTTPException8(422, {
         message: "GitHub App repository resources must be authorized for a GitHub App installation linked to this workspace"
       });
     }
   }
 }
 function isAuthoritativeGitHubRepositorySelectionError(error) {
-  return error instanceof HTTPException9 && error.status === 422;
+  return error instanceof HTTPException8 && error.status === 422;
 }
 async function validateFileResources(db, workspaceId, resources) {
   const fileIds = /* @__PURE__ */ new Set();
@@ -4805,15 +4871,15 @@ async function validateFileResources(db, workspaceId, resources) {
       continue;
     }
     if (fileIds.has(resource.fileId)) {
-      throw new HTTPException9(422, { message: `duplicate file resource: ${resource.fileId}` });
+      throw new HTTPException8(422, { message: `duplicate file resource: ${resource.fileId}` });
     }
     fileIds.add(resource.fileId);
     const file = await requireFile(db, workspaceId, resource.fileId).catch(() => null);
     if (!file) {
-      throw new HTTPException9(422, { message: `unknown file resource: ${resource.fileId}` });
+      throw new HTTPException8(422, { message: `unknown file resource: ${resource.fileId}` });
     }
     if (file.status !== "ready") {
-      throw new HTTPException9(422, {
+      throw new HTTPException8(422, {
         message: `file resource ${resource.fileId} is ${file.status}`
       });
     }
@@ -4824,7 +4890,7 @@ function normalizeMountPath(path) {
     return normalizeResourceMountPath(path);
   } catch (error) {
     if (!(error instanceof ResourceMountPathError)) throw error;
-    throw new HTTPException9(422, { message: `invalid resource mount path: ${path}` });
+    throw new HTTPException8(422, { message: `invalid resource mount path: ${path}` });
   }
 }
 function positiveInteger(value) {
@@ -4976,27 +5042,31 @@ import {
   getRig as getRig4,
   getScheduledTask,
   getScheduledTaskPersonalConnectionDelegations,
+  getSessionTurnXaiProviderAccountAuthoritySnapshot as getSessionTurnXaiProviderAccountAuthoritySnapshot2,
   getSession as getSession3,
   requireWorkspace as requireWorkspace2,
   scopedKnowledgeScopeKey,
-  updateScheduledTask
+  updateScheduledTask,
+  resolveXaiProviderAccountAuthoritySnapshotForAcceptance
 } from "@opengeni/db";
-import { HTTPException as HTTPException13 } from "hono/http-exception";
+import { HTTPException as HTTPException12 } from "hono/http-exception";
 
 // src/domain/sessions.ts
 import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
 import {
   canonicalizeConfiguredModelId,
   configuredAllowedModels,
+  resolveFirstPartyMcpToolPolicy,
   policyProviderIdForModel,
   resolveTurnExecutionPolicyV1,
-  WORKSPACE_GATEWAY_MODEL_ID_PREFIX
+  WORKSPACE_GATEWAY_MODEL_ID_PREFIX,
+  XAI_SUBSCRIPTION_MODEL_ID_PREFIX
 } from "@opengeni/config";
 import {
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
   DEFAULT_FIRST_PARTY_MCP_TOOLS,
-  FIRST_PARTY_MCP_TOOL_NAMES,
+  FIRST_PARTY_MCP_TOOL_NAMES as FIRST_PARTY_MCP_TOOL_NAMES2,
   OPENGENI_SLACK_BOT_SESSION_METADATA_KEY as OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2,
   SessionSpawnDenial,
   ServiceTurnInitiator,
@@ -5013,6 +5083,7 @@ import {
   encryptVariableSetValue as encryptVariableSetValue2,
   getAnySessionInGroup,
   getEnrollment as getEnrollment3,
+  getChannel,
   getRig as getRig3,
   getWorkspaceDefaultRigId,
   listDistinctVariableSetIdsInGroup,
@@ -5024,6 +5095,7 @@ import {
   getWorkspaceControlEvent,
   getSessionLineage,
   getSessionTurn,
+  getSessionTurnXaiProviderAccountAuthoritySnapshot,
   getWorkspaceModelPolicy,
   initializeSessionStartAtomically,
   listSessionTurns,
@@ -5045,7 +5117,7 @@ import {
   publishDurableSessionEvents,
   publishDurableWorkspaceControlEvent
 } from "@opengeni/events";
-import { HTTPException as HTTPException12 } from "hono/http-exception";
+import { HTTPException as HTTPException11 } from "hono/http-exception";
 
 // src/domain/timeline-annotations.ts
 import {
@@ -5054,11 +5126,11 @@ import {
   numberTimelineAnnotations
 } from "@opengeni/contracts";
 import { getSessionEvent } from "@opengeni/db";
-import { HTTPException as HTTPException10 } from "hono/http-exception";
+import { HTTPException as HTTPException9 } from "hono/http-exception";
 var SOURCE_CONTEXT_BYTES = 160;
 var ANSI_SEQUENCE = new RegExp("\\u001B\\[[0-?]*[ -/]*[@-~]", "g");
 function invalidAnnotationSource() {
-  throw new HTTPException10(422, { message: "Invalid timeline annotation source" });
+  throw new HTTPException9(422, { message: "Invalid timeline annotation source" });
 }
 function safeJson(value) {
   try {
@@ -5208,7 +5280,7 @@ import {
 import {
   getConnectionMetadata as getConnectionMetadata3
 } from "@opengeni/db";
-import { HTTPException as HTTPException11 } from "hono/http-exception";
+import { HTTPException as HTTPException10 } from "hono/http-exception";
 function openGeniSlackBotMetadata(metadata) {
   const parsed = OpenGeniSlackBotConnectionMetadata.safeParse(metadata);
   return parsed.success ? parsed.data : null;
@@ -5227,12 +5299,12 @@ function hasReservedOpenGeniSlackBotSessionMetadata(metadata) {
 async function requireOpenGeniSlackBotConnection(db, workspaceId, connectionId) {
   const connection = await getConnectionMetadata3(db, workspaceId, connectionId, null);
   if (!connection || !isOpenGeniSlackBotConnection(connection)) {
-    throw new HTTPException11(422, {
+    throw new HTTPException10(422, {
       message: "slackBotConnectionId must reference an OpenGeni Slack bot connection"
     });
   }
   if (connection.status !== "active") {
-    throw new HTTPException11(422, {
+    throw new HTTPException10(422, {
       message: `OpenGeni Slack bot connection is not active (${connection.status})`
     });
   }
@@ -5269,10 +5341,14 @@ var SessionSpawnDeniedError = class extends Error {
     this.denial = denial;
   }
 };
-function resolveFirstPartyMcpToolsForCreate(requested, parentStored) {
+function resolveFirstPartyMcpToolsForCreate(requested, parentStored, policy = {
+  default: DEFAULT_FIRST_PARTY_MCP_TOOLS,
+  allowed: FIRST_PARTY_MCP_TOOL_NAMES2
+}) {
   if (requested !== void 0) return [...requested];
-  if (parentStored === void 0) return [...DEFAULT_FIRST_PARTY_MCP_TOOLS];
-  return [...parentStored ?? DEFAULT_FIRST_PARTY_MCP_TOOLS];
+  const allowed = new Set(policy.allowed);
+  const inherited = parentStored === void 0 ? policy.default : parentStored ?? policy.default;
+  return [...inherited].filter((tool) => allowed.has(tool));
 }
 function sessionSpawnDeniedMessage(denial) {
   if (denial.code === "nested_agent_depth_override_forbidden") {
@@ -5292,7 +5368,7 @@ function sessionSpawnDenialEnvelope(error) {
 function serviceInitiatorForGrant(grant) {
   if (!grant.serviceInitiator) {
     if (grant.serviceInitiatorContext) {
-      throw new HTTPException12(403, {
+      throw new HTTPException11(403, {
         message: "service initiator context requires a signed service initiator"
       });
     }
@@ -5300,13 +5376,13 @@ function serviceInitiatorForGrant(grant) {
   }
   const initiator = ServiceTurnInitiator.safeParse(grant.serviceInitiator);
   if (!initiator.success) {
-    throw new HTTPException12(403, {
+    throw new HTTPException11(403, {
       message: "a delegated command initiator must be a bounded service principal"
     });
   }
   const context = ServiceTurnInitiatorContext.safeParse(grant.serviceInitiatorContext ?? {});
   if (!context.success) {
-    throw new HTTPException12(403, {
+    throw new HTTPException11(403, {
       message: "delegated service initiator context is invalid or reserved"
     });
   }
@@ -5314,7 +5390,7 @@ function serviceInitiatorForGrant(grant) {
   const callerAttemptId = grant.metadata?.["attemptId"];
   const callerExecutionGeneration = grant.metadata?.["executionGeneration"];
   if (callerTurnId !== void 0 || callerAttemptId !== void 0 || callerExecutionGeneration !== void 0) {
-    throw new HTTPException12(403, {
+    throw new HTTPException11(403, {
       message: "a service initiator cannot replace an exact agent-attempt initiator"
     });
   }
@@ -5332,7 +5408,7 @@ function creationInitiatorForGrant(grant) {
   const hasCallerTurnClaim = callerTurnId !== void 0 || callerAttemptId !== void 0 || callerExecutionGeneration !== void 0;
   if (hasCallerTurnClaim) {
     if (typeof callerSessionId !== "string" || typeof callerTurnId !== "string" || typeof callerAttemptId !== "string" || typeof callerExecutionGeneration !== "number" || !Number.isSafeInteger(callerExecutionGeneration) || callerExecutionGeneration < 1) {
-      throw new HTTPException12(403, {
+      throw new HTTPException11(403, {
         message: "caller attempt claims are incomplete"
       });
     }
@@ -5363,31 +5439,31 @@ function normalizedSessionMcpCredentialHeaders(headers) {
   }
   const entries = Object.entries(headers).map(([name, value]) => [name.trim(), value]).filter(([name]) => name.length > 0);
   if (entries.length > maxSessionMcpCredentialHeaders) {
-    throw new HTTPException12(422, {
+    throw new HTTPException11(422, {
       message: `a session MCP server supports at most ${maxSessionMcpCredentialHeaders} credential headers`
     });
   }
   const seen = /* @__PURE__ */ new Set();
   for (const [name, value] of entries) {
     if (!sessionMcpCredentialHeaderName.test(name)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `invalid credential header name: ${name}`
       });
     }
     const lower = name.toLowerCase();
     if (seen.has(lower)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `duplicate credential header name: ${name}`
       });
     }
     seen.add(lower);
     if (value.length === 0 || value.length > maxSessionMcpCredentialHeaderValueLength) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `credential header ${name} must be 1-${maxSessionMcpCredentialHeaderValueLength} characters`
       });
     }
     if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `credential header ${name} contains forbidden control characters`
       });
     }
@@ -5454,13 +5530,13 @@ function validateSessionMcpServersForCreate(settings, grant, servers) {
   const metadata = [];
   for (const server of servers) {
     if (seenIds.has(server.id)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `duplicate session MCP server id: ${server.id}`
       });
     }
     seenIds.add(server.id);
     if (reservedSessionMcpServerIds.has(server.id) || existingIds.has(server.id)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `MCP server id already exists: ${server.id}`
       });
     }
@@ -5502,13 +5578,13 @@ function validateInheritedSessionMcpServersForCreate(servers) {
   const seenIds = /* @__PURE__ */ new Set();
   for (const server of servers) {
     if (seenIds.has(server.id)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `duplicate inherited session MCP server id: ${server.id}`
       });
     }
     seenIds.add(server.id);
     if (reservedSessionMcpServerIds.has(server.id)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `reserved inherited session MCP server id: ${server.id}`
       });
     }
@@ -5540,13 +5616,13 @@ function validateSessionMcpCredentialUpdates(input) {
   const seenIds = /* @__PURE__ */ new Set();
   const encryptedUpdates = input.updates.map((update) => {
     if (seenIds.has(update.id)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `duplicate session MCP credential update id: ${update.id}`
       });
     }
     seenIds.add(update.id);
     if (!knownIds.has(update.id)) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `unknown session MCP server id: ${update.id}`
       });
     }
@@ -5590,6 +5666,7 @@ async function createAndStartSessionWithOutcome(input) {
       variableSetId: input.variableSet?.id ?? null,
       rigId: input.rigId ?? null,
       rigVersionId: input.rigVersionId ?? null,
+      channelId: input.channelId ?? null,
       firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
       firstPartyMcpTools: input.firstPartyMcpTools,
       instructions: input.instructions ?? null,
@@ -5600,9 +5677,13 @@ async function createAndStartSessionWithOutcome(input) {
       ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {},
       mcpServers: input.mcpServers ?? [],
       personalConnectionDelegations: input.personalConnectionDelegations ?? [],
+      ...input.xaiProviderAccountAuthoritySnapshot ? {
+        initialXaiProviderAccountAuthoritySnapshot: input.xaiProviderAccountAuthoritySnapshot
+      } : {},
       maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
       allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
-      subjectId: input.subjectId ?? null
+      subjectId: input.subjectId ?? null,
+      ...input.beforeCreateCommit ? { beforeCreateCommit: input.beforeCreateCommit } : {}
     });
     if (keyedResult.denied) {
       throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(keyedResult.denial));
@@ -5649,6 +5730,7 @@ async function createAndStartSessionWithOutcome(input) {
       variableSetId: input.variableSet?.id ?? null,
       rigId: input.rigId ?? null,
       rigVersionId: input.rigVersionId ?? null,
+      channelId: input.channelId ?? null,
       firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
       firstPartyMcpTools: input.firstPartyMcpTools,
       instructions: input.instructions ?? null,
@@ -5658,9 +5740,13 @@ async function createAndStartSessionWithOutcome(input) {
       ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {},
       mcpServers: input.mcpServers ?? [],
       personalConnectionDelegations: input.personalConnectionDelegations ?? [],
+      ...input.xaiProviderAccountAuthoritySnapshot ? {
+        initialXaiProviderAccountAuthoritySnapshot: input.xaiProviderAccountAuthoritySnapshot
+      } : {},
       maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
       allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
-      subjectId: input.subjectId ?? null
+      subjectId: input.subjectId ?? null,
+      ...input.beforeCreateCommit ? { beforeCreateCommit: input.beforeCreateCommit } : {}
     });
   } catch (error) {
     if (error instanceof SessionSpawnDeniedDbError) {
@@ -5682,7 +5768,7 @@ async function createAndStartSession(input) {
 async function finishStartSession(input, session) {
   if (input.seedTargetSandbox) {
     if (session.sandboxBackend === "none") {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: "cannot target a machine for a session with no sandbox (backend: none)"
       });
     }
@@ -5706,7 +5792,7 @@ async function finishStartSession(input, session) {
       input.seedTargetSandbox.workingDir ?? null
     );
     if (!seeded.swapped) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `cannot target sandbox ${input.seedTargetSandbox.sandboxId}: ${seeded.reason ?? "target is not attachable"}`
       });
     }
@@ -5765,10 +5851,13 @@ function canonicalConfiguredModel(settings, model) {
   if (settings.codexSubscriptionEnabled && canonicalModel.startsWith(CODEX_MODEL_ID_PREFIX)) {
     return canonicalModel;
   }
+  if (settings.supergrokSubscriptionEnabled && canonicalModel.startsWith(XAI_SUBSCRIPTION_MODEL_ID_PREFIX)) {
+    return canonicalModel;
+  }
   if (canonicalModel.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX)) {
     return canonicalModel;
   }
-  throw new HTTPException12(422, { message: `model is not available: ${model}` });
+  throw new HTTPException11(422, { message: `model is not available: ${model}` });
 }
 function assertConfiguredModel(settings, model) {
   canonicalConfiguredModel(settings, model);
@@ -5809,7 +5898,7 @@ async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model
     modelId: canonicalModel
   });
   if (!verdict.allowed) {
-    throw new HTTPException12(422, {
+    throw new HTTPException11(422, {
       message: verdict.reason === "provider" ? `model "${canonicalModel}" is not allowed by this workspace's model policy: provider "${providerId}" is not in the allowed providers` : `model "${canonicalModel}" is not allowed by this workspace's model policy`
     });
   }
@@ -5817,10 +5906,10 @@ async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model
 async function requireQueuedTurnForApi(db, workspaceId, sessionId, turnId) {
   const turn = await getSessionTurn(db, workspaceId, turnId);
   if (!turn || turn.sessionId !== sessionId) {
-    throw new HTTPException12(404, { message: "session turn not found" });
+    throw new HTTPException11(404, { message: "session turn not found" });
   }
   if (turn.status !== "queued") {
-    throw new HTTPException12(409, {
+    throw new HTTPException11(409, {
       message: `turn is ${turn.status}; only queued turns can be changed`
     });
   }
@@ -5844,7 +5933,7 @@ async function postUserMessageTurn(input) {
     assertSessionAllowsProductModel(sessionForModelGate, effectiveModelForGate);
   } catch (error) {
     if (error instanceof CodexCompactionV2ProviderLockedError) {
-      throw new HTTPException12(422, { message: error.message, cause: error });
+      throw new HTTPException11(422, { message: error.message, cause: error });
     }
     throw error;
   }
@@ -5893,13 +5982,13 @@ async function postUserMessageTurn(input) {
     );
   } catch (error) {
     if (error instanceof QueueCommandConflictError || error instanceof SessionControlConflictError) {
-      throw new HTTPException12(409, { message: error.message });
+      throw new HTTPException11(409, { message: error.message });
     }
     if (error instanceof Error && error.message.includes("cancelled")) {
-      throw new HTTPException12(409, { message: error.message });
+      throw new HTTPException11(409, { message: error.message });
     }
     if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
-      throw new HTTPException12(422, { message: error.message });
+      throw new HTTPException11(422, { message: error.message });
     }
     throw error;
   }
@@ -5966,7 +6055,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
   if (hasReservedOpenGeniSlackBotSessionMetadata(payload.metadata)) {
-    throw new HTTPException12(422, {
+    throw new HTTPException11(422, {
       message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2} is reserved for scheduler routing`
     });
   }
@@ -5982,30 +6071,45 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
   }
   const parentSessionId = typeof grant.metadata?.["sessionId"] === "string" ? grant.metadata["sessionId"] : null;
   if (parentSessionId) {
-    await requireSessionAuthorization(deps, grant, {
-      sessionId: parentSessionId,
-      operation: "session.child.create",
-      surface: "core"
-    });
+    try {
+      await requireSessionAuthorization(deps, grant, {
+        sessionId: parentSessionId,
+        operation: "session.child.create",
+        surface: "core"
+      });
+    } catch (error) {
+      if (error instanceof SessionAuthorizationDeniedError) {
+        throw new HTTPException11(403, { message: error.message, cause: error });
+      }
+      throw error;
+    }
   }
   const parentSession = parentSessionId ? await getSession2(db, workspaceId, parentSessionId) : null;
   if (parentSessionId && !parentSession) {
-    throw new HTTPException12(404, {
+    throw new HTTPException11(404, {
       message: `parent session not found in workspace: ${parentSessionId}`
     });
   }
   const creationInitiator = creationInitiatorForGrant(grant);
   const parentCallingTurn = parentSession && creationInitiator.actor ? await getSessionTurn(db, workspaceId, creationInitiator.actor.turnId) : null;
   if (creationInitiator.actor && (!parentCallingTurn || parentCallingTurn.sessionId !== parentSession?.id)) {
-    throw new HTTPException12(403, {
+    throw new HTTPException11(403, {
       message: "caller attempt does not belong to the parent session"
     });
   }
+  const xaiProviderAccountAuthoritySnapshot = parentSession && creationInitiator.actor ? await getSessionTurnXaiProviderAccountAuthoritySnapshot(
+    db,
+    workspaceId,
+    parentSession.id,
+    creationInitiator.actor.turnId
+  ) : void 0;
   const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(
     db,
     workspaceId,
     settings,
-    { subjectId: grant.subjectId }
+    {
+      subjectId: grant.subjectId
+    }
   );
   const sessionMcpServers = hasOwnProperty(rawPayload, "mcpServers") ? validateSessionMcpServersForCreate(capabilityRuntimeSettings, grant, payload.mcpServers) : parentSession ? validateInheritedSessionMcpServersForCreate(
     await listSessionMcpServersForChildInheritance(db, workspaceId, parentSession.id)
@@ -6074,7 +6178,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
   });
   await validateGitHubRepositorySelection(db, workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException12(503, {
+    throw new HTTPException11(503, {
       message: "object storage is not configured"
     });
   }
@@ -6092,7 +6196,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     const rig = await getRig3(db, workspaceId, requestedRigId);
     if (!rig || !rig.activeVersion) {
       if (payload.rigId) {
-        throw new HTTPException12(422, {
+        throw new HTTPException11(422, {
           message: rig ? `rig ${payload.rigId} has no active version to bind` : `unknown rigId: ${payload.rigId}`
         });
       }
@@ -6101,6 +6205,16 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       frozenRigVersionId = rig.activeVersion.id;
     }
   }
+  let channelId = null;
+  if (payload.channelId) {
+    const channel = await getChannel(db, workspaceId, payload.channelId);
+    if (!channel) {
+      throw new HTTPException11(422, {
+        message: `unknown channelId: ${payload.channelId}`
+      });
+    }
+    channelId = channel.id;
+  }
   const inheritedModel = parentCallingTurn?.model ?? parentSession?.model ?? settings.openaiModel;
   const model = canonicalConfiguredModel(settings, payload.model ?? inheritedModel);
   if (model === null || model === void 0) {
@@ -6125,7 +6239,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
   if (parentFirstPartyMcpPermissions && payload.firstPartyMcpPermissions?.some(
     (permission) => !hasPermission(parentFirstPartyMcpPermissions, permission)
   )) {
-    throw new HTTPException12(403, {
+    throw new HTTPException11(403, {
       message: "child first-party MCP permissions may only narrow the parent session grant"
     });
   }
@@ -6133,32 +6247,42 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     (permission) => hasPermission(grant.permissions, permission)
   ) : null);
   if (firstPartyMcpPermissions && firstPartyMcpPermissions.length === 0) {
-    throw new HTTPException12(422, {
+    throw new HTTPException11(422, {
       message: "firstPartyMcpPermissions must not be empty; omit it for the default worker permission set"
     });
   }
   for (const permission of firstPartyMcpPermissions ?? []) {
     if (!hasPermission(grant.permissions, permission)) {
-      throw new HTTPException12(403, {
+      throw new HTTPException11(403, {
         message: `cannot grant first-party MCP permission beyond the creating grant: ${permission}`
       });
     }
   }
   if (payload.goal && firstPartyMcpPermissions && !firstPartyMcpPermissions.includes("goals:manage")) {
-    throw new HTTPException12(422, {
+    throw new HTTPException11(422, {
       message: "goal-bearing sessions require goals:manage in the resulting first-party MCP permission set"
     });
   }
+  const deploymentFirstPartyMcpToolPolicy = resolveFirstPartyMcpToolPolicy(settings);
+  const disallowedFirstPartyMcpTool = payload.firstPartyMcpTools?.find(
+    (tool) => !deploymentFirstPartyMcpToolPolicy.allowed.includes(tool)
+  );
+  if (disallowedFirstPartyMcpTool) {
+    throw new HTTPException11(422, {
+      message: `first-party MCP tool is disabled by deployment policy: ${disallowedFirstPartyMcpTool}`
+    });
+  }
   const firstPartyMcpTools = resolveFirstPartyMcpToolsForCreate(
     payload.firstPartyMcpTools,
-    parentSession ? parentSession.firstPartyMcpTools : void 0
+    parentSession ? parentSession.firstPartyMcpTools : void 0,
+    deploymentFirstPartyMcpToolPolicy
   );
   if (payload.goal) {
-    const missingGoalTools = ["goal_update", "goal_complete", "goal_pause"].filter(
+    const missingGoalTools = ["goal_update", "goal_progress", "goal_complete", "goal_pause"].filter(
       (name) => !firstPartyMcpTools.includes(name)
     );
     if (missingGoalTools.length > 0) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `goal-bearing sessions require first-party MCP tools: ${missingGoalTools.join(", ")}`
       });
     }
@@ -6171,7 +6295,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
   const rigVersionMatchesGroup = (memberRigVersionId) => memberRigVersionId === frozenRigVersionId;
   if (sandboxChoice === "shared") {
     if (!parentSessionId) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: "sandbox:'shared' requires a parent session (spawn from inside a session); use 'new' for a top-level create."
       });
     }
@@ -6194,7 +6318,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     }
     if (variableSetMismatch || rigMismatch) {
       if (payload.sandbox === "shared") {
-        throw new HTTPException12(422, {
+        throw new HTTPException11(422, {
           message: variableSetMismatch ? "sandbox:'shared' requires the same variableSet / same environment as the creator's box (the box variable set/environment is fixed at creation); omit sandbox or pass 'new' when attaching a different variableSet/environment." : "sandbox:'shared' requires the same rig as the creator's box (the box's rig setup is fixed at creation); omit sandbox or pass 'new' when binding a different rig."
         });
       }
@@ -6205,7 +6329,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
   } else if (typeof sandboxChoice === "object") {
     const member = await getAnySessionInGroup(db, workspaceId, sandboxChoice.groupId);
     if (!member) {
-      throw new HTTPException12(404, {
+      throw new HTTPException11(404, {
         message: `sandbox group not found in workspace: ${sandboxChoice.groupId}`
       });
     }
@@ -6218,7 +6342,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       if (!memberVariableSetIds.every(
         (memberVariableSetId) => variableSetMatchesGroup(memberVariableSetId)
       )) {
-        throw new HTTPException12(422, {
+        throw new HTTPException11(422, {
           message: `sandbox group ${sandboxChoice.groupId} runs a different variableSet / different environment (the box variable set/environment is fixed at creation); create with the group's variableSet/environment or omit sandbox for an own box.`
         });
       }
@@ -6230,7 +6354,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       if (!memberRigVersionIds.every(
         (memberRigVersionId) => rigVersionMatchesGroup(memberRigVersionId)
       )) {
-        throw new HTTPException12(422, {
+        throw new HTTPException11(422, {
           message: `sandbox group ${sandboxChoice.groupId} runs a different rig (the box's rig setup is fixed at creation); create with the group's rig or omit sandbox for an own box.`
         });
       }
@@ -6239,7 +6363,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     inheritedBackend = member.sandboxBackend;
   }
   if (payload.workingDir !== void 0 && !payload.targetSandboxId) {
-    throw new HTTPException12(422, {
+    throw new HTTPException11(422, {
       message: "workingDir requires targetSandboxId (it is the targeted machine's working directory)"
     });
   }
@@ -6306,6 +6430,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       // Frozen rig binding (M3): both null for a rig-less session (today's path).
       rigId: frozenRigId,
       rigVersionId: frozenRigVersionId,
+      channelId,
       goal: payload.goal ?? null,
       // Per-session persona instructions (already trimmed/validated by the
       // contracts schema). Persisted on the row; composed system-level at turn
@@ -6317,6 +6442,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       mcpServers: sessionMcpServers.dbServers,
       sessionMcpServers: sessionMcpServers.metadata,
       personalConnectionDelegations,
+      ...xaiProviderAccountAuthoritySnapshot ? { xaiProviderAccountAuthoritySnapshot } : {},
       parentSessionId,
       createIdempotencyKey: payload.idempotencyKey ?? null,
       maxNestedAgentDepthOverride: payload.maxNestedAgentDepth ?? null,
@@ -6338,10 +6464,10 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     });
   } catch (error) {
     if (error instanceof AgentCommandAuthorityError) {
-      throw new HTTPException12(403, { message: error.message });
+      throw new HTTPException11(403, { message: error.message });
     }
     if (error instanceof SessionIdConflictError) {
-      throw new HTTPException12(409, {
+      throw new HTTPException11(409, {
         message: "requested session id is already in use"
       });
     }
@@ -6387,6 +6513,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
 }
 async function acceptSessionUserMessageWithOutcome(deps, grant, workspaceId, sessionId, input) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
+  const delegatedServiceInitiator = serviceInitiatorForGrant(grant);
   await requireSessionAuthorization(deps, grant, {
     sessionId,
     operation: input.delivery === "steer" ? "session.steer" : "session.append",
@@ -6402,7 +6529,7 @@ async function acceptSessionUserMessageWithOutcome(deps, grant, workspaceId, ses
     assertSessionAllowsProductModel(existingSession, effectiveModel);
   } catch (error) {
     if (error instanceof CodexCompactionV2ProviderLockedError) {
-      throw new HTTPException12(422, { message: error.message, cause: error });
+      throw new HTTPException11(422, { message: error.message, cause: error });
     }
     throw error;
   }
@@ -6437,7 +6564,7 @@ async function acceptSessionUserMessageWithOutcome(deps, grant, workspaceId, ses
     model: effectiveModel
   });
   if (requestedResources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException12(503, {
+    throw new HTTPException11(503, {
       message: "object storage is not configured"
     });
   }
@@ -6462,7 +6589,6 @@ async function acceptSessionUserMessageWithOutcome(deps, grant, workspaceId, ses
     tools: existingSession.tools,
     source: personalConnectionDelegationSourceForGrant(grant)
   });
-  const delegatedServiceInitiator = serviceInitiatorForGrant(grant);
   const { accepted, turn, interruptionCount, replay } = await postUserMessageTurn({
     db,
     bus,
@@ -6558,7 +6684,7 @@ async function updateSessionMcpApprovalPolicy(deps, grant, sessionId, serverId,
     async (_session, context) => {
       const result = await context.updateSessionMcpApprovalPolicy(serverId, normalizedPolicy);
       if (!result.server) {
-        throw new HTTPException12(404, {
+        throw new HTTPException11(404, {
           message: "session MCP server not found"
         });
       }
@@ -6638,18 +6764,27 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       (tool) => !validatedIds.has(`${tool.kind}:${tool.id}`)
     );
     if (unknown) {
-      throw new HTTPException12(422, {
+      throw new HTTPException11(422, {
         message: `unknown MCP server id: ${unknown.id}`
       });
     }
     return withFirstPartyTools(validatedTools, runtimeSettings);
   })() : null;
   const explicitRequestedFirstPartyTools = explicitRequest ? [...explicitRequest.firstPartyMcpTools] : null;
+  const deploymentFirstPartyMcpToolPolicy = resolveFirstPartyMcpToolPolicy(deps.settings);
+  const disallowedFirstPartyMcpTool = explicitRequestedFirstPartyTools?.find(
+    (tool) => !deploymentFirstPartyMcpToolPolicy.allowed.includes(tool)
+  );
+  if (disallowedFirstPartyMcpTool) {
+    throw new HTTPException11(422, {
+      message: `first-party MCP tool is disabled by deployment policy: ${disallowedFirstPartyMcpTool}`
+    });
+  }
   const workspaceDefaultTools = withFirstPartyTools(
     withDefaultEnabledCapabilityMcpTools([], deps.settings, capabilityRuntimeSettings),
     runtimeSettings
   );
-  const workspaceDefaultFirstPartyTools = [...FIRST_PARTY_MCP_TOOL_NAMES];
+  const workspaceDefaultFirstPartyTools = [...deploymentFirstPartyMcpToolPolicy.default];
   const events = await appendSessionEventsWithLockedSessionUpdate(
     deps.db,
     grant.workspaceId,
@@ -6665,7 +6800,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       if (session.parentSessionId) {
         const parent = await context.getLockedSession(session.parentSessionId);
         if (!parent) {
-          throw new HTTPException12(409, {
+          throw new HTTPException11(409, {
             message: "parent session is no longer available"
           });
         }
@@ -6678,12 +6813,15 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
           ) : parent.tools,
           runtimeSettings
         );
+        const deploymentAllowedFirstPartyMcpTools = new Set(
+          deploymentFirstPartyMcpToolPolicy.allowed
+        );
         const parentFirstPartyMcpTools = [
-          ...parent.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS
-        ];
+          ...parent.firstPartyMcpTools ?? deploymentFirstPartyMcpToolPolicy.default
+        ].filter((tool) => deploymentAllowedFirstPartyMcpTools.has(tool));
         if (requestedMode === "workspace_default") {
           if (!parentTracksWorkspaceDefaults) {
-            throw new HTTPException12(403, {
+            throw new HTTPException11(403, {
               message: "a child may adopt workspace defaults only while its parent tracks workspace defaults"
             });
           }
@@ -6705,7 +6843,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
             (tool) => !parentFirstPartySet.has(tool)
           );
           if (widenedFirstPartyTool) {
-            throw new HTTPException12(403, {
+            throw new HTTPException11(403, {
               message: `session OpenGeni tools may only narrow the parent policy: ${widenedFirstPartyTool}`
             });
           }
@@ -6723,7 +6861,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       const currentPolicy = session.toolPolicy;
       const unchanged = stableJson4({
         tools: session.tools,
-        firstPartyMcpTools: session.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS,
+        firstPartyMcpTools: session.firstPartyMcpTools ?? deploymentFirstPartyMcpToolPolicy.default,
         policy: currentPolicy
       }) === stableJson4({
         tools: nextTools,
@@ -6742,7 +6880,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
               before: toolPolicyAuditSnapshot(
                 session,
                 session.tools,
-                [...session.firstPartyMcpTools ?? DEFAULT_FIRST_PARTY_MCP_TOOLS],
+                [...session.firstPartyMcpTools ?? deploymentFirstPartyMcpToolPolicy.default],
                 currentPolicy
               ),
               after: toolPolicyAuditSnapshot(
@@ -6781,13 +6919,13 @@ async function readSessionLineage(deps, grant, sessionId) {
   if (authorization?.relatedSessionAccess === "target") {
     const session = await getSession2(deps.db, grant.workspaceId, sessionId);
     if (!session) {
-      throw new HTTPException12(404, { message: "session not found" });
+      throw new HTTPException11(404, { message: "session not found" });
     }
     return { ancestors: [], children: [], truncated: false };
   }
   const lineage = await getSessionLineage(deps.db, grant.workspaceId, sessionId);
   if (!lineage) {
-    throw new HTTPException12(404, { message: "session not found" });
+    throw new HTTPException11(404, { message: "session not found" });
   }
   return lineage;
 }
@@ -6865,6 +7003,15 @@ async function createValidatedScheduledTask(input) {
     source: personalConnectionDelegationSourceForGrant(input.grant)
   });
   const creationInitiator = creationInitiatorForGrant(input.grant);
+  const xaiProviderAccountAuthoritySnapshot = creationInitiator.actor ? await getSessionTurnXaiProviderAccountAuthoritySnapshot2(
+    input.db,
+    input.grant.workspaceId,
+    creationInitiator.actor.sessionId,
+    creationInitiator.actor.turnId
+  ) : await resolveXaiProviderAccountAuthoritySnapshotForAcceptance(input.db, {
+    workspaceId: input.grant.workspaceId,
+    subjectId: input.grant.subjectId
+  });
   return await createScheduledTask(input.db, {
     id,
     accountId: input.grant.accountId,
@@ -6881,6 +7028,7 @@ async function createValidatedScheduledTask(input) {
     ...creationInitiator.context ? { createdByContext: creationInitiator.context } : {},
     createdByActor: creationInitiator.actor ?? null,
     personalConnectionDelegations,
+    xaiProviderAccountAuthoritySnapshot,
     targetSessionId: target?.id ?? null,
     variableSetId: input.payload.variableSetId ?? null,
     rigId: input.payload.rigId ?? null,
@@ -6890,20 +7038,20 @@ async function createValidatedScheduledTask(input) {
 async function validateScheduledTaskTarget(input) {
   if (input.runMode !== "existing_session") {
     if (input.targetSessionId) {
-      throw new HTTPException13(422, {
+      throw new HTTPException12(422, {
         message: "targetSessionId requires runMode=existing_session"
       });
     }
     return null;
   }
   if (!input.targetSessionId) {
-    throw new HTTPException13(input.missingTargetStatus ?? 422, {
+    throw new HTTPException12(input.missingTargetStatus ?? 422, {
       message: input.missingTargetStatus === 404 ? "target session not found" : "targetSessionId is required when runMode=existing_session"
     });
   }
   requirePermission(input.grant, "sessions:control");
   if (input.agentConfig.goal) {
-    throw new HTTPException13(422, {
+    throw new HTTPException12(422, {
       message: "agentConfig.goal cannot be used with an existing-session target"
     });
   }
@@ -6922,39 +7070,39 @@ async function validateScheduledTaskTarget(input) {
     );
   } catch (error) {
     if (error instanceof SessionAuthorizationDeniedError) {
-      throw new HTTPException13(404, { message: "target session not found" });
+      throw new HTTPException12(404, { message: "target session not found" });
     }
     if (error instanceof SessionAuthorizationUnavailableError) {
-      throw new HTTPException13(503, { message: "session authorization is unavailable" });
+      throw new HTTPException12(503, { message: "session authorization is unavailable" });
     }
     throw error;
   }
   const session = await getSession3(input.db, input.grant.workspaceId, input.targetSessionId);
   if (!session || session.accountId !== input.grant.accountId) {
-    throw new HTTPException13(404, { message: "target session not found" });
+    throw new HTTPException12(404, { message: "target session not found" });
   }
   if (session.status === "cancelled") {
-    throw new HTTPException13(409, {
+    throw new HTTPException12(409, {
       message: "target session is cancelled; choose a revivable session"
     });
   }
   if ((session.variableSetId ?? null) !== (input.variableSetId ?? null)) {
-    throw new HTTPException13(422, {
+    throw new HTTPException12(422, {
       message: "target session variableSet attachment does not match the scheduled task"
     });
   }
   if (input.rigId && input.rigId !== session.rigId) {
-    throw new HTTPException13(422, {
+    throw new HTTPException12(422, {
       message: "target session rig does not match the scheduled task"
     });
   }
   if (input.agentConfig.sandboxBackend !== void 0 && input.agentConfig.sandboxBackend !== session.sandboxBackend) {
-    throw new HTTPException13(422, {
+    throw new HTTPException12(422, {
       message: "target session sandbox backend does not match the scheduled task"
     });
   }
   if (scheduledSlackBotConnectionId(session.metadata) !== (input.agentConfig.slackBotConnectionId ?? null)) {
-    throw new HTTPException13(422, {
+    throw new HTTPException12(422, {
       message: "target session OpenGeni Slack bot binding does not match the scheduled task"
     });
   }
@@ -6975,25 +7123,25 @@ function scheduledTaskRunForGrant(run, grant) {
 async function requireScheduledTaskRig(db, workspaceId, rigId) {
   const rig = await getRig4(db, workspaceId, rigId);
   if (!rig) {
-    throw new HTTPException13(422, { message: `unknown rigId: ${rigId}` });
+    throw new HTTPException12(422, { message: `unknown rigId: ${rigId}` });
   }
 }
 async function validatedScheduledTaskUpdate(input) {
   const update = {};
   const existingKnowledge = input.existing.action.kind === "knowledge_source_sync";
   if (input.payload.action && input.payload.action.kind !== input.existing.action.kind) {
-    throw new HTTPException13(409, {
+    throw new HTTPException12(409, {
       message: "scheduled task action kind is immutable; create a new schedule"
     });
   }
   if (existingKnowledge) {
     if (input.payload.agentConfig !== void 0 || input.payload.runMode !== void 0 || input.payload.targetSessionId !== void 0 || input.payload.variableSetId !== void 0 || input.payload.rigId !== void 0) {
-      throw new HTTPException13(422, {
+      throw new HTTPException12(422, {
         message: "knowledge source schedules do not accept agent/session configuration"
       });
     }
     if (input.payload.overlapPolicy === "allow_concurrent") {
-      throw new HTTPException13(422, {
+      throw new HTTPException12(422, {
         message: "knowledge source schedules require skip or buffer_one overlap"
       });
     }
@@ -7022,7 +7170,7 @@ async function validatedScheduledTaskUpdate(input) {
   const nextRunMode = input.payload.runMode ?? input.existing.runMode;
   const nextTargetSessionId = input.payload.targetSessionId !== void 0 ? input.payload.targetSessionId : nextRunMode === "existing_session" ? existingTarget : null;
   if (input.existing.runMode === "reusable_session" && input.existing.reusableSessionId && nextRunMode === "existing_session") {
-    throw new HTTPException13(409, {
+    throw new HTTPException12(409, {
       message: "cannot target an existing session after this task created its reusable session; create a new task"
     });
   }
@@ -7048,7 +7196,7 @@ async function validatedScheduledTaskUpdate(input) {
   if (input.payload.variableSetId !== void 0) {
     const nextVariableSetId = input.payload.variableSetId;
     if ((input.existing.variableSetId ?? null) !== (nextVariableSetId ?? null) && input.existing.runMode === "reusable_session" && input.existing.reusableSessionId) {
-      throw new HTTPException13(409, {
+      throw new HTTPException12(409, {
         message: "cannot change variableSet of a task with a live reusable session; recreate the task"
       });
     }
@@ -7088,7 +7236,7 @@ async function validatedScheduledTaskUpdate(input) {
       ...input.toolsProvided !== void 0 ? { toolsProvided: input.toolsProvided } : {}
     });
     if (input.existing.reusableSessionId && input.existing.runMode === "reusable_session" && (input.existing.agentConfig.slackBotConnectionId ?? null) !== (nextAgentConfig.slackBotConnectionId ?? null)) {
-      throw new HTTPException13(409, {
+      throw new HTTPException12(409, {
         message: "cannot change the OpenGeni Slack bot connection of a task with a live reusable session; recreate the task"
       });
     }
@@ -7113,7 +7261,7 @@ async function validatedScheduledTaskUpdate(input) {
         input.existing.id
       );
       if (!personalConnectionDelegationsEqual(existingDelegations, personalConnectionDelegations)) {
-        throw new HTTPException13(409, {
+        throw new HTTPException12(409, {
           message: "cannot change personal MCP connections of a task with a live reusable session; recreate the task"
         });
       }
@@ -7152,7 +7300,7 @@ async function validatedScheduledTaskUpdate(input) {
 async function requireScheduledTaskForApi(db, workspaceId, taskId) {
   const task = await getScheduledTask(db, workspaceId, taskId);
   if (!task) {
-    throw new HTTPException13(404, { message: "scheduled task not found" });
+    throw new HTTPException12(404, { message: "scheduled task not found" });
   }
   return task;
 }
@@ -7185,12 +7333,12 @@ async function restoreScheduledTask(db, previous) {
 }
 async function validateKnowledgeSourceSyncAction(input) {
   if (input.action.initiatingSubjectId !== input.grant.subjectId) {
-    throw new HTTPException13(403, {
+    throw new HTTPException12(403, {
       message: "knowledge source sync must preserve the exact initiating subject"
     });
   }
   if (input.action.connection.ownerSubjectId !== input.grant.subjectId) {
-    throw new HTTPException13(403, {
+    throw new HTTPException12(403, {
       message: "knowledge source connection must belong to the initiating subject"
     });
   }
@@ -7201,10 +7349,10 @@ async function validateKnowledgeSourceSyncAction(input) {
     initiatingSubjectId: input.grant.subjectId
   });
   if (!resolved || resolved.source.lifecycleState !== "active") {
-    throw new HTTPException13(404, { message: "knowledge source not found" });
+    throw new HTTPException12(404, { message: "knowledge source not found" });
   }
   if (resolved.source.syncGeneration !== input.action.sourceGeneration || resolved.source.lifecycleGeneration !== input.action.sourceLifecycleGeneration || scopedKnowledgeScopeKey(resolved.source.scope) !== scopedKnowledgeScopeKey(input.action.destination)) {
-    throw new HTTPException13(409, {
+    throw new HTTPException12(409, {
       message: "knowledge source authority or generation changed"
     });
   }
@@ -7215,7 +7363,7 @@ async function validateKnowledgeSourceSyncAction(input) {
     input.grant.subjectId
   );
   if (!connection || connection.accountId !== input.grant.accountId || connection.workspaceId !== input.grant.workspaceId || connection.subjectId !== input.action.connection.ownerSubjectId || connection.version !== input.action.connection.connectionVersion || connection.providerDomain.toLowerCase() !== input.action.connection.providerDomain.toLowerCase() || connection.kind !== input.action.connection.kind || connection.status !== "active") {
-    throw new HTTPException13(409, {
+    throw new HTTPException12(409, {
       message: "knowledge source connection authority changed or requires reconnect"
     });
   }
@@ -7285,16 +7433,16 @@ async function validateScheduledTaskAgentConfig(input) {
   const tools = input.toolsProvided ?? true ? requestedTools : withDefaultEnabledCapabilityMcpTools(requestedTools, input.settings, runtimeSettings);
   const prompt = input.payload.agentConfig.prompt.trim();
   if (!prompt) {
-    throw new HTTPException13(422, { message: "scheduled task prompt is required" });
+    throw new HTTPException12(422, { message: "scheduled task prompt is required" });
   }
   if (hasReservedOpenGeniSlackBotSessionMetadata(input.payload.agentConfig.metadata)) {
-    throw new HTTPException13(422, {
+    throw new HTTPException12(422, {
       message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY3} is reserved for scheduler routing`
     });
   }
   await validateGitHubRepositorySelection(input.db, input.workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !input.objectStorage) {
-    throw new HTTPException13(503, { message: "object storage is not configured" });
+    throw new HTTPException12(503, { message: "object storage is not configured" });
   }
   await validateFileResources(input.db, input.workspaceId, resources);
   if (input.payload.agentConfig.slackBotConnectionId) {
@@ -7312,7 +7460,7 @@ async function validateScheduledTaskAgentConfig(input) {
     const deploymentPolicy = await getNestedAgentDepthDeploymentPolicy(input.db);
     const inheritedMaxDepth = typeof workspaceMaxDepth === "number" ? workspaceMaxDepth : deploymentPolicy.maxNestedAgentDepth;
     if (requestedMaxDepth > inheritedMaxDepth && !hasPermission(input.grant.permissions, "workspace:admin")) {
-      throw new HTTPException13(403, {
+      throw new HTTPException12(403, {
         message: `scheduled task maxNestedAgentDepth ${requestedMaxDepth} exceeds inherited limit ${inheritedMaxDepth}; workspace:admin is required to increase it`
       });
     }
@@ -7330,13 +7478,13 @@ function validateScheduledTaskSchedule(schedule) {
     return;
   }
   if (new Date(schedule.startAt).getTime() >= new Date(schedule.endAt).getTime()) {
-    throw new HTTPException13(422, { message: "interval schedule endAt must be after startAt" });
+    throw new HTTPException12(422, { message: "interval schedule endAt must be after startAt" });
   }
 }
 function trimmedScheduledTaskName(name) {
   const trimmed = name.trim();
   if (!trimmed) {
-    throw new HTTPException13(422, { message: "scheduled task name is required" });
+    throw new HTTPException12(422, { message: "scheduled task name is required" });
   }
   return trimmed;
 }
@@ -7349,6 +7497,7 @@ import {
 import {
   aggregateModelCallFacts,
   aggregateModelCallFactsByDay,
+  aggregateModelCallFactsByHour,
   aggregateRootSessionDrivers,
   aggregateScheduleFacts,
   aggregateSessionDepth,
@@ -7357,6 +7506,7 @@ import {
   countScheduledTaskFires,
   countSessionsAttachedToGroups,
   enumerateUtcDays,
+  enumerateUtcHours,
   listFloorSessions,
   listLiveWarmLeases,
   listModelCallFacets,
@@ -7365,6 +7515,7 @@ import {
   requireWorkspace as requireWorkspace3,
   sumUsageQuantity as sumUsageQuantity2,
   sumUsageQuantityByDay,
+  sumUsageQuantityByHour,
   sumUsageQuantityInRange
 } from "@opengeni/db";
 var MACHINE_HEARTBEAT_FRESH_MS = 12e4;
@@ -7396,29 +7547,29 @@ function resolveRangeWindow(range, now) {
       since = startOfUtcDay(now);
       rangeLabel = "Today (UTC)";
       priorLabel = "Prior equal window";
-      seriesLabel = "Credit $ (UTC day)";
-      cacheSeriesLabel = "Cache hit %";
+      seriesLabel = "Credit $ / UTC hour";
+      cacheSeriesLabel = "Cache hit % / UTC hour";
       break;
     case "week":
       since = new Date(startOfUtcDay(now).getTime() - 6 * 24 * 60 * 60 * 1e3);
       rangeLabel = "Last 7 days (UTC)";
       priorLabel = "Prior 7 days";
-      seriesLabel = "Credit $ / day";
-      cacheSeriesLabel = "Cache hit % / day";
+      seriesLabel = "Credit $ / UTC day";
+      cacheSeriesLabel = "Cache hit % / UTC day";
       break;
     case "month":
       since = startOfUtcMonth2(now);
       rangeLabel = "This month (UTC)";
       priorLabel = "Prior equal window";
-      seriesLabel = "Credit $ / day";
-      cacheSeriesLabel = "Cache hit % / day";
+      seriesLabel = "Credit $ / UTC day";
+      cacheSeriesLabel = "Cache hit % / UTC day";
       break;
     case "ytd":
       since = startOfUtcYear(now);
       rangeLabel = "Year to date (UTC)";
       priorLabel = "Prior equal window";
-      seriesLabel = "Credit $ / day";
-      cacheSeriesLabel = "Cache hit % / day";
+      seriesLabel = "Credit $ / UTC day";
+      cacheSeriesLabel = "Cache hit % / UTC day";
       break;
     default: {
       const _exhaustive = range;
@@ -7482,6 +7633,8 @@ async function getWorkspaceInsights(db, settings, input) {
   const model = input.model?.trim() || null;
   const modelFilterActive = Boolean(provider || model);
   const filter = { provider, model };
+  const aggregateFactsForSeries = input.range === "today" ? aggregateModelCallFactsByHour : aggregateModelCallFactsByDay;
+  const sumUsageForSeries = input.range === "today" ? sumUsageQuantityByHour : sumUsageQuantityByDay;
   const [
     workspaceCreditMicros,
     priorWorkspaceCreditMicros,
@@ -7541,19 +7694,19 @@ async function getWorkspaceInsights(db, settings, input) {
       until: window.priorUntil,
       ...filter
     }),
-    aggregateModelCallFactsByDay(db, {
+    aggregateFactsForSeries(db, {
       workspaceId: input.workspaceId,
       since: window.since,
       until: window.until,
       ...filter
     }),
-    sumUsageQuantityByDay(db, {
+    sumUsageForSeries(db, {
       workspaceId: input.workspaceId,
       eventType: "sandbox.warm_seconds",
       since: window.since,
       until: window.until
     }),
-    sumUsageQuantityByDay(db, {
+    sumUsageForSeries(db, {
       workspaceId: input.workspaceId,
       eventType: "model.cost",
       since: window.since,
@@ -7673,9 +7826,9 @@ async function getWorkspaceInsights(db, settings, input) {
   const priorCachedTokens = priorModelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
   const priorCacheInputTokens = priorModelRows.reduce((sum, row) => sum + row.cacheInputTokens, 0);
   const priorCalls = priorModelRows.reduce((sum, row) => sum + row.calls, 0);
-  const days = enumerateUtcDays(window.since, window.until);
-  const series = days.map((day) => {
-    const facts = factDays.get(day) ?? {
+  const buckets = input.range === "today" ? enumerateUtcHours(window.since, window.until) : enumerateUtcDays(window.since, window.until);
+  const series = buckets.map((bucket) => {
+    const facts = factDays.get(bucket) ?? {
       costMicros: 0,
       estimatedProviderCostMicros: 0,
       estimatedProviderCostKnownCalls: 0,
@@ -7690,13 +7843,13 @@ async function getWorkspaceInsights(db, settings, input) {
       cacheKnownCalls: 0,
       calls: 0
     };
-    const modelCostMicros = modelFilterActive ? facts.costMicros : costDays.get(day) ?? facts.costMicros;
+    const modelCostMicros = modelFilterActive ? facts.costMicros : costDays.get(bucket) ?? facts.costMicros;
     return {
-      label: day.slice(5),
+      label: input.range === "today" ? bucket.slice(11) : bucket.slice(5),
       modelCostUsd: microsToUsd(modelCostMicros),
       estimatedProviderUsd: microsToUsd(facts.estimatedProviderCostMicros),
       estimatedProviderCostKnownCalls: facts.estimatedProviderCostKnownCalls,
-      warmSeconds: warmDays.get(day) ?? 0,
+      warmSeconds: warmDays.get(bucket) ?? 0,
       inputTokens: facts.inputTokens,
       outputTokens: facts.outputTokens,
       cachedTokens: facts.cachedTokens,
@@ -8488,8 +8641,797 @@ function createCompanyProfileDurableLearningAdapter(options) {
   };
 }
 
+// src/domain/conversation-integrations.ts
+import { createHash as createHash5 } from "crypto";
+var CONVERSATION_INTEGRATION_SCHEMA_VERSION = 1;
+var CONVERSATION_PROVIDER_NAMESPACE_MAX_UTF8_BYTES = 128;
+var CONVERSATION_PROVIDER_OPAQUE_ID_MAX_UTF8_BYTES = 512;
+var CONVERSATION_TEXT_MAX_UTF8_BYTES = 32 * 1024;
+var CONVERSATION_ATTACHMENT_MAX_COUNT = 16;
+var CONVERSATION_ATTACHMENT_NAME_MAX_UTF8_BYTES = 1024;
+var CONVERSATION_ATTACHMENT_MEDIA_TYPE_MAX_UTF8_BYTES = 128;
+var CONVERSATION_OPERATION_KEY_MAX_UTF8_BYTES = 512;
+var CONVERSATION_OUTCOME_CODE_MAX_UTF8_BYTES = 128;
+var PROVIDER_NAMESPACE_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/u;
+var OUTCOME_CODE_PATTERN = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/u;
+var MEDIA_TYPE_PATTERN = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/iu;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+var ABSOLUTE_URL_PATTERN = /^[a-z][a-z0-9+.-]*:\/\//iu;
+var textEncoder = new TextEncoder();
+function normalizeConversationInboundEnvelope(input) {
+  assertExactObject(input, "inbound envelope", [
+    "provider",
+    "installationId",
+    "actor",
+    "route",
+    "providerEventId",
+    "providerMessageId",
+    "occurredAt",
+    "signal",
+    "text",
+    "attachments"
+  ]);
+  const provider = normalizeConversationProviderNamespace(input.provider);
+  const installation = normalizeConversationInstallationIdentity({
+    provider,
+    providerInstallationId: input.installationId
+  });
+  const actor = normalizeConversationActor(installation, input.actor);
+  const route = normalizeConversationRoute(installation, input.route);
+  const providerEventId = providerOpaqueId(provider, "event", input.providerEventId);
+  const providerMessageId = providerOpaqueId(provider, "message", input.providerMessageId);
+  const occurredAt = canonicalTimestamp(input.occurredAt, "inbound occurredAt");
+  const signal = normalizeSignal(input.signal);
+  const text = boundedExactText(input.text, "inbound text", true);
+  const rawAttachments = input.attachments ?? [];
+  if (!Array.isArray(rawAttachments)) throw new TypeError("inbound attachments must be an array");
+  if (rawAttachments.length > CONVERSATION_ATTACHMENT_MAX_COUNT) {
+    throw new RangeError(
+      `inbound attachments must contain at most ${CONVERSATION_ATTACHMENT_MAX_COUNT} entries`
+    );
+  }
+  const attachments = Object.freeze(
+    rawAttachments.map((attachment) => normalizeAttachment(provider, attachment))
+  );
+  if ((signal.kind === "start" || signal.kind === "continue") && !text && !attachments.length) {
+    throw new TypeError("start and continue signals require text or an attachment reference");
+  }
+  return Object.freeze({
+    schemaVersion: CONVERSATION_INTEGRATION_SCHEMA_VERSION,
+    installation,
+    actor,
+    route,
+    providerEventId,
+    providerMessageId,
+    eventIdentity: deriveConversationEventIdentity(installation, providerEventId),
+    occurredAt,
+    signal,
+    text,
+    attachments
+  });
+}
+function normalizeConversationProviderNamespace(value) {
+  return providerNamespace(value);
+}
+function normalizeConversationInstallationIdentity(input) {
+  assertExactObject(input, "installation identity", ["provider", "providerInstallationId"]);
+  return providerOpaqueId(
+    providerNamespace(input.provider),
+    "installation",
+    input.providerInstallationId
+  );
+}
+function normalizeConversationActor(installation, input) {
+  assertConversationInstallationIdentity(installation);
+  assertExactObject(input, "inbound actor", ["providerActorId", "kind"]);
+  if (input.kind !== "human" && input.kind !== "bot" && input.kind !== "system") {
+    throw new TypeError("inbound actor kind is unsupported");
+  }
+  const providerActorId = providerOpaqueId(installation.provider, "actor", input.providerActorId);
+  return Object.freeze({
+    installation,
+    providerActorId,
+    kind: input.kind,
+    identity: deriveConversationActorIdentity(installation, providerActorId)
+  });
+}
+function normalizeConversationRoute(installation, input) {
+  assertConversationInstallationIdentity(installation);
+  assertExactObject(input, "inbound route", ["providerConversationId", "providerThreadId"]);
+  const providerConversationId = providerOpaqueId(
+    installation.provider,
+    "conversation",
+    input.providerConversationId
+  );
+  const providerThreadId = input.providerThreadId === void 0 || input.providerThreadId === null ? null : providerOpaqueId(installation.provider, "thread", input.providerThreadId);
+  const identity = deriveConversationRouteIdentity(
+    installation,
+    providerConversationId,
+    providerThreadId
+  );
+  return Object.freeze({ installation, providerConversationId, providerThreadId, identity });
+}
+function normalizeConversationDeliveryCommand(input) {
+  const keys = input.kind === "post" ? ["kind", "logicalOperationKey", "installation", "route", "text"] : input.kind === "update" ? [
+    "kind",
+    "logicalOperationKey",
+    "installation",
+    "route",
+    "targetProviderMessageId",
+    "text"
+  ] : ["kind", "logicalOperationKey", "installation", "route", "targetProviderMessageId"];
+  assertExactObject(input, "delivery command", keys);
+  if (input.kind !== "post" && input.kind !== "update" && input.kind !== "delete") {
+    throw new TypeError("delivery command kind is unsupported");
+  }
+  assertConversationInstallationIdentity(input.installation);
+  assertConversationRoute(input.route);
+  assertSameInstallation(input.installation, input.route.installation, "delivery route");
+  const logicalOperationKey = boundedOpaqueString(
+    input.logicalOperationKey,
+    "logical operation key",
+    CONVERSATION_OPERATION_KEY_MAX_UTF8_BYTES
+  );
+  const operationId = deriveConversationOperationIdentity(input.installation, logicalOperationKey);
+  const targetProviderMessageId = input.kind === "post" ? null : providerOpaqueId(input.installation.provider, "message", input.targetProviderMessageId);
+  const text = input.kind === "delete" ? null : boundedExactText(input.text, "delivery text", false);
+  const requestDigest = deliveryRequestDigest({
+    kind: input.kind,
+    installation: input.installation,
+    route: input.route,
+    targetProviderMessageId,
+    text
+  });
+  return Object.freeze({
+    schemaVersion: CONVERSATION_INTEGRATION_SCHEMA_VERSION,
+    operationId,
+    logicalOperationKey,
+    requestDigest,
+    installation: input.installation,
+    route: input.route,
+    kind: input.kind,
+    targetProviderMessageId,
+    text
+  });
+}
+function normalizeConversationProviderReceipt(input) {
+  assertExactObject(input, "provider receipt", [
+    "command",
+    "providerMessageId",
+    "providerReceiptId",
+    "observedAt"
+  ]);
+  assertConversationDeliveryCommand(input.command);
+  const providerMessageId = providerOpaqueId(
+    input.command.installation.provider,
+    "message",
+    input.providerMessageId
+  );
+  if (input.command.targetProviderMessageId && providerMessageId.value !== input.command.targetProviderMessageId.value) {
+    throw new TypeError("provider receipt message does not match the mutation target");
+  }
+  const providerReceiptId = input.providerReceiptId === void 0 || input.providerReceiptId === null ? null : providerOpaqueId(input.command.installation.provider, "receipt", input.providerReceiptId);
+  return Object.freeze({
+    schemaVersion: CONVERSATION_INTEGRATION_SCHEMA_VERSION,
+    operationId: input.command.operationId,
+    requestDigest: input.command.requestDigest,
+    installation: input.command.installation,
+    providerMessageId,
+    providerReceiptId,
+    observedAt: canonicalTimestamp(input.observedAt, "provider receipt observedAt")
+  });
+}
+function normalizeConversationDeliveryOutcome(input) {
+  if (input.status === "success") {
+    assertExactObject(input, "delivery success", ["status", "receipt"]);
+    assertConversationProviderReceipt(input.receipt);
+    return Object.freeze({ status: "success", receipt: input.receipt });
+  }
+  if (input.status === "retryable_failure") {
+    assertExactObject(input, "retryable delivery failure", ["status", "code", "retryAfterMs"]);
+    const retryAfterMs = input.retryAfterMs ?? null;
+    if (retryAfterMs !== null && (!Number.isSafeInteger(retryAfterMs) || retryAfterMs < 0)) {
+      throw new RangeError("retryAfterMs must be a non-negative safe integer or null");
+    }
+    return Object.freeze({
+      status: "retryable_failure",
+      code: outcomeCode(input.code),
+      retryAfterMs
+    });
+  }
+  if (input.status !== "not_started" && input.status !== "unknown" && input.status !== "permanent_failure") {
+    throw new TypeError("delivery outcome status is unsupported");
+  }
+  assertExactObject(input, "delivery outcome", ["status", "code"]);
+  return Object.freeze({ status: input.status, code: outcomeCode(input.code) });
+}
+function conversationDeliveryNextAction(outcome) {
+  assertConversationDeliveryOutcome(outcome);
+  if (outcome.status === "unknown") return "reconcile";
+  if (outcome.status === "not_started" || outcome.status === "retryable_failure") {
+    return "retry_same_operation";
+  }
+  return outcome.status === "success" ? "complete" : "stop";
+}
+function assertConversationDeliveryMayRetry(outcome) {
+  const action = conversationDeliveryNextAction(outcome);
+  if (action === "retry_same_operation") return;
+  if (action === "reconcile") {
+    throw new Error("unknown delivery outcome must be reconciled before retry");
+  }
+  throw new Error(`delivery outcome ${outcome.status} may not be retried`);
+}
+function assertConversationDeliveryCommandMatches(expected, candidate) {
+  assertConversationDeliveryCommand(expected);
+  assertConversationDeliveryCommand(candidate);
+  if (expected.operationId !== candidate.operationId) {
+    throw new Error("delivery operation identity does not match");
+  }
+  if (expected.requestDigest !== candidate.requestDigest) {
+    throw new Error("delivery operation identity was reused for different request content");
+  }
+}
+function assertConversationInboundEnvelope(value) {
+  assertExactObject(value, "normalized inbound envelope", [
+    "schemaVersion",
+    "installation",
+    "actor",
+    "route",
+    "providerEventId",
+    "providerMessageId",
+    "eventIdentity",
+    "occurredAt",
+    "signal",
+    "text",
+    "attachments"
+  ]);
+  if (value.schemaVersion !== CONVERSATION_INTEGRATION_SCHEMA_VERSION) {
+    throw new TypeError("inbound envelope schema version is unsupported");
+  }
+  assertConversationInstallationIdentity(value.installation);
+  assertConversationActor(value.actor);
+  assertConversationRoute(value.route);
+  assertProviderOpaqueId(value.providerEventId, "event");
+  assertProviderOpaqueId(value.providerMessageId, "message");
+  assertSameInstallation(value.installation, value.actor.installation, "inbound actor");
+  assertSameInstallation(value.installation, value.route.installation, "inbound route");
+  assertSameProvider(value.installation.provider, value.providerEventId.provider, "event id");
+  assertSameProvider(value.installation.provider, value.providerMessageId.provider, "message id");
+  const expectedEventIdentity = deriveConversationEventIdentity(
+    value.installation,
+    value.providerEventId
+  );
+  if (value.eventIdentity !== expectedEventIdentity) {
+    throw new TypeError("inbound event identity is not canonical");
+  }
+  canonicalTimestamp(value.occurredAt, "inbound occurredAt");
+  const signal = normalizeSignal(value.signal);
+  const text = boundedExactText(value.text, "inbound text", true);
+  if (!Array.isArray(value.attachments))
+    throw new TypeError("inbound attachments must be an array");
+  if (value.attachments.length > CONVERSATION_ATTACHMENT_MAX_COUNT) {
+    throw new RangeError("inbound attachment count exceeds the contract bound");
+  }
+  for (const attachment of value.attachments) {
+    assertConversationAttachmentReference(attachment);
+    assertSameProvider(
+      value.installation.provider,
+      attachment.providerAttachmentId.provider,
+      "attachment id"
+    );
+  }
+  if ((signal.kind === "start" || signal.kind === "continue") && !text && !value.attachments.length) {
+    throw new TypeError("start and continue signals require text or an attachment reference");
+  }
+}
+function assertConversationDeliveryCommand(value) {
+  assertExactObject(value, "normalized delivery command", [
+    "schemaVersion",
+    "operationId",
+    "logicalOperationKey",
+    "requestDigest",
+    "installation",
+    "route",
+    "kind",
+    "targetProviderMessageId",
+    "text"
+  ]);
+  if (value.schemaVersion !== CONVERSATION_INTEGRATION_SCHEMA_VERSION) {
+    throw new TypeError("delivery command schema version is unsupported");
+  }
+  if (value.kind !== "post" && value.kind !== "update" && value.kind !== "delete") {
+    throw new TypeError("delivery command kind is unsupported");
+  }
+  assertConversationInstallationIdentity(value.installation);
+  assertConversationRoute(value.route);
+  assertSameInstallation(value.installation, value.route.installation, "delivery route");
+  const logicalOperationKey = boundedOpaqueString(
+    value.logicalOperationKey,
+    "logical operation key",
+    CONVERSATION_OPERATION_KEY_MAX_UTF8_BYTES
+  );
+  if (value.operationId !== deriveConversationOperationIdentity(value.installation, logicalOperationKey)) {
+    throw new TypeError("delivery operation identity is not canonical");
+  }
+  let target;
+  let text;
+  if (value.kind === "post") {
+    if (value.targetProviderMessageId !== null) {
+      throw new TypeError("post command cannot carry a target message");
+    }
+    target = null;
+    text = boundedExactText(value.text, "delivery text", false);
+  } else {
+    assertProviderOpaqueId(value.targetProviderMessageId, "message");
+    target = value.targetProviderMessageId;
+    assertSameProvider(value.installation.provider, target.provider, "delivery target");
+    if (value.kind === "delete") {
+      if (value.text !== null) throw new TypeError("delete command cannot carry text");
+      text = null;
+    } else {
+      text = boundedExactText(value.text, "delivery text", false);
+    }
+  }
+  const expectedDigest = deliveryRequestDigest({
+    kind: value.kind,
+    installation: value.installation,
+    route: value.route,
+    targetProviderMessageId: target,
+    text
+  });
+  if (value.requestDigest !== expectedDigest) {
+    throw new TypeError("delivery request digest is not canonical");
+  }
+}
+function assertConversationProviderReceipt(value) {
+  assertExactObject(value, "normalized provider receipt", [
+    "schemaVersion",
+    "operationId",
+    "requestDigest",
+    "installation",
+    "providerMessageId",
+    "providerReceiptId",
+    "observedAt"
+  ]);
+  if (value.schemaVersion !== CONVERSATION_INTEGRATION_SCHEMA_VERSION) {
+    throw new TypeError("provider receipt schema version is unsupported");
+  }
+  assertIdentity(value.operationId, /^ciop1_[0-9a-f]{64}$/u, "provider receipt operation id");
+  assertIdentity(value.requestDigest, /^sha256:[0-9a-f]{64}$/u, "provider receipt request digest");
+  assertConversationInstallationIdentity(value.installation);
+  assertProviderOpaqueId(value.providerMessageId, "message");
+  assertSameProvider(
+    value.installation.provider,
+    value.providerMessageId.provider,
+    "receipt message"
+  );
+  if (value.providerReceiptId !== null) {
+    assertProviderOpaqueId(value.providerReceiptId, "receipt");
+    assertSameProvider(
+      value.installation.provider,
+      value.providerReceiptId.provider,
+      "provider receipt id"
+    );
+  }
+  canonicalTimestamp(value.observedAt, "provider receipt observedAt");
+}
+function assertConversationDeliveryOutcome(value) {
+  normalizeConversationDeliveryOutcome(value);
+}
+function canonicalConversationInboundEnvelopeJson(envelope) {
+  assertConversationInboundEnvelope(envelope);
+  return JSON.stringify({
+    schemaVersion: envelope.schemaVersion,
+    installation: providerIdWire(envelope.installation),
+    actor: actorWire(envelope.actor),
+    route: routeWire(envelope.route),
+    providerEventId: providerIdWire(envelope.providerEventId),
+    providerMessageId: providerIdWire(envelope.providerMessageId),
+    eventIdentity: envelope.eventIdentity,
+    occurredAt: envelope.occurredAt,
+    signal: signalWire(envelope.signal),
+    text: envelope.text,
+    attachments: envelope.attachments.map(attachmentWire)
+  });
+}
+function canonicalConversationDeliveryCommandJson(command) {
+  assertConversationDeliveryCommand(command);
+  return JSON.stringify(deliveryCommandWire(command));
+}
+function canonicalConversationProviderReceiptJson(receipt2) {
+  assertConversationProviderReceipt(receipt2);
+  return JSON.stringify(providerReceiptWire(receipt2));
+}
+function canonicalConversationDeliveryOutcomeJson(outcome) {
+  assertConversationDeliveryOutcome(outcome);
+  if (outcome.status === "success") {
+    return JSON.stringify({ status: "success", receipt: providerReceiptWire(outcome.receipt) });
+  }
+  if (outcome.status === "retryable_failure") {
+    return JSON.stringify({
+      status: outcome.status,
+      code: outcome.code,
+      retryAfterMs: outcome.retryAfterMs
+    });
+  }
+  return JSON.stringify({ status: outcome.status, code: outcome.code });
+}
+function normalizeSignal(input) {
+  assertExactObject(input, "conversation signal", ["kind", "control"]);
+  if (input.kind === "start" || input.kind === "continue") {
+    assertExactObject(input, "conversation signal", ["kind"]);
+    return Object.freeze({ kind: input.kind });
+  }
+  if (input.kind === "control") {
+    assertExactObject(input, "conversation control signal", ["kind", "control"]);
+    if (input.control !== "stop" && input.control !== "resume") {
+      throw new TypeError("conversation control signal is unsupported");
+    }
+    return Object.freeze({ kind: "control", control: input.control });
+  }
+  throw new TypeError("conversation signal is unsupported");
+}
+function normalizeAttachment(provider, input) {
+  assertExactObject(input, "attachment reference", [
+    "providerAttachmentId",
+    "fileName",
+    "mediaType",
+    "byteSize",
+    "contentSha256"
+  ]);
+  if (ABSOLUTE_URL_PATTERN.test(input.providerAttachmentId) || input.providerAttachmentId.startsWith("//")) {
+    throw new TypeError("attachment references cannot contain provider URLs");
+  }
+  const providerAttachmentId = providerOpaqueId(provider, "attachment", input.providerAttachmentId);
+  const fileName = nullableBoundedString(
+    input.fileName,
+    "attachment fileName",
+    CONVERSATION_ATTACHMENT_NAME_MAX_UTF8_BYTES
+  );
+  if (fileName?.includes("/") || fileName?.includes("\\")) {
+    throw new TypeError("attachment fileName must not contain a path");
+  }
+  const mediaType = nullableBoundedString(
+    input.mediaType,
+    "attachment mediaType",
+    CONVERSATION_ATTACHMENT_MEDIA_TYPE_MAX_UTF8_BYTES
+  );
+  if (mediaType !== null && !MEDIA_TYPE_PATTERN.test(mediaType)) {
+    throw new TypeError("attachment mediaType is invalid");
+  }
+  const byteSize = input.byteSize ?? null;
+  if (byteSize !== null && (!Number.isSafeInteger(byteSize) || byteSize < 0)) {
+    throw new RangeError("attachment byteSize must be a non-negative safe integer or null");
+  }
+  const contentSha256 = input.contentSha256 ?? null;
+  if (contentSha256 !== null && !SHA256_PATTERN.test(contentSha256)) {
+    throw new TypeError("attachment contentSha256 must be 64 lowercase hexadecimal characters");
+  }
+  return Object.freeze({
+    providerAttachmentId,
+    fileName,
+    mediaType,
+    byteSize,
+    contentSha256
+  });
+}
+function providerNamespace(value) {
+  const bounded = boundedOpaqueString(
+    value,
+    "provider namespace",
+    CONVERSATION_PROVIDER_NAMESPACE_MAX_UTF8_BYTES
+  );
+  if (!PROVIDER_NAMESPACE_PATTERN.test(bounded)) {
+    throw new TypeError("provider namespace must be canonical lowercase segments");
+  }
+  return bounded;
+}
+function providerOpaqueId(provider, kind, value) {
+  return Object.freeze({
+    provider,
+    kind,
+    value: boundedOpaqueString(
+      value,
+      `provider ${kind} id`,
+      CONVERSATION_PROVIDER_OPAQUE_ID_MAX_UTF8_BYTES
+    )
+  });
+}
+function deriveConversationEventIdentity(installation, providerEventId) {
+  return `ciev1_${hashParts("opengeni:conversation-event:v1", [
+    installation.provider,
+    installation.value,
+    providerEventId.value
+  ])}`;
+}
+function deriveConversationRouteIdentity(installation, conversationId, threadId) {
+  return `cirt1_${hashParts("opengeni:conversation-route:v1", [
+    installation.provider,
+    installation.value,
+    conversationId.value,
+    threadId?.value ?? null
+  ])}`;
+}
+function deriveConversationActorIdentity(installation, actorId) {
+  return `ciac1_${hashParts("opengeni:conversation-actor:v1", [
+    installation.provider,
+    installation.value,
+    actorId.value
+  ])}`;
+}
+function deriveConversationOperationIdentity(installation, logicalOperationKey) {
+  return `ciop1_${hashParts("opengeni:conversation-operation:v1", [
+    installation.provider,
+    installation.value,
+    logicalOperationKey
+  ])}`;
+}
+function deliveryRequestDigest(input) {
+  return `sha256:${createHash5("sha256").update("opengeni:conversation-delivery-request:v1\0", "utf8").update(
+    JSON.stringify({
+      kind: input.kind,
+      installation: providerIdWire(input.installation),
+      route: routeWire(input.route),
+      targetProviderMessageId: input.targetProviderMessageId ? providerIdWire(input.targetProviderMessageId) : null,
+      text: input.text
+    }),
+    "utf8"
+  ).digest("hex")}`;
+}
+function hashParts(domain, parts) {
+  const hash = createHash5("sha256");
+  hash.update(domain, "utf8").update("\0", "utf8");
+  for (const part of parts) {
+    if (part === null) {
+      hash.update("n:", "utf8");
+      continue;
+    }
+    const bytes = textEncoder.encode(part);
+    hash.update(`s:${bytes.byteLength}:`, "utf8").update(bytes);
+  }
+  return hash.digest("hex");
+}
+function assertConversationInstallationIdentity(value) {
+  assertProviderOpaqueId(value, "installation");
+}
+function assertConversationActor(value) {
+  assertExactObject(value, "normalized conversation actor", [
+    "installation",
+    "providerActorId",
+    "kind",
+    "identity"
+  ]);
+  assertConversationInstallationIdentity(value.installation);
+  assertProviderOpaqueId(value.providerActorId, "actor");
+  if (value.kind !== "human" && value.kind !== "bot" && value.kind !== "system") {
+    throw new TypeError("conversation actor kind is unsupported");
+  }
+  assertSameProvider(value.installation.provider, value.providerActorId.provider, "actor id");
+  if (value.identity !== deriveConversationActorIdentity(value.installation, value.providerActorId)) {
+    throw new TypeError("conversation actor identity is not canonical");
+  }
+}
+function assertConversationRoute(value) {
+  assertExactObject(value, "normalized conversation route", [
+    "installation",
+    "providerConversationId",
+    "providerThreadId",
+    "identity"
+  ]);
+  assertConversationInstallationIdentity(value.installation);
+  assertProviderOpaqueId(value.providerConversationId, "conversation");
+  if (value.providerThreadId !== null) assertProviderOpaqueId(value.providerThreadId, "thread");
+  assertSameProvider(
+    value.installation.provider,
+    value.providerConversationId.provider,
+    "conversation id"
+  );
+  if (value.providerThreadId) {
+    assertSameProvider(value.installation.provider, value.providerThreadId.provider, "thread id");
+  }
+  if (value.identity !== deriveConversationRouteIdentity(
+    value.installation,
+    value.providerConversationId,
+    value.providerThreadId
+  )) {
+    throw new TypeError("conversation route identity is not canonical");
+  }
+}
+function assertConversationAttachmentReference(value) {
+  assertExactObject(value, "normalized attachment reference", [
+    "providerAttachmentId",
+    "fileName",
+    "mediaType",
+    "byteSize",
+    "contentSha256"
+  ]);
+  assertProviderOpaqueId(value.providerAttachmentId, "attachment");
+  if (ABSOLUTE_URL_PATTERN.test(value.providerAttachmentId.value) || value.providerAttachmentId.value.startsWith("//")) {
+    throw new TypeError("attachment references cannot contain provider URLs");
+  }
+  const fileName = nullableBoundedString(
+    value.fileName,
+    "attachment fileName",
+    CONVERSATION_ATTACHMENT_NAME_MAX_UTF8_BYTES
+  );
+  if (fileName?.includes("/") || fileName?.includes("\\")) {
+    throw new TypeError("attachment fileName must not contain a path");
+  }
+  const mediaType = nullableBoundedString(
+    value.mediaType,
+    "attachment mediaType",
+    CONVERSATION_ATTACHMENT_MEDIA_TYPE_MAX_UTF8_BYTES
+  );
+  if (mediaType !== null && !MEDIA_TYPE_PATTERN.test(mediaType)) {
+    throw new TypeError("attachment mediaType is invalid");
+  }
+  const byteSize = value.byteSize;
+  if (byteSize !== null) {
+    if (typeof byteSize !== "number" || !Number.isSafeInteger(byteSize) || byteSize < 0) {
+      throw new RangeError("attachment byteSize must be a non-negative safe integer or null");
+    }
+  }
+  const contentSha256 = value.contentSha256;
+  if (contentSha256 !== null) {
+    if (typeof contentSha256 !== "string" || !SHA256_PATTERN.test(contentSha256)) {
+      throw new TypeError("attachment contentSha256 must be 64 lowercase hexadecimal characters");
+    }
+  }
+}
+function assertProviderOpaqueId(value, kind) {
+  assertExactObject(value, `provider ${kind} id`, ["provider", "kind", "value"]);
+  providerNamespace(value.provider);
+  if (value.kind !== kind) throw new TypeError(`provider id must have kind ${kind}`);
+  boundedOpaqueString(
+    value.value,
+    `provider ${kind} id`,
+    CONVERSATION_PROVIDER_OPAQUE_ID_MAX_UTF8_BYTES
+  );
+}
+function assertSameProvider(expected, actual, label) {
+  if (expected !== actual) throw new TypeError(`${label} provider namespace does not match`);
+}
+function assertSameInstallation(expected, actual, label) {
+  if (expected.provider !== actual.provider || expected.value !== actual.value) {
+    throw new TypeError(`${label} installation identity does not match`);
+  }
+}
+function boundedExactText(value, label, allowEmpty) {
+  return boundedString(value, label, allowEmpty ? 0 : 1, CONVERSATION_TEXT_MAX_UTF8_BYTES, true);
+}
+function boundedOpaqueString(value, label, maxBytes) {
+  const result = boundedString(value, label, 1, maxBytes, false);
+  if (result !== result.trim())
+    throw new TypeError(`${label} must not have surrounding whitespace`);
+  return result;
+}
+function nullableBoundedString(value, label, maxBytes) {
+  if (value === void 0 || value === null) return null;
+  return boundedString(value, label, 1, maxBytes, false);
+}
+function boundedString(value, label, minBytes, maxBytes, allowNewlines) {
+  if (typeof value !== "string") throw new TypeError(`${label} must be a string`);
+  if (!isWellFormedUnicode(value)) throw new TypeError(`${label} must be well-formed Unicode`);
+  if (value.includes("\0")) throw new TypeError(`${label} must not contain NUL`);
+  if (!allowNewlines && /[\u0001-\u001f\u007f]/u.test(value)) {
+    throw new TypeError(`${label} must not contain control characters`);
+  }
+  const byteLength = textEncoder.encode(value).byteLength;
+  if (byteLength < minBytes || byteLength > maxBytes) {
+    throw new RangeError(`${label} must contain ${minBytes}-${maxBytes} UTF-8 bytes`);
+  }
+  return value;
+}
+function isWellFormedUnicode(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) return false;
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function canonicalTimestamp(value, label) {
+  const timestamp = boundedString(value, label, 20, 32, false);
+  const milliseconds = Date.parse(timestamp);
+  if (!Number.isFinite(milliseconds) || new Date(milliseconds).toISOString() !== timestamp) {
+    throw new TypeError(`${label} must be a canonical UTC timestamp`);
+  }
+  return timestamp;
+}
+function outcomeCode(value) {
+  const code = boundedOpaqueString(
+    value,
+    "delivery outcome code",
+    CONVERSATION_OUTCOME_CODE_MAX_UTF8_BYTES
+  );
+  if (!OUTCOME_CODE_PATTERN.test(code)) {
+    throw new TypeError("delivery outcome code must use canonical lowercase segments");
+  }
+  return code;
+}
+function assertExactObject(value, label, allowedKeys) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${label} must be an object`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError(`${label} must be a plain object`);
+  }
+  const allowed = new Set(allowedKeys);
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string" || !allowed.has(key)) {
+      throw new TypeError(`${label} contains an unsupported field`);
+    }
+  }
+}
+function assertIdentity(value, pattern, label) {
+  if (typeof value !== "string" || !pattern.test(value)) {
+    throw new TypeError(`${label} is invalid`);
+  }
+}
+function providerIdWire(id) {
+  return { provider: id.provider, kind: id.kind, value: id.value };
+}
+function actorWire(actor) {
+  return {
+    installation: providerIdWire(actor.installation),
+    providerActorId: providerIdWire(actor.providerActorId),
+    kind: actor.kind,
+    identity: actor.identity
+  };
+}
+function routeWire(route) {
+  return {
+    installation: providerIdWire(route.installation),
+    providerConversationId: providerIdWire(route.providerConversationId),
+    providerThreadId: route.providerThreadId ? providerIdWire(route.providerThreadId) : null,
+    identity: route.identity
+  };
+}
+function signalWire(signal) {
+  return signal.kind === "control" ? { kind: "control", control: signal.control } : { kind: signal.kind };
+}
+function attachmentWire(attachment) {
+  return {
+    providerAttachmentId: providerIdWire(attachment.providerAttachmentId),
+    fileName: attachment.fileName,
+    mediaType: attachment.mediaType,
+    byteSize: attachment.byteSize,
+    contentSha256: attachment.contentSha256
+  };
+}
+function deliveryCommandWire(command) {
+  return {
+    schemaVersion: command.schemaVersion,
+    operationId: command.operationId,
+    logicalOperationKey: command.logicalOperationKey,
+    requestDigest: command.requestDigest,
+    installation: providerIdWire(command.installation),
+    route: routeWire(command.route),
+    kind: command.kind,
+    targetProviderMessageId: command.targetProviderMessageId ? providerIdWire(command.targetProviderMessageId) : null,
+    text: command.text
+  };
+}
+function providerReceiptWire(receipt2) {
+  return {
+    schemaVersion: receipt2.schemaVersion,
+    operationId: receipt2.operationId,
+    requestDigest: receipt2.requestDigest,
+    installation: providerIdWire(receipt2.installation),
+    providerMessageId: providerIdWire(receipt2.providerMessageId),
+    providerReceiptId: receipt2.providerReceiptId ? providerIdWire(receipt2.providerReceiptId) : null,
+    observedAt: receipt2.observedAt
+  };
+}
+
 // src/domain/workspace-members.ts
-import { HTTPException as HTTPException14 } from "hono/http-exception";
+import { HTTPException as HTTPException13 } from "hono/http-exception";
 var MEMBER_ADMIN_PERMISSIONS = ["workspace:admin", "members:manage"];
 function memberCanAdminister(member) {
   return member.permissions.some((permission) => MEMBER_ADMIN_PERMISSIONS.includes(permission));
@@ -8499,25 +9441,25 @@ function isUserMember(member) {
 }
 function resolveMemberSubjectId(userId) {
   if (!userId) {
-    throw new HTTPException14(404, { message: "user is not registered" });
+    throw new HTTPException13(404, { message: "user is not registered" });
   }
   return `user:${userId}`;
 }
 function assertWorkspaceMemberRemovable(input) {
   const { members, subjectId, callerSubjectId } = input;
   if (subjectId === callerSubjectId) {
-    throw new HTTPException14(409, { message: "you cannot remove your own membership" });
+    throw new HTTPException13(409, { message: "you cannot remove your own membership" });
   }
   const target = members.find((member) => member.subjectId === subjectId);
   if (!target) {
-    throw new HTTPException14(404, { message: "member not found" });
+    throw new HTTPException13(404, { message: "member not found" });
   }
   if (memberCanAdminister(target)) {
     const remainingAdmins = members.filter(
       (member) => member.subjectId !== subjectId && memberCanAdminister(member)
     );
     if (remainingAdmins.length === 0) {
-      throw new HTTPException14(409, {
+      throw new HTTPException13(409, {
         message: "cannot remove the last member who can manage this workspace"
       });
     }
@@ -8525,10 +9467,10 @@ function assertWorkspaceMemberRemovable(input) {
 }
 function assertWorkspaceDeletable(input) {
   if (input.workspaceCountForAccount <= 1) {
-    throw new HTTPException14(409, { message: "cannot delete the account's only workspace" });
+    throw new HTTPException13(409, { message: "cannot delete the account's only workspace" });
   }
   if (input.activeSessionCount > 0) {
-    throw new HTTPException14(409, {
+    throw new HTTPException13(409, {
       message: "stop the workspace's running sessions before deleting it"
     });
   }
@@ -8538,7 +9480,7 @@ function assertWorkspaceDeletable(input) {
 import {
   GenerateVideoToolInput
 } from "@opengeni/contracts";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var VIDEO_GENERATION_ADAPTER_VERSION = "gateway-video-v4/1";
 var TERMINAL_STATES = /* @__PURE__ */ new Set([
   "completed",
@@ -8677,13 +9619,14 @@ function assertReferenceRoles(sourceMode, references) {
   }
 }
 function sha2562(prefix, ...parts) {
-  const hash = createHash5("sha256").update(prefix);
+  const hash = createHash6("sha256").update(prefix);
   for (const part of parts) hash.update(part).update("\0");
   return hash.digest("hex");
 }
 
 // src/domain/video-generation-capabilities.ts
 import {
+  GROK_IMAGINE_VIDEO_1_5_MODEL_ID,
   SEEDANCE_2_5_MODEL_ID,
   VideoGenerationCapabilities,
   VideoGenerationPolicy
@@ -8702,10 +9645,32 @@ var VIDEO_GENERATION_MODEL_CATALOG = Object.freeze([
     ]),
     resolutions: Object.freeze(["480p", "720p"]),
     aspectRatios: Object.freeze(["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"]),
-    duration: Object.freeze({ minSeconds: 4, maxSeconds: 30, stepSeconds: 1 }),
+    duration: Object.freeze({
+      minSeconds: 4,
+      maxSeconds: 30,
+      stepSeconds: 1
+    }),
+    supportsAudio: true
+  }),
+  Object.freeze({
+    modelId: GROK_IMAGINE_VIDEO_1_5_MODEL_ID,
+    label: "Grok Imagine Video 1.5",
+    providerLabel: "Connected SuperGrok",
+    sourceModes: Object.freeze(["text", "first_frame", "image_reference"]),
+    resolutions: Object.freeze(["480p", "720p"]),
+    aspectRatios: Object.freeze(["16:9", "4:3", "1:1", "3:4", "9:16"]),
+    duration: Object.freeze({
+      minSeconds: 4,
+      maxSeconds: 15,
+      stepSeconds: 1
+    }),
+    // xAI emits audio but exposes no separate audio wire option.
     supportsAudio: true
   })
 ]);
+function videoGenerationModelSupportsFundingSource(modelId, fundingSource) {
+  return modelId === GROK_IMAGINE_VIDEO_1_5_MODEL_ID ? fundingSource === "supergrok_subscription" : modelId === SEEDANCE_2_5_MODEL_ID ? fundingSource === "opengeni_credits" || fundingSource === "workspace_gateway" : false;
+}
 function defaultVideoGenerationPolicy() {
   return VideoGenerationPolicy.parse({
     schemaVersion: 1,
@@ -8718,7 +9683,9 @@ function defaultVideoGenerationPolicy() {
 function videoGenerationCapabilitiesForPolicy(input) {
   const policy = VideoGenerationPolicy.parse(input.policy);
   const enabled = new Set(policy.enabledModelIds);
-  const models = VIDEO_GENERATION_MODEL_CATALOG.filter((model) => enabled.has(model.modelId));
+  const models = VIDEO_GENERATION_MODEL_CATALOG.filter(
+    (model) => enabled.has(model.modelId) && videoGenerationModelSupportsFundingSource(model.modelId, policy.fundingSource)
+  );
   if (models.length === 0 || policy.defaultModelId === null) {
     throw new Error("Video generation is disabled for this workspace");
   }
@@ -8751,7 +9718,7 @@ import {
   getEnrollment as getEnrollment4,
   getRig as getRig5,
   getSandbox as getSandbox4,
-  getVariableSet as getVariableSet5,
+  getVariableSet as getVariableSet4,
   NewSessionDraftAccessError,
   newSessionDraftToolsProvided,
   publicNewSessionDraftOptions,
@@ -8759,7 +9726,7 @@ import {
   saveNewSessionDraftInTransaction,
   withWorkspaceSubjectRls
 } from "@opengeni/db";
-import { HTTPException as HTTPException15 } from "hono/http-exception";
+import { HTTPException as HTTPException14 } from "hono/http-exception";
 function hasOwn(value, key) {
   return typeof value === "object" && value !== null && Object.hasOwn(value, key);
 }
@@ -8810,7 +9777,7 @@ async function hydrateNewSessionDraft(deps, grant, workspaceId, row) {
   }
   const options = { ...mapped.options };
   if (options.variableSetId) {
-    if (!hasPermission(grant.permissions, "variable-sets:use") || !await getVariableSet5(deps.db, workspaceId, options.variableSetId)) {
+    if (!hasPermission(grant.permissions, "variable-sets:use") || !await getVariableSet4(deps.db, workspaceId, options.variableSetId)) {
       delete options.variableSetId;
     }
   }
@@ -8885,7 +9852,7 @@ async function saveActorNewSessionDraft(deps, grant, workspaceId, rawInput) {
   const tools = toolsProvided ? validateToolRefs(input.tools, runtimeSettings) : [];
   await validateGitHubRepositorySelection(deps.db, workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !deps.objectStorage) {
-    throw new HTTPException15(503, { message: "object storage is not configured" });
+    throw new HTTPException14(503, { message: "object storage is not configured" });
   }
   await validateFileResources(deps.db, workspaceId, resources);
   assertConfiguredModel(deps.settings, input.model);
@@ -8920,7 +9887,7 @@ async function saveActorNewSessionDraft(deps, grant, workspaceId, rawInput) {
     return mapNewSessionDraft(saved);
   } catch (error) {
     if (error instanceof NewSessionDraftAccessError) {
-      throw new HTTPException15(403, { message: error.message });
+      throw new HTTPException14(403, { message: error.message });
     }
     throw error;
   }
@@ -9465,6 +10432,15 @@ async function saveHumanComposerDraft(deps, context, input) {
 }
 export {
   CODEX_COMPACTION_V2_PROVIDER_LOCKED,
+  CONVERSATION_ATTACHMENT_MAX_COUNT,
+  CONVERSATION_ATTACHMENT_MEDIA_TYPE_MAX_UTF8_BYTES,
+  CONVERSATION_ATTACHMENT_NAME_MAX_UTF8_BYTES,
+  CONVERSATION_INTEGRATION_SCHEMA_VERSION,
+  CONVERSATION_OPERATION_KEY_MAX_UTF8_BYTES,
+  CONVERSATION_OUTCOME_CODE_MAX_UTF8_BYTES,
+  CONVERSATION_PROVIDER_NAMESPACE_MAX_UTF8_BYTES,
+  CONVERSATION_PROVIDER_OPAQUE_ID_MAX_UTF8_BYTES,
+  CONVERSATION_TEXT_MAX_UTF8_BYTES,
   CodexCompactionV2ProviderLockedError,
   DEFAULT_MEMORY_SLACK_PUBLICATION_POLICY,
   EDITABLE_ARTIFACT_COMPACTION_BYTE_THRESHOLD,
@@ -9570,6 +10546,12 @@ export {
   assertBoundedKernelVersion,
   assertBoundedOpaqueReference,
   assertConfiguredModel,
+  assertConversationDeliveryCommand,
+  assertConversationDeliveryCommandMatches,
+  assertConversationDeliveryMayRetry,
+  assertConversationDeliveryOutcome,
+  assertConversationInboundEnvelope,
+  assertConversationProviderReceipt,
   assertIsoTimestamp,
   assertKnownVideoGenerationModelIds,
   assertNonnegativeSafeInteger,
@@ -9588,6 +10570,10 @@ export {
   buildFleetContextForSession,
   buildMarketingDailyAnalysisAgentConfig,
   canonicalConfiguredModel,
+  canonicalConversationDeliveryCommandJson,
+  canonicalConversationDeliveryOutcomeJson,
+  canonicalConversationInboundEnvelopeJson,
+  canonicalConversationProviderReceiptJson,
   canonicalVideoGenerationRequestJson,
   capabilityPackManifestDigest,
   capabilityPackRequiresInstallationPlan,
@@ -9603,6 +10589,7 @@ export {
   controlHumanSessionWorkstream,
   controlHumanSessionWorkstreamWithOutcome,
   controlHumanWorkspace,
+  conversationDeliveryNextAction,
   correctWorkspaceMemoryWithSlackPublication,
   createAndStartSession,
   createAndStartSessionWithOutcome,
@@ -9660,6 +10647,7 @@ export {
   encodeEditableArtifactLiveServerWireFrame,
   evaluateMemorySlackPublication,
   executeRunOnSelfhostedMachine,
+  fikenConnectionMetadata,
   filenameForMimeType,
   freezePersonalConnectionDelegations,
   getActorNewSessionDraft,
@@ -9669,6 +10657,7 @@ export {
   getWorkspaceInsights,
   hasLiteralPermission,
   hasPermission,
+  hasReservedFikenMetadata,
   hasReservedOpenGeniSlackBotMetadata,
   hasReservedOpenGeniSlackBotSessionMetadata,
   hashEditableArtifactCreateRequest,
@@ -9678,6 +10667,7 @@ export {
   isAcceptedMimeType,
   isAuthoritativeGitHubRepositorySelectionError,
   isBuiltInCapabilityPack,
+  isFikenConnection,
   isOpenGeniSlackBotConnection,
   isTerminalVideoGenerationState,
   isTrustedScheduledSlackBotSession,
@@ -9696,6 +10686,14 @@ export {
   mergeToolRefs,
   moveHumanQueuePrompt,
   nativeConnectionCapabilityRecommendations,
+  normalizeConversationActor,
+  normalizeConversationDeliveryCommand,
+  normalizeConversationDeliveryOutcome,
+  normalizeConversationInboundEnvelope,
+  normalizeConversationInstallationIdentity,
+  normalizeConversationProviderNamespace,
+  normalizeConversationProviderReceipt,
+  normalizeConversationRoute,
   normalizeMimeType,
   normalizeResources,
   normalizeVideoGenerationRequest,
@@ -9711,6 +10709,7 @@ export {
   portableSkillCapabilityId,
   portableSkillPluginKey,
   postUserMessageTurn,
+  preferredFikenConnection,
   previewCapabilityPackInstallation,
   promoteSetupAppendChange,
   promoteVerifiedDefinitionEditChangeForApi,
@@ -9744,6 +10743,7 @@ export {
   requireVariableSetForApi,
   resolveCapabilityPack,
   resolveCodexAppsCredentialIdForRun,
+  resolveFikenDefaultCompanySlug,
   resolveFirstPartyMcpToolsForCreate,
   resolveMemberSubjectId,
   resolveSessionToolPolicy,
@@ -9771,6 +10771,7 @@ export {
   searchCapabilityCatalogItems,
   selectedPersonalConnectionServers,
   sendAgentSessionMessage,
+  sessionRlsActorForAuthorization,
   sessionSpawnDenialEnvelope,
   sessionWithEffectiveToolPolicy,
   settingsWithApiIntegrationServers,
@@ -9806,10 +10807,12 @@ export {
   videoGenerationAdmissionKey,
   videoGenerationCapabilitiesForPolicy,
   videoGenerationCapabilityRevision,
+  videoGenerationModelSupportsFundingSource,
   videoGenerationProviderIdempotencyKey,
   videoGenerationRequestDigest,
   withDefaultEnabledCapabilityMcpTools,
   withFrozenPersonalConnectionDelegations,
+  withResolvedSessionAuthorization,
   workflowIdForSession,
   workspaceSessionToolPolicyDefaultServerIds,
   workspaceSessionToolPolicyServerIds,