@opengeni/core 5.1.1 → 5.2.0-canary.37090756480001

package/dist/index.js

@@ -419,6 +419,57 @@ async function readSessionAttachmentFiles(deps, grant, sessionId, fileIds) {
   return [...ordinary, ...shared];
 }
 
+// src/domain/direct-model-provider.ts
+import { DirectModelProviderMetadata } from "@opengeni/contracts";
+import { HTTPException } from "hono/http-exception";
+async function verifyDirectModelAccess(input, apiKey, fetchImpl = fetch) {
+  const config = DirectModelProviderMetadata.parse(input);
+  const baseUrl = config.provider === "openai" ? "https://api.openai.com/v1" : config.endpoint;
+  let response;
+  try {
+    response = await fetchImpl(`${baseUrl}/responses`, {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(15e3),
+      headers: {
+        "content-type": "application/json",
+        ...config.provider === "openai" ? { authorization: `Bearer ${apiKey}` } : { "api-key": apiKey }
+      },
+      body: JSON.stringify({
+        model: config.model,
+        input: "Reply OK.",
+        max_output_tokens: 32,
+        store: false
+      })
+    });
+  } catch {
+    throw new HTTPException(502, {
+      message: "We couldn\u2019t reach your model provider. Check the endpoint and try again."
+    });
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new HTTPException(422, {
+      message: "Your provider didn\u2019t accept this API key. Check the key and its permissions."
+    });
+  }
+  if (response.status === 404 || response.status === 400) {
+    throw new HTTPException(422, {
+      message: config.provider === "azure_openai" ? "Azure couldn\u2019t use this deployment. Check the endpoint and deployment name." : "OpenAI couldn\u2019t use this model. Check the model name and your account\u2019s access."
+    });
+  }
+  if (response.status === 429) {
+    throw new HTTPException(422, {
+      message: "Your provider\u2019s quota or rate limit blocked the check. Check your provider billing or try again shortly."
+    });
+  }
+  const body = response.ok ? await response.json().catch(() => null) : null;
+  if (!body || !["completed", "incomplete"].includes(body.status)) {
+    throw new HTTPException(502, {
+      message: "Your provider couldn\u2019t complete the connection check. Try again shortly."
+    });
+  }
+}
+
 // src/domain/skills.ts
 import { validateSkillTextFiles } from "@opengeni/contracts";
 import { buildPortableSkillArtifact } from "@opengeni/runtime/skill-library";
@@ -509,9 +560,9 @@ import {
 } from "@opengeni/contracts";
 
 // src/domain/connection-account-selection-error.ts
-import { HTTPException } from "hono/http-exception";
+import { HTTPException as HTTPException2 } from "hono/http-exception";
 import { ConnectionAccountSelectionDiagnostic } from "@opengeni/contracts";
-var ConnectionAccountSelectionError = class extends HTTPException {
+var ConnectionAccountSelectionError = class extends HTTPException2 {
   name = "ConnectionAccountSelectionError";
   diagnostic;
   constructor(message, diagnostic = {
@@ -677,7 +728,7 @@ import {
   mcpServerIdForCapability,
   upsertCapabilityCatalogItem
 } from "@opengeni/db";
-import { HTTPException as HTTPException5 } from "hono/http-exception";
+import { HTTPException as HTTPException6 } from "hono/http-exception";
 import {
   withOrganizationIntegrationAcquisition,
   withOrganizationIntegrationPolicyFence
@@ -699,6 +750,7 @@ import {
   bootstrapWorkspace,
   ensureManagedAccessForUser,
   ensureExternalIdentity,
+  lockExternalWorkspaceMembershipLifecycle,
   resolveExternalIdentityLink,
   managedPersonalWorkspacePermissions,
   nestedPostgresSqlState,
@@ -710,22 +762,22 @@ import {
   requireWorkspace,
   resolveNamedManagedPersonalWorkspaceGrant
 } from "@opengeni/db";
-import { HTTPException as HTTPException3 } from "hono/http-exception";
+import { HTTPException as HTTPException4 } from "hono/http-exception";
 
 // src/access/service-initiator.ts
 import { ServiceTurnInitiatorContext } from "@opengeni/contracts";
-import { HTTPException as HTTPException2 } from "hono/http-exception";
+import { HTTPException as HTTPException3 } from "hono/http-exception";
 function serviceInitiatorFromHeaders(headers) {
   const name = headers.get("x-opengeni-service-initiator");
   const rawContext = headers.get("x-opengeni-service-context");
   if (name === null && rawContext === null) return null;
   if (headers.has("x-opengeni-external-actor")) {
-    throw new HTTPException2(422, {
+    throw new HTTPException3(422, {
       message: "service initiator and external actor (asUser) are mutually exclusive"
     });
   }
   if (name === null || !/^[a-z0-9][a-z0-9:._-]{0,63}$/.test(name)) {
-    throw new HTTPException2(422, {
+    throw new HTTPException3(422, {
       message: "x-opengeni-service-initiator must match ^[a-z0-9][a-z0-9:._-]{0,63}$"
     });
   }
@@ -742,7 +794,7 @@ function serviceInitiatorFromHeaders(headers) {
       context = parsed;
       if (!ServiceTurnInitiatorContext.safeParse(context).success) throw new Error("reserved");
     } catch {
-      throw new HTTPException2(422, {
+      throw new HTTPException3(422, {
         message: "x-opengeni-service-context must be a JSON object of flat string/number/boolean values, at most 2048 UTF-8 bytes, without reserved OpenGeni provenance fields"
       });
     }
@@ -773,12 +825,12 @@ function isDeveloperSetupDelegatedPermissionAllowed(permission) {
 }
 function requireApiKeyManagementContext(context) {
   if (developerSetupApiKeyContexts.has(context)) {
-    throw new HTTPException3(403, { message: "Developer setup keys cannot manage API keys" });
+    throw new HTTPException4(403, { message: "Developer setup keys cannot manage API keys" });
   }
 }
 function requireApiKeyDelegationContext(context, permissions) {
   if ((hasPermission(permissions, "api_keys:manage") || hasPermission(permissions, "members:manage")) && developerSetupApiKeyContexts.has(context)) {
-    throw new HTTPException3(403, {
+    throw new HTTPException4(403, {
       message: "Setup credentials cannot delegate API key management"
     });
   }
@@ -899,7 +951,7 @@ async function requireAccessContext(c, deps) {
   }
   const context = await pending;
   if (!context) {
-    throw new HTTPException3(401, { message: "authentication required" });
+    throw new HTTPException4(401, { message: "authentication required" });
   }
   return context;
 }
@@ -909,7 +961,7 @@ async function requireAccessGrant(c, deps, workspaceId, permission) {
 async function requireFreshAccessGrant(c, deps, workspaceId, permission) {
   const context = await resolveAccessContext(c, deps);
   if (!context) {
-    throw new HTTPException3(401, { message: "authentication required" });
+    throw new HTTPException4(401, { message: "authentication required" });
   }
   return (await accessGrantAuthorization(context, deps, workspaceId, permission)).grant;
 }
@@ -956,7 +1008,7 @@ function accessGrantAuthorizationFromContext(context, grant) {
 function requireAccountAdminAuthorizationStamp(authorization) {
   const { grant, accountGrant } = authorization;
   if (!resolvedAccessGrantAuthorizations.has(authorization) || !authorization.contextIntegrity || authorization.authenticatedSubjectId !== grant.subjectId || accountGrant?.accountId !== grant.accountId || accountGrant.subjectId !== grant.subjectId || !accountGrant.permissions.includes("account:admin")) {
-    throw new HTTPException3(403, { message: "missing permission: account:admin" });
+    throw new HTTPException4(403, { message: "missing permission: account:admin" });
   }
   return Object.freeze({
     authorizationId: crypto.randomUUID(),
@@ -968,24 +1020,24 @@ function requireAccountAdminAuthorizationStamp(authorization) {
 function requireResolvedAccessGrantAuthorization(authorization, workspaceId) {
   const { grant } = authorization;
   if (!resolvedAccessGrantAuthorizations.has(authorization) || !authorization.contextIntegrity || authorization.authenticatedSubjectId !== grant.subjectId || grant.workspaceId !== workspaceId) {
-    throw new HTTPException3(403, { message: "workspace access authorization is invalid" });
+    throw new HTTPException4(403, { message: "workspace access authorization is invalid" });
   }
   return grant;
 }
 async function requireCanonicalLocalAccountAdministrator(c, deps, accountId) {
   if (c.req.header("authorization")) {
-    throw new HTTPException3(401, { message: "organization administrator session required" });
+    throw new HTTPException4(401, { message: "organization administrator session required" });
   }
   const context = await requireAccessContext(c, deps);
   const grant = context.workspaceGrants.find((candidate) => candidate.accountId === accountId);
   if (!grant) {
-    throw new HTTPException3(403, {
+    throw new HTTPException4(403, {
       message: "local organization administration is not authorized"
     });
   }
   const authorization = accessGrantAuthorizationFromContext(context, grant);
   if (!authorization.canonicalLocalHumanSession) {
-    throw new HTTPException3(401, { message: "organization administrator session required" });
+    throw new HTTPException4(401, { message: "organization administrator session required" });
   }
   requireAccountAdminAuthorizationStamp(authorization);
   return { subjectId: context.subjectId, authorization };
@@ -1005,7 +1057,7 @@ async function requireWorkspaceSettingsGrant(c, deps, workspaceId) {
   })) {
     return grant;
   }
-  throw new HTTPException3(403, {
+  throw new HTTPException4(403, {
     message: "workspace settings require a workspace administrator or Personal workspace owner"
   });
 }
@@ -1027,7 +1079,7 @@ async function accessGrantAuthorization(context, deps, workspaceId, permission)
       })
     );
     if (!grant2 || grant2.accountId !== external.identity.accountId) {
-      throw new HTTPException3(403, { message: "external workspace access denied" });
+      throw new HTTPException4(403, { message: "external workspace access denied" });
     }
     grant2.permissions = Permission.options.filter(
       (value) => hasPermission(grant2.permissions, value) && hasPermission(external.permissions, value) && (!external.linked || hasPermission(external.linked.link.permissions, value))
@@ -1050,7 +1102,7 @@ async function accessGrantAuthorization(context, deps, workspaceId, permission)
     const authority = accountScopedApiKeyWorkspaceAuthority(context);
     const workspace = await requireWorkspace(deps.db, workspaceId);
     if (!authority || workspace.accountId !== authority.accountId || workspace.kind !== "shared") {
-      throw new HTTPException3(403, {
+      throw new HTTPException4(403, {
         message: "Developer setup requires a shared organization workspace"
       });
     }
@@ -1065,7 +1117,7 @@ async function accessGrantAuthorization(context, deps, workspaceId, permission)
   if (!grant) {
     const workspace = await requireWorkspace(deps.db, workspaceId).catch(() => null);
     if (!workspace) {
-      throw new HTTPException3(404, { message: "workspace not found" });
+      throw new HTTPException4(404, { message: "workspace not found" });
     }
     const authority = accountScopedApiKeyWorkspaceAuthority(context);
     const requiredWorkspacePermission = permission ?? "workspace:read";
@@ -1080,7 +1132,7 @@ async function accessGrantAuthorization(context, deps, workspaceId, permission)
         ...apiKeyServiceContexts.get(context)
       };
     } else {
-      throw new HTTPException3(403, { message: "workspace access denied" });
+      throw new HTTPException4(403, { message: "workspace access denied" });
     }
   }
   if (permission) {
@@ -1105,23 +1157,23 @@ function hostedHumanSessionPrincipalKind(context) {
 function requirePermission(grant, permission) {
   if (!hasPermission(grant.permissions, permission)) {
     if (permission === "variable-sets:use") {
-      throw new HTTPException3(403, {
+      throw new HTTPException4(403, {
         message: "missing permission: variable-sets:use (deprecated alias: environments:use)"
       });
     }
     if (permission === "variable-sets:manage") {
-      throw new HTTPException3(403, {
+      throw new HTTPException4(403, {
         message: "missing permission: variable-sets:manage (deprecated alias: environments:manage)"
       });
     }
-    throw new HTTPException3(403, {
+    throw new HTTPException4(403, {
       message: `missing permission: ${permission}`
     });
   }
 }
 function requireLiteralPermission(grant, permission) {
   if (!hasLiteralPermission(grant.permissions, permission)) {
-    throw new HTTPException3(403, {
+    throw new HTTPException4(403, {
       message: `missing literal permission: ${permission}`
     });
   }
@@ -1141,13 +1193,13 @@ async function resolveAccessContext(c, deps) {
   const service = serviceInitiatorFromHeaders(c.req.raw.headers);
   if (service) {
     if (deps.settings.productAccessMode === "local") {
-      throw new HTTPException3(422, {
+      throw new HTTPException4(422, {
         message: "service initiator headers require an organization or workspace API key"
       });
     }
     const context = await apiKeyAccessContext(c, deps, deps.settings.productAccessMode);
     if (!context) {
-      throw new HTTPException3(422, {
+      throw new HTTPException4(422, {
         message: "service initiator headers require an organization or workspace API key"
       });
     }
@@ -1155,7 +1207,7 @@ async function resolveAccessContext(c, deps) {
   }
   if (c.req.header("x-opengeni-external-actor") !== void 0) {
     if (deps.settings.productAccessMode === "local") {
-      throw new HTTPException3(401, {
+      throw new HTTPException4(401, {
         message: "external actors require organization key authentication"
       });
     }
@@ -1255,32 +1307,35 @@ async function apiKeyAccessContext(c, deps, mode) {
   const externalHeader = c.req.header("x-opengeni-external-actor");
   const service = serviceInitiatorFromHeaders(c.req.raw.headers);
   if (service && apiKey.credentialKind !== "organization" && apiKey.credentialKind !== "workspace") {
-    throw new HTTPException3(422, {
+    throw new HTTPException4(422, {
       message: "service initiator headers require an organization or workspace API key"
     });
   }
   if (externalHeader !== void 0) {
     if (apiKey.workspaceId !== null || apiKey.credentialKind !== "organization") {
-      throw new HTTPException3(403, { message: "external actors require an organization key" });
+      throw new HTTPException4(403, { message: "external actors require an organization key" });
     }
     let selection;
     try {
       if (externalHeader.length > 16384) throw new Error("oversize");
       selection = ExternalActorSelection.parse(JSON.parse(decodeURIComponent(externalHeader)));
     } catch {
-      throw new HTTPException3(400, { message: "invalid external actor selection" });
+      throw new HTTPException4(400, { message: "invalid external actor selection" });
     }
     let identity;
     try {
-      identity = await ensureExternalIdentity(deps.db, {
-        accountId: apiKey.accountId,
-        ...selection.identity
+      identity = await withAccountRls(deps.db, apiKey.accountId, async (tx) => {
+        await lockExternalWorkspaceMembershipLifecycle(tx, apiKey.accountId);
+        return await ensureExternalIdentity(tx, {
+          accountId: apiKey.accountId,
+          ...selection.identity
+        });
       });
     } catch (error) {
       if (nestedPostgresSqlState(error) === "42501") {
-        throw new HTTPException3(403, { message: "external identity is unavailable" });
+        throw new HTTPException4(403, { message: "external identity is unavailable" });
       }
-      throw new HTTPException3(503, { message: "external identity authority is unavailable" });
+      throw new HTTPException4(503, { message: "external identity authority is unavailable" });
     }
     const linked = selection.mode === "linked_native" ? await resolveExternalIdentityLink(deps.db, {
       identity,
@@ -1288,7 +1343,7 @@ async function apiKeyAccessContext(c, deps, mode) {
       expectedRevision: selection.expectedLinkRevision
     }) : null;
     if (selection.mode === "linked_native" && !linked)
-      throw new HTTPException3(403, { message: "Native identity link is unavailable or changed" });
+      throw new HTTPException4(403, { message: "Native identity link is unavailable or changed" });
     const effectiveSubjectId = linked?.link.nativeSubjectId ?? identity.subjectId;
     const context2 = {
       mode,
@@ -1483,10 +1538,10 @@ function preferredFikenConnection(connections) {
 import { listSkillLibraryEntries } from "@opengeni/runtime/skill-library";
 
 // src/domain/native-mcp-connection-admission.ts
-import { HTTPException as HTTPException4 } from "hono/http-exception";
+import { HTTPException as HTTPException5 } from "hono/http-exception";
 function assertNativeMcpConnectionRef(connectionRef) {
   if (connectionRef?.authoritySource === "host") {
-    throw new HTTPException4(422, {
+    throw new HTTPException5(422, {
       message: "host-owned MCP connection refs are no longer supported; select an ordinary native connection"
     });
   }
@@ -1569,22 +1624,22 @@ async function buildCapabilityCatalog(input) {
 async function createCatalogItem(input) {
   const id = input.payload.id?.trim() || generatedCapabilityId(input.payload);
   if (id.startsWith("skill:")) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "Skills are installed through the Skill library or source import flow"
     });
   }
   if (id.startsWith("api:")) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "API Integrations are installed from typed Integration Definitions"
     });
   }
   if (id.startsWith("plugin:")) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(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 HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: `${CODEX_APPS_MCP_SERVER_ID} is reserved for the canonical Codex Apps service`
     });
   }
@@ -1623,26 +1678,26 @@ async function prepareCapabilityEnable(input) {
     input.capabilityId
   );
   if (isReservedCodexAppsCatalogItem(item))
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "Codex Apps use the dedicated account designation flow"
     });
   if (item.kind === "skill") {
-    throw new HTTPException5(409, {
+    throw new HTTPException6(409, {
       message: "Install Skills through the Skill library or source import flow"
     });
   }
   if (item.kind === "api") {
-    throw new HTTPException5(409, {
+    throw new HTTPException6(409, {
       message: "Install API Integrations through the Integration Definitions flow"
     });
   }
   if (item.kind === "plugin") {
-    throw new HTTPException5(409, {
+    throw new HTTPException6(409, {
       message: "Install Plugins through the Plugin Package flow"
     });
   }
   if (item.kind === "mcp" && !item.runtime.available) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled"
     });
   }
@@ -1676,7 +1731,7 @@ async function prepareCapabilityEnable(input) {
             installationConfig
           );
           if (!current || !isDeepStrictEqual(current, unchanged)) {
-            throw new HTTPException5(409, {
+            throw new HTTPException6(409, {
               message: "Capability installation changed; reload before reconciling"
             });
           }
@@ -1777,7 +1832,7 @@ async function resolveMcpCredentialHeaders(input, item) {
       ])
     );
   } catch {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: `stored credential headers for "${item.name}" could not be decrypted; supply them again in the enable request "headers" field`
     });
   }
@@ -1788,31 +1843,31 @@ function normalizedMcpCredentialHeaders(headers) {
     return null;
   }
   if (entries.length > maxMcpCredentialHeaders) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(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 HTTPException5(422, {
+      throw new HTTPException6(422, {
         message: `invalid credential header name: ${name}`
       });
     }
     const lower = name.toLowerCase();
     if (seen.has(lower)) {
-      throw new HTTPException5(422, {
+      throw new HTTPException6(422, {
         message: `duplicate credential header name: ${name}`
       });
     }
     seen.add(lower);
     if (value.length === 0 || value.length > maxMcpCredentialHeaderValueLength) {
-      throw new HTTPException5(422, {
+      throw new HTTPException6(422, {
         message: `credential header ${name} must be 1-${maxMcpCredentialHeaderValueLength} characters`
       });
     }
     if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
-      throw new HTTPException5(422, {
+      throw new HTTPException6(422, {
         message: `credential header ${name} contains forbidden control characters`
       });
     }
@@ -1838,12 +1893,12 @@ async function validateMcpCapabilityConnectionRef(input, item, ref) {
     } : {}
   };
   if (!normalized.providerDomain) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "connectionRef.providerDomain is required"
     });
   }
   if (!item.endpointUrl || !item.runtime.mcpServerId) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "MCP capabilities need a remote streamable HTTP endpoint before they can use a connectionRef"
     });
   }
@@ -1868,27 +1923,27 @@ async function validateMcpCapabilityConnectionRef(input, item, ref) {
     ) ?? null;
   }
   if (!connection) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(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 HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: `connectionRef does not reference a ${subjectScope}-owned connection`
     });
   }
   if (connection.status !== "active") {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: `connectionRef.connectionId is not active (${connection.status})`
     });
   }
   if (connection.providerDomain !== normalized.providerDomain) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "connectionRef.providerDomain does not match the referenced connection"
     });
   }
   if (normalized.kind && connection.kind !== normalized.kind) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "connectionRef.kind does not match the referenced connection"
     });
   }
@@ -1915,12 +1970,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 HTTPException5(422, {
+    throw new HTTPException6(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 HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: `MCP capability "${item.name}" requires credentials; pass them in the enable request "headers" field`
     });
   }
@@ -1935,7 +1990,7 @@ function requiredCapabilityHeaders(metadata) {
 function requireCapabilityHeaderEncryption(settings) {
   const key = environmentsEncryptionKeyBytes(settings);
   if (!key) {
-    throw new HTTPException5(503, {
+    throw new HTTPException6(503, {
       message: "MCP credential headers require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
     });
   }
@@ -1946,7 +2001,7 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
     return {};
   }
   if (!item.endpointUrl || !item.runtime.mcpServerId) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled"
     });
   }
@@ -1967,7 +2022,7 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
       }
     };
   } catch (error) {
-    throw new HTTPException5(422, {
+    throw new HTTPException6(422, {
       message: `MCP capability "${item.name}" could not be enabled because ${mcpProbeErrorMessage(error, item.endpointUrl)}`
     });
   }
@@ -2032,27 +2087,27 @@ async function disableCapability(input) {
     input.capabilityId
   );
   if (item.kind === "skill") {
-    throw new HTTPException5(409, {
+    throw new HTTPException6(409, {
       message: "Uninstall Skills through the Skill uninstall preview flow"
     });
   }
   if (item.kind === "api") {
-    throw new HTTPException5(409, {
+    throw new HTTPException6(409, {
       message: "Remove API Integrations through the Integration instance flow"
     });
   }
   if (item.kind === "plugin") {
-    throw new HTTPException5(409, {
+    throw new HTTPException6(409, {
       message: "Remove Plugins through the Plugin Package flow"
     });
   }
   if (item.source === "built_in" || item.source === "configured") {
-    throw new HTTPException5(409, {
+    throw new HTTPException6(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 HTTPException5(409, {
+    throw new HTTPException6(409, {
       message: "capability is not currently enabled"
     });
   }
@@ -2249,21 +2304,21 @@ async function fetchMcpRegistryPage(url, options = {}) {
   try {
     const response = await fetchImpl(url, { signal: controller.signal });
     if (!response.ok) {
-      throw new HTTPException5(502, {
+      throw new HTTPException6(502, {
         message: `MCP registry returned ${response.status}`
       });
     }
     return await response.json();
   } catch (error) {
-    if (error instanceof HTTPException5) {
+    if (error instanceof HTTPException6) {
       throw error;
     }
     if (error instanceof Error && error.name === "AbortError") {
-      throw new HTTPException5(504, {
+      throw new HTTPException6(504, {
         message: "MCP registry request timed out"
       });
     }
-    throw new HTTPException5(502, {
+    throw new HTTPException6(502, {
       message: `MCP registry request failed: ${error instanceof Error ? error.message : String(error)}`
     });
   } finally {
@@ -2274,7 +2329,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 HTTPException5(404, { message: "capability not found" });
+    throw new HTTPException6(404, { message: "capability not found" });
   }
   return item;
 }
@@ -3002,13 +3057,13 @@ import {
   requireFileForSubject,
   withSessionRlsActorContext as withSessionRlsActorContext3
 } from "@opengeni/db";
-import { HTTPException as HTTPException6 } from "hono/http-exception";
+import { HTTPException as HTTPException7 } 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 HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: `unsupported tool kind: ${tool.kind}`
       });
     }
@@ -3017,7 +3072,7 @@ function validateToolRefs(tools, settings) {
       if (optional) {
         continue;
       }
-      throw new HTTPException6(422, { message: `unknown MCP server id: ${tool.id}` });
+      throw new HTTPException7(422, { message: `unknown MCP server id: ${tool.id}` });
     }
     out.push({
       kind: "mcp",
@@ -3058,7 +3113,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 HTTPException6(403, { message: `${message}: ${widened.id}` });
+    throw new HTTPException7(403, { message: `${message}: ${widened.id}` });
   }
 }
 function validateToolRefsForSessionPolicy(input) {
@@ -3087,7 +3142,7 @@ function normalizeResources(resources) {
       try {
         normalizedUri = normalizeRepositoryTransportUri(resource.uri);
       } catch (error) {
-        throw new HTTPException6(422, {
+        throw new HTTPException7(422, {
           message: error instanceof Error ? error.message : "invalid repository URI"
         });
       }
@@ -3096,14 +3151,14 @@ function normalizeResources(resources) {
       );
       const credentialBindingId = gitCredentialBindingIdForRepository(resource, credentialProvider);
       if ((resource.credentialBindingId || resource.connectionId || resource.access) && !credentialProvider) {
-        throw new HTTPException6(422, {
+        throw new HTTPException7(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 HTTPException6(422, {
+          throw new HTTPException7(422, {
             message: `credential binding ${credentialBindingId} is assigned to multiple Git providers`
           });
         }
@@ -3132,7 +3187,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 HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: `duplicate resource mount path: ${normalized.mountPath}`
       });
     }
@@ -3142,7 +3197,7 @@ function normalizeResources(resources) {
     const identity = resourceIdentityKey(normalized);
     const seenIdentity = identities.get(identity);
     if (seenIdentity && seenIdentity !== key) {
-      throw new HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: `duplicate resource with different settings: ${identity}`
       });
     }
@@ -3159,7 +3214,7 @@ function mergeResourceRefs(existing, additions) {
     return mergeContractResourceRefs(existing, additions, { rejectConflicts: true });
   } catch (error) {
     if (error instanceof ResourceRefConflictError) {
-      throw new HTTPException6(422, { message: error.message });
+      throw new HTTPException7(422, { message: error.message });
     }
     throw error;
   }
@@ -3183,14 +3238,14 @@ function personalGitHubRepositoryResources(resources) {
   for (const resource of resources) {
     if (!isPersonalGitHubRepositoryCandidate(resource)) {
       if (resource.kind === "repository" && resource.connectionType === "github_personal") {
-        throw new HTTPException6(422, {
+        throw new HTTPException7(422, {
           message: "personal GitHub repository resources require the dedicated GitHub provider"
         });
       }
       continue;
     }
     if (!PERSONAL_GITHUB_BINDING_ID_PATTERN.test(resource.credentialBindingId) || typeof resource.repositoryId !== "string" || !/^[1-9]\d*$/u.test(resource.repositoryId) || resource.access !== "read" && resource.access !== "write" || resource.installationId !== void 0 || resource.githubInstallationId !== void 0 || resource.githubRepositoryId !== void 0 || resource.connectionId !== void 0 || resource.projectId !== void 0) {
-      throw new HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: "personal GitHub repository resources require one opaque binding, provider repository id, and explicit read or write access"
       });
     }
@@ -3198,10 +3253,10 @@ function personalGitHubRepositoryResources(resources) {
     try {
       uri = new URL(resource.uri);
     } catch {
-      throw new HTTPException6(422, { message: "personal GitHub repository URI is invalid" });
+      throw new HTTPException7(422, { message: "personal GitHub repository URI is invalid" });
     }
     if (uri.protocol !== "https:" || uri.hostname !== "github.com" || uri.port !== "" || uri.username !== "" || uri.password !== "" || uri.search !== "" || uri.hash !== "" || uri.pathname.endsWith(".git") || uri.pathname.split("/").filter(Boolean).length !== 2 || resource.uri !== `${uri.origin}${uri.pathname.replace(/\/$/u, "")}`) {
-      throw new HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: "personal GitHub repository resources require a canonical GitHub HTTPS URI"
       });
     }
@@ -3211,7 +3266,7 @@ function personalGitHubRepositoryResources(resources) {
   for (const resource of selected) {
     const key = `${resource.credentialBindingId}\0${resource.repositoryId}`;
     if (identities.has(key)) {
-      throw new HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: "personal GitHub repository resources must not contain duplicates"
       });
     }
@@ -3222,7 +3277,7 @@ function personalGitHubRepositoryResources(resources) {
 function validateGitHubRepositorySelectionShape(resources) {
   const installationIds = validateGitHubRepositorySelectionShapes(resources);
   if (installationIds.length > 1) {
-    throw new HTTPException6(422, {
+    throw new HTTPException7(422, {
       message: "GitHub App repository resources must belong to one installation"
     });
   }
@@ -3247,7 +3302,7 @@ function gitHubRepositorySelections(resources) {
     const installationId = positiveInteger(installationRaw);
     const repositoryId = positiveInteger(repositoryRaw);
     if (!installationId || !repositoryId) {
-      throw new HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: "GitHub App repository resources require positive github_installation_id and github_repository_id"
       });
     }
@@ -3269,14 +3324,14 @@ async function validateGitHubRepositorySelection(db, workspaceId, resources) {
       installationId,
       repositoryIds
     )) {
-      throw new HTTPException6(422, {
+      throw new HTTPException7(422, {
         message: "GitHub App repository resources must be authorized for a GitHub App installation linked to this workspace"
       });
     }
   }
 }
 function isAuthoritativeGitHubRepositorySelectionError(error) {
-  return error instanceof HTTPException6 && error.status === 422;
+  return error instanceof HTTPException7 && error.status === 422;
 }
 async function validateFileResources(db, accountId, workspaceId, subjectId, resources, privateFileContext) {
   return withSessionRlsActorContext3(
@@ -3291,7 +3346,7 @@ async function validateFileResources(db, accountId, workspaceId, subjectId, reso
           continue;
         }
         if (fileIds.has(resource.fileId)) {
-          throw new HTTPException6(422, { message: `duplicate file resource: ${resource.fileId}` });
+          throw new HTTPException7(422, { message: `duplicate file resource: ${resource.fileId}` });
         }
         fileIds.add(resource.fileId);
         const file = await requireFileForSubject(db, {
@@ -3301,10 +3356,10 @@ async function validateFileResources(db, accountId, workspaceId, subjectId, reso
           fileId: resource.fileId
         }).catch(() => null);
         if (!file) {
-          throw new HTTPException6(422, { message: `unknown file resource: ${resource.fileId}` });
+          throw new HTTPException7(422, { message: `unknown file resource: ${resource.fileId}` });
         }
         if (file.status !== "ready") {
-          throw new HTTPException6(422, {
+          throw new HTTPException7(422, {
             message: `file resource ${resource.fileId} is ${file.status}`
           });
         }
@@ -3317,7 +3372,7 @@ function normalizeMountPath(path) {
     return normalizeResourceMountPath(path);
   } catch (error) {
     if (!(error instanceof ResourceMountPathError)) throw error;
-    throw new HTTPException6(422, { message: `invalid resource mount path: ${path}` });
+    throw new HTTPException7(422, { message: `invalid resource mount path: ${path}` });
   }
 }
 function positiveInteger(value) {
@@ -4035,17 +4090,18 @@ async function freezePersonalConnectionDelegations(input) {
 }
 
 // src/domain/sessions.ts
+import { isDirectModelId, ModelUnavailableError } from "@opengeni/contracts";
 import { acceptSessionFileAttachments } from "@opengeni/db";
 
 // src/domain/knowledge.ts
-import { HTTPException as HTTPException7 } from "hono/http-exception";
+import { HTTPException as HTTPException8 } from "hono/http-exception";
 async function knowledgeContextForGateway(deps, grant) {
   if (!hasPermission(grant.permissions, "documents:search"))
-    throw new HTTPException7(403, { message: "Missing permission: documents:search" });
+    throw new HTTPException8(403, { message: "Missing permission: documents:search" });
   if (grant.principalKind === "agent_attempt") {
     const sessionId = grant.metadata?.sessionId;
     if (typeof sessionId !== "string")
-      throw new HTTPException7(403, { message: "Knowledge attempt unavailable" });
+      throw new HTTPException8(403, { message: "Knowledge attempt unavailable" });
     const attempt = await requireLiveAgentAttemptAuthorization(deps.db, grant, sessionId);
     return {
       accountId: grant.accountId,
@@ -4075,12 +4131,12 @@ async function knowledgeContextForGateway(deps, grant) {
 async function knowledgeContextForAccess(deps, access, permission) {
   const { grant } = access;
   if (!hasPermission(grant.permissions, permission)) {
-    throw new HTTPException7(403, { message: `Missing permission: ${permission}` });
+    throw new HTTPException8(403, { message: `Missing permission: ${permission}` });
   }
   if (grant.principalKind === "agent_attempt") {
     const sessionId = grant.metadata?.sessionId;
     if (typeof sessionId !== "string")
-      throw new HTTPException7(403, { message: "Knowledge attempt unavailable" });
+      throw new HTTPException8(403, { message: "Knowledge attempt unavailable" });
     const attempt = await requireLiveAgentAttemptAuthorization(deps.db, grant, sessionId);
     return {
       accountId: grant.accountId,
@@ -4115,7 +4171,7 @@ async function knowledgeContextForAccess(deps, access, permission) {
     };
   }
   if (grant.principalKind !== "human_session" || !access.contextIntegrity || access.authenticatedSubjectId !== grant.subjectId || grant.serviceInitiator || grant.serviceInitiatorContext || grant.metadata?.attemptId !== void 0 || grant.metadata?.turnId !== void 0) {
-    throw new HTTPException7(403, {
+    throw new HTTPException8(403, {
       message: "Knowledge management requires an authenticated human or agent attempt"
     });
   }
@@ -4308,14 +4364,14 @@ import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
 import {
   readTurnExecutionPolicyV1
 } from "@opengeni/contracts";
-import { HTTPException as HTTPException8 } from "hono/http-exception";
+import { HTTPException as HTTPException9 } from "hono/http-exception";
 function requireDeveloperSetupDelegatedPermissions(policy, permissions) {
   if (policy.credentialRestriction !== "developer_setup") return;
   const forbidden = permissions?.find(
     (permission) => !isDeveloperSetupDelegatedPermissionAllowed(permission)
   );
   if (forbidden) {
-    throw new HTTPException8(403, {
+    throw new HTTPException9(403, {
       message: `Developer setup cannot delegate first-party MCP permission: ${forbidden}`
     });
   }
@@ -4328,7 +4384,7 @@ function withDeveloperSetupCredentialRestriction(policy, source) {
     try {
       inherited = readTurnExecutionPolicyV1(metadata);
     } catch {
-      throw new HTTPException8(409, { message: "The frozen session credential ceiling is invalid" });
+      throw new HTTPException9(409, { message: "The frozen session credential ceiling is invalid" });
     }
     if (inherited.kind === "valid" && inherited.policy.credentialRestriction === "developer_setup") {
       restricted = true;
@@ -4444,14 +4500,14 @@ import {
   publishDurableSessionEvents as publishDurableSessionEvents2,
   publishDurableWorkspaceControlEvent
 } from "@opengeni/events";
-import { HTTPException as HTTPException16 } from "hono/http-exception";
+import { HTTPException as HTTPException17 } from "hono/http-exception";
 
 // src/domain/external-creation-attribution.ts
-import { HTTPException as HTTPException9 } from "hono/http-exception";
+import { HTTPException as HTTPException10 } from "hono/http-exception";
 var EXTERNAL_CREATION_ATTRIBUTION_KEY = "opengeniExternalCreationAttribution";
 function externalCreationMetadata(metadata, authorization, grant) {
   if (metadata && Object.hasOwn(metadata, EXTERNAL_CREATION_ATTRIBUTION_KEY)) {
-    throw new HTTPException9(422, {
+    throw new HTTPException10(422, {
       message: `${EXTERNAL_CREATION_ATTRIBUTION_KEY} is server-owned`
     });
   }
@@ -4476,12 +4532,12 @@ import {
   resolveExternalIdentityLink as resolveExternalIdentityLink2,
   getWorkspaceGrant as getWorkspaceGrant3,
   lockActiveExternalOrganizationKey,
-  lockExternalWorkspaceMembershipLifecycle,
+  lockExternalWorkspaceMembershipLifecycle as lockExternalWorkspaceMembershipLifecycle2,
   managedPersonalWorkspacePermissions as managedPersonalWorkspacePermissions2,
   nestedPostgresSqlState as nestedPostgresSqlState2,
   withWorkspaceSubjectRls as withWorkspaceSubjectRls2
 } from "@opengeni/db";
-import { HTTPException as HTTPException10 } from "hono/http-exception";
+import { HTTPException as HTTPException11 } from "hono/http-exception";
 function externalContinuationCommitAuthorizer(authorization) {
   const continuation = authorization ? externalActorContinuationForAuthorization(authorization) : null;
   if (!continuation || !authorization) return void 0;
@@ -4496,7 +4552,7 @@ function externalContinuationCommitAuthorizer(authorization) {
       await requireExternalContinuationAuthority(tx, continuation, scope, permissions);
     } catch (error) {
       const denied2 = nestedPostgresSqlState2(error) === "42501" || error instanceof Error && error.message === "External continuation authority unavailable";
-      throw new HTTPException10(denied2 ? 403 : 503, {
+      throw new HTTPException11(denied2 ? 403 : 503, {
         message: denied2 ? "external authority changed" : "external authority is unavailable",
         cause: error
       });
@@ -4510,7 +4566,7 @@ async function requireExternalContinuationAuthority(tx, raw, scope, permission)
     throw new Error("External continuation authority unavailable");
   };
   if (actor.accountId !== scope.accountId || actor.effectiveSubjectId !== scope.subjectId) deny();
-  await lockExternalWorkspaceMembershipLifecycle(tx, scope.accountId);
+  await lockExternalWorkspaceMembershipLifecycle2(tx, scope.accountId);
   const permissions = await lockActiveExternalOrganizationKey(
     tx,
     scope.accountId,
@@ -4608,7 +4664,7 @@ import {
   recordUsageEvent,
   sumUsageQuantity
 } from "@opengeni/db";
-import { HTTPException as HTTPException11 } from "hono/http-exception";
+import { HTTPException as HTTPException12 } from "hono/http-exception";
 function paidDocumentEmbedding(settings) {
   return settings.documentEmbeddingBillingMode === "credits" && settings.documentEmbeddingProvider === "openai";
 }
@@ -4637,7 +4693,7 @@ async function requireLimit(deps, input) {
   if (decision.allowed) {
     return;
   }
-  throw new HTTPException11(
+  throw new HTTPException12(
     decision.code === "insufficient_credits" || decision.code === "allowance_exhausted" ? 402 : 429,
     {
       message: decision.message,
@@ -6140,6 +6196,7 @@ async function provisionSandbox(services, ctx, input) {
 // src/model-catalog.ts
 import { modelAllowedByConnections } from "@opengeni/db";
 import {
+  withDirectModelProviders,
   applyModelCatalogDocument,
   CLAUDE_CONNECTION_KINDS,
   claudeProviderId,
@@ -6170,6 +6227,7 @@ import {
   evaluateWorkspaceModelPolicy
 } from "@opengeni/contracts";
 import {
+  listConnectionsMetadata as listConnectionsMetadata3,
   getDeploymentModelCatalog,
   listWorkspaceProviderCustomModels,
   getWorkspaceProviderCustomModelForExecution,
@@ -6302,7 +6360,8 @@ async function resolveWorkspaceCatalogSettings(db, envSettings, input) {
     organizationGatewayCustomModels,
     organizationOpenRouterCustomModels,
     retainedOrganizationGatewayCustomModels,
-    retainedOrganizationOpenRouterCustomModels
+    retainedOrganizationOpenRouterCustomModels,
+    directConnections
   ] = await Promise.all([
     resolveCatalogSettings(db, envSettings),
     listWorkspaceGatewayCustomModels(db, {
@@ -6360,7 +6419,8 @@ async function resolveWorkspaceCatalogSettings(db, envSettings, input) {
           upstreamModelId
         })
       )
-    ) : Promise.resolve([])
+    ) : Promise.resolve([]),
+    supportsOrganizationProviderReads ? listConnectionsMetadata3(db, input.workspaceId, null) : Promise.resolve([])
   ]);
   const includeRetainedModels = (activeModels, retainedModels) => {
     const customModels = [...activeModels];
@@ -6434,22 +6494,25 @@ async function resolveWorkspaceCatalogSettings(db, envSettings, input) {
     }
   return {
     ...resolved,
-    settings: withClaudeConnectionCatalog(
+    settings: withDirectModelProviders(
       withClaudeConnectionCatalog(
-        withOrganizationOpenRouterCatalogProvider(
-          withOrganizationGatewayCatalogProvider(
-            withWorkspaceOpenRouterCatalogProvider(
-              withWorkspaceGatewayCatalogProvider(resolved.settings, gatewayCustomModels),
-              openRouterCustomModels
+        withClaudeConnectionCatalog(
+          withOrganizationOpenRouterCatalogProvider(
+            withOrganizationGatewayCatalogProvider(
+              withWorkspaceOpenRouterCatalogProvider(
+                withWorkspaceGatewayCatalogProvider(resolved.settings, gatewayCustomModels),
+                openRouterCustomModels
+              ),
+              organizationGatewayModels
             ),
-            organizationGatewayModels
+            organizationOpenRouterModels
           ),
-          organizationOpenRouterModels
+          claudeConnections
         ),
-        claudeConnections
+        workspaceClaudeConnections,
+        "workspace"
       ),
-      workspaceClaudeConnections,
-      "workspace"
+      directConnections
     )
   };
 }
@@ -6525,7 +6588,7 @@ function credentialReadinessFor(input) {
     const claudeKind = CLAUDE_CONNECTION_KINDS.find(
       (kind) => claudeProviderId(kind, "workspace") === input.model.providerId
     );
-    const connectionActive = claudeKind ? input.workspaceClaudeConnections?.[claudeKind]?.active === true : input.model.providerId === WORKSPACE_OPENROUTER_PROVIDER_ID ? input.workspaceOpenRouterConnectionActive : input.workspaceGatewayConnectionActive;
+    const connectionActive = input.provider?.kind === "direct-openai-workspace" || input.provider?.kind === "direct-azure-workspace" ? true : claudeKind ? input.workspaceClaudeConnections?.[claudeKind]?.active === true : input.model.providerId === WORKSPACE_OPENROUTER_PROVIDER_ID ? input.workspaceOpenRouterConnectionActive : input.workspaceGatewayConnectionActive;
     return connectionActive ? { status: "ready", reason: null, basis: "connection", checkedAt: null } : {
       status: "not_ready",
       reason: "needs_reauth",
@@ -6868,8 +6931,19 @@ function findSelection(selections, modelId) {
 function creditsCandidate(input) {
   const fallbackEffort = input.settings.openaiReasoningEffort;
   const deployment = findSelection(input.selections, input.settings.openaiModel);
-  if (deployment?.availability.selectable && deployment.model.cost === "credits") return null;
   const configured = findSelection(input.selections, input.settings.creditsDefaultModel);
+  if (deployment?.availability.selectable && deployment.model.cost === "credits") {
+    if (configured?.model.id !== deployment.model.id) return null;
+    return {
+      model: deployment.model.id,
+      reasoningEffort: clampReasoningEffortForConfiguredModel(
+        deployment.model,
+        input.settings.creditsDefaultReasoningEffort,
+        fallbackEffort
+      ),
+      source: "credits"
+    };
+  }
   if (configured?.availability.selectable && configured.model.cost === "credits") {
     return {
       model: configured.model.id,
@@ -7138,13 +7212,13 @@ import {
   resolveWorkspaceAgentDefaults,
   resolveWorkspaceAgentHumanInputEnabled
 } from "@opengeni/contracts";
-import { HTTPException as HTTPException12 } from "hono/http-exception";
+import { HTTPException as HTTPException13 } from "hono/http-exception";
 function withAgentConfigHttpErrors(fn) {
   try {
     return fn();
   } catch (error) {
     if (error instanceof AgentConfigError) {
-      throw new HTTPException12(422, { message: error.message, cause: error });
+      throw new HTTPException13(422, { message: error.message, cause: error });
     }
     throw error;
   }
@@ -7209,7 +7283,7 @@ function applySessionAgentConfigWriteThrough(input) {
 }
 function requireAgentConfigAdmission(settings, agent) {
   if (agent !== void 0 && settings.agentConfigAdmissionEnabled !== true) {
-    throw new HTTPException12(422, {
+    throw new HTTPException13(422, {
       message: "agent configuration is not enabled on this deployment",
       cause: new AgentConfigError(
         "agent_config_not_enabled",
@@ -7368,6 +7442,21 @@ function resolveTurnToolPolicy(input) {
     defaultMcpServerIds: scheduledIds ?? input.defaultMcpServerIds ?? []
   });
 }
+async function workspaceSessionToolPolicyContext(db, workspaceId, settings, subjectId) {
+  const [runtimeSettings, workspace] = await Promise.all([
+    settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings, {
+      ...subjectId ? { subjectId } : {}
+    }),
+    requireWorkspace2(db, workspaceId)
+  ]);
+  return {
+    workspaceServerIds: sortedIds(runtimeSettings.mcpServers.map((server) => server.id)),
+    workspaceDefaultServerIds: workspaceSessionToolPolicyDefaultServerIdsFor(
+      runtimeSettings.mcpServers,
+      workspace.settings
+    )
+  };
+}
 async function workspaceSessionToolPolicyServerIds(db, workspaceId, settings, subjectId) {
   const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings, {
     ...subjectId ? { subjectId } : {}
@@ -7529,11 +7618,12 @@ function sessionEffectiveToolProjectionInput(session, toolRefs, context) {
         "browser_screenshot",
         "browser_clipboard",
         "browser_debug",
+        "browser_downloads",
         "computer_targets",
         "computer_observe",
         "computer_clipboard"
       ].includes(name);
-      if (permissionAllowed(readOnly ? "sessions:read" : "sessions:control")) {
+      if (permissionAllowed(readOnly ? "sessions:read" : "sessions:control") && (name !== "browser_download_save" || permissionAllowed("files:upload"))) {
         firstPartyModelNames.set(name, `interaction__${name}`);
         if (!firstPartyMcpTools.includes(name) && resolveAgentToolFamilies(session.agent).allowsFirstPartyTool(name) && session.firstPartyMcpTools.includes(name))
           firstPartyMcpTools.push(name);
@@ -7629,11 +7719,11 @@ import {
   numberTimelineAnnotations
 } from "@opengeni/contracts";
 import { getSessionEvent } from "@opengeni/db";
-import { HTTPException as HTTPException13 } from "hono/http-exception";
+import { HTTPException as HTTPException14 } from "hono/http-exception";
 var SOURCE_CONTEXT_BYTES = 160;
 var ANSI_SEQUENCE = new RegExp("\\u001B\\[[0-?]*[ -/]*[@-~]", "g");
 function invalidAnnotationSource() {
-  throw new HTTPException13(422, { message: "Invalid timeline annotation source" });
+  throw new HTTPException14(422, { message: "Invalid timeline annotation source" });
 }
 function safeJson(value) {
   try {
@@ -7778,12 +7868,12 @@ import {
   variableSetVariableNameReservation
 } from "@opengeni/contracts";
 import { getVariableSet, recordAuditEvent } from "@opengeni/db";
-import { HTTPException as HTTPException14 } from "hono/http-exception";
+import { HTTPException as HTTPException15 } from "hono/http-exception";
 var MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
 var MAX_VARIABLES_PER_ENVIRONMENT = 100;
 function assertAllowedVariableSetVariableName(name) {
   if (variableSetVariableNameReservation(name)) {
-    throw new HTTPException14(422, {
+    throw new HTTPException15(422, {
       message: `reserved variable set variable name / reserved environment variable name: ${name}`
     });
   }
@@ -7792,7 +7882,7 @@ var assertAllowedEnvironmentVariableName = assertAllowedVariableSetVariableName;
 function requireVariableSetEncryption(settings) {
   const key = environmentsEncryptionKeyBytes2(settings);
   if (!key) {
-    throw new HTTPException14(503, {
+    throw new HTTPException15(503, {
       message: "variable sets require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
     });
   }
@@ -7810,7 +7900,7 @@ async function requireVariableSetForApi(db, grant, variableSetId) {
     variableSetId
   );
   if (!variableSet) {
-    throw new HTTPException14(404, { message: "variableSet not found" });
+    throw new HTTPException15(404, { message: "variableSet not found" });
   }
   return variableSet;
 }
@@ -7824,7 +7914,7 @@ async function validateVariableSetAttachment(deps, grant, workspaceId, variableS
     variableSetId
   );
   if (!variableSet) {
-    throw new HTTPException14(422, { message: "unknown variableSetId" });
+    throw new HTTPException15(422, { message: "unknown variableSetId" });
   }
   return variableSet;
 }
@@ -7855,7 +7945,7 @@ import {
 import {
   getConnectionMetadata as getConnectionMetadata3
 } from "@opengeni/db";
-import { HTTPException as HTTPException15 } from "hono/http-exception";
+import { HTTPException as HTTPException16 } from "hono/http-exception";
 function openGeniSlackBotMetadata(metadata) {
   const parsed = OpenGeniSlackBotConnectionMetadata.safeParse(metadata);
   return parsed.success ? parsed.data : null;
@@ -7874,12 +7964,12 @@ function hasReservedOpenGeniSlackBotSessionMetadata(metadata) {
 async function requireOpenGeniSlackBotConnection(db, workspaceId, connectionId) {
   const connection = await getConnectionMetadata3(db, workspaceId, connectionId, null);
   if (!connection || !isOpenGeniSlackBotConnection(connection)) {
-    throw new HTTPException15(422, {
+    throw new HTTPException16(422, {
       message: "slackBotConnectionId must reference an OpenGeni Slack bot connection"
     });
   }
   if (connection.status !== "active") {
-    throw new HTTPException15(422, {
+    throw new HTTPException16(422, {
       message: `OpenGeni Slack bot connection is not active (${connection.status})`
     });
   }
@@ -7911,12 +8001,12 @@ async function validateScheduledTaskSlackChannel(input) {
   const nextChannel = input.next.slackBotChannelId ?? null;
   if (!nextChannel) return;
   if (!input.next.slackBotConnectionId) {
-    throw new HTTPException15(422, {
+    throw new HTTPException16(422, {
       message: "slackBotChannelId requires slackBotConnectionId"
     });
   }
   if (input.runMode === "existing_session") {
-    throw new HTTPException15(422, {
+    throw new HTTPException16(422, {
       message: "Slack channel posting needs a task that starts its own chats"
     });
   }
@@ -7924,18 +8014,18 @@ async function validateScheduledTaskSlackChannel(input) {
     return;
   }
   if (!isAuthenticatedPersonAuthorization(input.authorization)) {
-    throw new HTTPException15(403, {
+    throw new HTTPException16(403, {
       message: "Only a person can choose the Slack channel a scheduled task posts to"
     });
   }
   requirePermission(input.grant, "connections:write");
   if (input.reusableSessionCanPost && !await input.reusableSessionCanPost()) {
-    throw new HTTPException15(409, {
+    throw new HTTPException16(409, {
       message: "this task continues a chat that was created without Slack posting; recreate the task to post from it"
     });
   }
   if (!input.verifySlackChannel) {
-    throw new HTTPException15(422, {
+    throw new HTTPException16(422, {
       message: "Choose the Slack channel in the schedule editor"
     });
   }
@@ -8284,14 +8374,14 @@ function withoutExcludedMcpServers(tools, excludedIds = []) {
 function defaultPolicyExclusions(ids = []) {
   const sorted = [...new Set(ids)].filter((id) => id !== "opengeni").sort();
   if (sorted.length > 64 || sorted.some((id) => id.length > 200 || !/^[A-Za-z0-9_-]+$/.test(id))) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "connector exclusions must contain at most 64 valid MCP server IDs"
     });
   }
   return sorted.length ? { excludedMcpServerIds: sorted } : {};
 }
 function isCatalogOverlayModel(modelId) {
-  return modelId?.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX2) === true || modelId?.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2) === true || modelId?.startsWith(ORGANIZATION_GATEWAY_MODEL_ID_PREFIX2) === true || modelId?.startsWith(ORGANIZATION_OPENROUTER_MODEL_ID_PREFIX2) === true || CLAUDE_CONNECTION_KINDS3.some(
+  return modelId != null && isDirectModelId(modelId) || modelId?.startsWith(WORKSPACE_GATEWAY_MODEL_ID_PREFIX2) === true || modelId?.startsWith(WORKSPACE_OPENROUTER_MODEL_ID_PREFIX2) === true || modelId?.startsWith(ORGANIZATION_GATEWAY_MODEL_ID_PREFIX2) === true || modelId?.startsWith(ORGANIZATION_OPENROUTER_MODEL_ID_PREFIX2) === true || CLAUDE_CONNECTION_KINDS3.some(
     (kind) => ["workspace", "organization"].some(
       (scope) => modelId?.startsWith(claudeProviderId2(kind, scope) + "/")
     )
@@ -8301,25 +8391,25 @@ var sessionMcpCredentialHeaderName = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
 async function requireAtomicPersonalResourceAttachment(deps, authorization, workspaceId, intent, existingSession) {
   if (!intent) return;
   if (!authorization) {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "Personal resources require the owning managed-human session."
     });
   }
   try {
     requireVerifiedOwningUser(authorization, workspaceId);
   } catch (error) {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "Personal resources require the owning managed-human session.",
       cause: error
     });
   }
   if (!await sessionTenancyProductActivated2(deps.db, workspaceId)) {
-    throw new HTTPException16(409, {
+    throw new HTTPException17(409, {
       message: "Session tenancy is not activated for this organization."
     });
   }
   if (existingSession && intent.expectedAuthorityEpoch === void 0) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "Personal-resource attachment requires expectedAuthorityEpoch."
     });
   }
@@ -8350,7 +8440,7 @@ function resolveFirstPartyMcpToolsForCreate(requested, parentStored, policy = {
       const parentCeiling = effectiveFirstPartyMcpToolCeiling(parentStored, policy);
       const widened = requested.find((tool) => !parentCeiling.has(tool));
       if (widened) {
-        throw new HTTPException16(403, {
+        throw new HTTPException17(403, {
           message: `child first-party MCP tools may only narrow the parent session selection: ${widened}`
         });
       }
@@ -8383,7 +8473,7 @@ function initiatingHumanForAllowance(frozen) {
 function serviceInitiatorForGrant(grant) {
   if (!grant.serviceInitiator) {
     if (grant.serviceInitiatorContext) {
-      throw new HTTPException16(403, {
+      throw new HTTPException17(403, {
         message: "service initiator context requires a signed service initiator"
       });
     }
@@ -8391,13 +8481,13 @@ function serviceInitiatorForGrant(grant) {
   }
   const initiator = ServiceTurnInitiator.safeParse(grant.serviceInitiator);
   if (!initiator.success) {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "a delegated command initiator must be a bounded service principal"
     });
   }
   const context = ServiceTurnInitiatorContext2.safeParse(grant.serviceInitiatorContext ?? {});
   if (!context.success) {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "delegated service initiator context is invalid or reserved"
     });
   }
@@ -8405,7 +8495,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 HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "a service initiator cannot replace an exact agent-attempt initiator"
     });
   }
@@ -8423,7 +8513,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 HTTPException16(403, {
+      throw new HTTPException17(403, {
         message: "caller attempt claims are incomplete"
       });
     }
@@ -8464,31 +8554,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 HTTPException16(422, {
+    throw new HTTPException17(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 HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `invalid credential header name: ${name}`
       });
     }
     const lower = name.toLowerCase();
     if (seen.has(lower)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `duplicate credential header name: ${name}`
       });
     }
     seen.add(lower);
     if (value.length === 0 || value.length > maxSessionMcpCredentialHeaderValueLength) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `credential header ${name} must be 1-${maxSessionMcpCredentialHeaderValueLength} characters`
       });
     }
     if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `credential header ${name} contains forbidden control characters`
       });
     }
@@ -8556,13 +8646,13 @@ function validateSessionMcpServersForCreate(settings, grant, servers) {
   for (const server of servers) {
     assertNativeMcpConnectionRef(server.connectionRef);
     if (seenIds.has(server.id)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `duplicate session MCP server id: ${server.id}`
       });
     }
     seenIds.add(server.id);
     if (reservedSessionMcpServerIds.has(server.id) || existingIds.has(server.id)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `MCP server id already exists: ${server.id}`
       });
     }
@@ -8604,13 +8694,13 @@ function validateInheritedSessionMcpServersForCreate(servers) {
   const seenIds = /* @__PURE__ */ new Set();
   for (const server of servers) {
     if (seenIds.has(server.id)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `duplicate inherited session MCP server id: ${server.id}`
       });
     }
     seenIds.add(server.id);
     if (reservedSessionMcpServerIds.has(server.id)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `reserved inherited session MCP server id: ${server.id}`
       });
     }
@@ -8642,13 +8732,13 @@ function validateSessionMcpCredentialUpdates(input) {
   const seenIds = /* @__PURE__ */ new Set();
   const encryptedUpdates = input.updates.map((update) => {
     if (seenIds.has(update.id)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `duplicate session MCP credential update id: ${update.id}`
       });
     }
     seenIds.add(update.id);
     if (!knownIds.has(update.id)) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `unknown session MCP server id: ${update.id}`
       });
     }
@@ -8715,7 +8805,7 @@ async function createAndStartSessionWithOutcome(input) {
   let targetSeededBeforeCreateCommit = false;
   const beforeCreateCommit = requiresActiveWorkspaceCustomModel || input.consumeNewSessionDraft || input.beforeCreateCommit || preflightTarget || targetPreflightFailureMessage ? async (tx, sessionId, context) => {
     if (targetPreflightFailureMessage && context?.created !== false) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: targetPreflightFailureMessage
       });
     }
@@ -8733,9 +8823,7 @@ async function createAndStartSessionWithOutcome(input) {
         reference
       });
       if (!active) {
-        throw new HTTPException16(422, {
-          message: `model is not available: ${input.model}`
-        });
+        throw modelUnavailableHttpException(input.model);
       }
     }
     if (input.consumeNewSessionDraft && context?.created !== false) {
@@ -8758,7 +8846,7 @@ async function createAndStartSessionWithOutcome(input) {
         workingDir: preflightTarget.workingDir
       });
       if (!seeded.swapped) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: `cannot target sandbox ${seedTargetForNewSession.sandboxId}: target authority changed during session creation`
         });
       }
@@ -8962,7 +9050,7 @@ async function finishStartSession(input, session) {
       input.seedTargetSandbox.workingDir ?? null
     );
     if (!seeded.swapped) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `cannot target sandbox ${input.seedTargetSandbox.sandboxId}: ${seeded.reason ?? "target is not attachable"}`
       });
     }
@@ -9025,6 +9113,10 @@ async function finishStartSession(input, session) {
 function workflowIdForSession(sessionId) {
   return `session-${sessionId}`;
 }
+function modelUnavailableHttpException(model) {
+  const cause = new ModelUnavailableError(model);
+  return new HTTPException17(422, { message: cause.message, cause });
+}
 function canonicalConfiguredModel(settings, model) {
   if (model === null || model === void 0) {
     return model;
@@ -9034,7 +9126,7 @@ function canonicalConfiguredModel(settings, model) {
     if (settings.codexSubscriptionEnabled && configuredAllowedModels(withCodexCatalogProvider3(settings)).includes(canonicalModel)) {
       return canonicalModel;
     }
-    throw new HTTPException16(422, { message: `model is not available: ${model}` });
+    throw modelUnavailableHttpException(model);
   }
   if (configuredAllowedModels(settings).includes(canonicalModel)) {
     return canonicalModel;
@@ -9045,7 +9137,7 @@ function canonicalConfiguredModel(settings, model) {
   if (settings.supergrokSubscriptionEnabled && canonicalModel.startsWith(XAI_SUBSCRIPTION_MODEL_ID_PREFIX)) {
     return canonicalModel;
   }
-  throw new HTTPException16(422, { message: `model is not available: ${model}` });
+  throw modelUnavailableHttpException(model);
 }
 function assertConfiguredModel(settings, model) {
   canonicalConfiguredModel(settings, model);
@@ -9086,7 +9178,7 @@ async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model
     modelId: canonicalModel
   });
   if (!verdict.allowed) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(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`
     });
   }
@@ -9094,10 +9186,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 HTTPException16(404, { message: "session turn not found" });
+    throw new HTTPException17(404, { message: "session turn not found" });
   }
   if (turn.status !== "queued") {
-    throw new HTTPException16(409, {
+    throw new HTTPException17(409, {
       message: `turn is ${turn.status}; only queued turns can be changed`
     });
   }
@@ -9208,7 +9300,7 @@ async function postUserMessageTurn(input) {
     assertSessionAllowsProductModel(sessionForModelGate, effectiveModelForGate);
   } catch (error) {
     if (error instanceof CodexCompactionV2ProviderLockedError) {
-      throw new HTTPException16(422, { message: error.message, cause: error });
+      throw new HTTPException17(422, { message: error.message, cause: error });
     }
     throw error;
   }
@@ -9275,9 +9367,7 @@ async function postUserMessageTurn(input) {
                 reference
               });
               if (!active) {
-                throw new HTTPException16(422, {
-                  message: `model is not available: ${freshWorkspaceCustomModel}`
-                });
+                throw modelUnavailableHttpException(freshWorkspaceCustomModel);
               }
             }
           } : {},
@@ -9290,19 +9380,19 @@ async function postUserMessageTurn(input) {
       throw error;
     }
     if (error instanceof PersonalResourceAttachmentAcceptanceError) {
-      throw new HTTPException16(
+      throw new HTTPException17(
         error.kind === "invalid" ? 422 : error.kind === "forbidden" ? 403 : 409,
         { message: error.message, cause: error }
       );
     }
     if (error instanceof QueueCommandConflictError || error instanceof SessionControlConflictError) {
-      throw new HTTPException16(409, { message: error.message });
+      throw new HTTPException17(409, { message: error.message });
     }
     if (error instanceof Error && error.message.includes("cancelled")) {
-      throw new HTTPException16(409, { message: error.message });
+      throw new HTTPException17(409, { message: error.message });
     }
     if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
-      throw new HTTPException16(422, { message: error.message });
+      throw new HTTPException17(422, { message: error.message });
     }
     throw error;
   }
@@ -9358,28 +9448,28 @@ function resolveSessionCreateScope(input) {
   } else {
     const agentAccess = requested.agentAccessProvided ? requested.agentAccess : parent.agentAccess;
     if (AGENT_ACCESS_WIDTH[agentAccess] > AGENT_ACCESS_WIDTH[parent.agentAccess]) {
-      throw new HTTPException16(403, {
+      throw new HTTPException17(403, {
         message: "child agent access may only narrow the parent session"
       });
     }
     if (requested.endUserProvided) {
       const same = requested.scopeSubjectId !== null && parent.scopeSubjectId !== null && requested.scopeSubjectId === parent.scopeSubjectId;
       if (!same) {
-        throw new HTTPException16(403, {
+        throw new HTTPException17(403, {
           message: "child end-user label must equal the parent session label"
         });
       }
     }
     const memoryScope = requested.memoryScopeProvided ? requested.memoryScope : parent.memoryScope;
     if (MEMORY_SCOPE_WIDTH[memoryScope] > MEMORY_SCOPE_WIDTH[parent.memoryScope]) {
-      throw new HTTPException16(403, {
+      throw new HTTPException17(403, {
         message: "child memory scope may only narrow the parent session"
       });
     }
     resolved = { agentAccess, scopeSubjectId: parent.scopeSubjectId, memoryScope };
   }
   if (resolved.memoryScope === "user" && resolved.scopeSubjectId === null) {
-    throw new HTTPException16(422, { message: 'memoryScope "user" requires an authenticated user' });
+    throw new HTTPException17(422, { message: 'memoryScope "user" requires an authenticated user' });
   }
   return resolved;
 }
@@ -9433,7 +9523,7 @@ async function retryFailedSession(deps, grant, workspaceId, sessionId, request)
     assertSessionAllowsProductModel(session, model);
   } catch (error) {
     if (error instanceof CodexCompactionV2ProviderLockedError)
-      throw new HTTPException16(422, { message: error.message, cause: error });
+      throw new HTTPException17(422, { message: error.message, cause: error });
     throw error;
   }
   await assertWorkspaceModelPolicyAllows(deps.db, settings, workspaceId, model);
@@ -9544,7 +9634,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   const creationMetadata = externalCreationMetadata(payload.metadata, authorization, grant);
   const externalBeforeCreateCommit = externalContinuationCommitAuthorizer(authorization);
   if (hasReservedOpenGeniSlackBotSessionMetadata(payload.metadata)) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2} is reserved for scheduler routing`
     });
   }
@@ -9552,13 +9642,13 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   const visibilityProvided = hasOwnProperty(rawPayload, "visibility");
   if (payload.visibility === "private" && !grant.metadata?.["sessionId"]) {
     if (!authorization) {
-      throw new HTTPException16(403, {
+      throw new HTTPException17(403, {
         message: "managed human session required"
       });
     }
     await requireManagedHumanPrivateSessionCreate(unresolvedDeps, authorization, workspaceId);
     if (payload.sandbox === "shared" || typeof payload.sandbox === "object") {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: "Only-me sessions require their own sandbox"
       });
     }
@@ -9573,14 +9663,14 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       });
     } catch (error) {
       if (error instanceof SessionAuthorizationDeniedError) {
-        throw new HTTPException16(403, { message: error.message, cause: error });
+        throw new HTTPException17(403, { message: error.message, cause: error });
       }
       throw error;
     }
   }
   const parentSession = parentSessionId ? await getSession3(db, workspaceId, parentSessionId) : null;
   if (parentSessionId && !parentSession) {
-    throw new HTTPException16(404, {
+    throw new HTTPException17(404, {
       message: `parent session not found in workspace: ${parentSessionId}`
     });
   }
@@ -9588,7 +9678,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   const workspaceSessionToolDefaults = resolveWorkspaceSessionToolDefaults2(workspace.settings);
   const parentAuthority = parentSession ? await getSessionAuthorityProjection4(db, workspaceId, parentSession.id) : null;
   if (parentSession && !parentAuthority) {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "parent session authority is unavailable"
     });
   }
@@ -9600,7 +9690,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       parentVisibility: parentAuthority?.visibility ?? null
     });
   } catch (error) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: error instanceof Error ? error.message : "invalid child visibility"
     });
   }
@@ -9611,7 +9701,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       parentSession?.bundledSkillIds
     );
   } catch (error) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: error instanceof Error ? error.message : "Invalid bundled Skill selection"
     });
   }
@@ -9653,7 +9743,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     creationInitiator.actor.attemptId
   ) : null;
   if (creationInitiator.actor && (!parentCallingTurn || parentCallingTurn.sessionId !== parentSession?.id)) {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "caller attempt does not belong to the parent session"
     });
   }
@@ -9713,12 +9803,12 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       }
     } catch (error) {
       if (error instanceof SessionIdConflictError) {
-        throw new HTTPException16(409, {
+        throw new HTTPException17(409, {
           message: "requested session id is already in use"
         });
       }
       if (error instanceof SessionCreateIdempotencyConflictError) {
-        throw new HTTPException16(409, { message: error.message, cause: error });
+        throw new HTTPException17(409, { message: error.message, cause: error });
       }
       throw error;
     }
@@ -9777,7 +9867,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
         }
       );
     } catch (error) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: error instanceof Error ? error.message : "invalid child goal root constraints"
       });
     }
@@ -9824,7 +9914,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     for (const [id, policy] of Object.entries(requestedMcpPolicies)) {
       const inherited = inheritedServers.find((server) => server.id === id);
       if (!inherited || sessionMcpServers.runtimeServers.some((server) => server.id === id)) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: `MCP approval policy must name an enabled inherited capability: ${id}${/^api_(openapi|graphql)_/.test(id) ? "; API Integration tool approval is set at install with autoApprovedTools" : ""}`
         });
       }
@@ -9845,12 +9935,12 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     for (const capabilityId of selectedInstalledSkillIds) {
       const installed = installedById.get(capabilityId);
       if (!installed) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: `Session-selected Skill is not installed in this workspace: ${capabilityId}`
         });
       }
       if (installed.activationMode !== "session_selected") {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: `Installed Skill does not require explicit session selection: ${capabilityId}`
         });
       }
@@ -9865,13 +9955,13 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   try {
     skills = SessionSkills.parse([...inheritedOrSubmittedSkills, ...selectedInstalledSkills]);
   } catch (error) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: error instanceof Error ? error.message : "invalid session Skill selection"
     });
   }
   const toolsProvided = hasOwnProperty(rawPayload, "tools");
   if (toolsProvided && payload.excludedMcpServerIds !== void 0) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "connector exclusions require workspace-default tools"
     });
   }
@@ -9933,7 +10023,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   }
   if (payload.excludedMcpServerIds !== void 0) {
     if (toolPolicy.mode !== "workspace_default") {
-      throw new HTTPException16(403, {
+      throw new HTTPException17(403, {
         message: "connector exclusions require workspace-default tools"
       });
     }
@@ -9967,7 +10057,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   const captureLinkedAuthority = prepareExternalLinkTurnAdmission(authorization);
   await validateGitHubRepositorySelection(db, workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException16(503, {
+    throw new HTTPException17(503, {
       message: "object storage is not configured"
     });
   }
@@ -9994,7 +10084,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     const rig = await getRig2(db, grant, requestedRigId);
     if (!rig || !rig.activeVersion) {
       if (payload.rigId) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: rig ? `sandbox environment ${payload.rigId} has no active version to bind` : `unknown rigId: ${payload.rigId}`
         });
       }
@@ -10015,7 +10105,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   if (payload.channelId) {
     const channel = await getChannel(db, workspaceId, payload.channelId);
     if (!channel) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `unknown channelId: ${payload.channelId}`
       });
     }
@@ -10034,15 +10124,14 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       ...xaiProviderAccountAuthoritySnapshot ? { xaiAuthoritySnapshot: xaiProviderAccountAuthoritySnapshot } : {}
     });
     if (!admissibleWorkspaceModel(selections, model)) {
-      throw new HTTPException16(422, { message: `model is not selectable: ${model}` });
+      throw new HTTPException17(422, { message: `model is not selectable: ${model}` });
     }
   }
   const inheritedReasoningEffort = parentCallingTurn?.reasoningEffort ?? parentSession?.reasoningEffort ?? resolvedDefault?.reasoningEffort ?? settings.openaiReasoningEffort;
-  const inheritedLatencyMode = parentCallingTurn?.latencyMode ?? parentSession?.latencyMode ?? "standard";
   const reasoningEffort = payload.reasoningEffort ?? inheritedReasoningEffort;
-  const latencyMode = payload.latencyMode ?? inheritedLatencyMode;
+  const latencyMode = payload.latencyMode ?? "standard";
   if (payload.expectedNewSessionDraftRevision !== void 0 && payload.rigId === null) {
-    throw new HTTPException16(409, {
+    throw new HTTPException17(409, {
       message: "The submitted session options are not represented by the new-session draft"
     });
   }
@@ -10080,7 +10169,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       reasoningEffort,
       reasoningSource: payload.reasoningEffort === void 0 ? inheritedFromParent ? "continuation" : "deployment" : "explicit",
       latencyMode,
-      latencyModeSource: payload.latencyMode === void 0 ? inheritedFromParent ? "continuation" : "deployment" : "explicit"
+      latencyModeSource: payload.latencyMode === void 0 ? "deployment" : "explicit"
     }),
     { grant, authorization, trustedMetadata: [parentSession?.metadata] }
   );
@@ -10089,7 +10178,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   if (parentFirstPartyMcpPermissions && payload.firstPartyMcpPermissions?.some(
     (permission) => !hasPermission(parentFirstPartyMcpPermissions, permission)
   )) {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "child first-party MCP permissions may only narrow the parent session grant"
     });
   }
@@ -10097,19 +10186,19 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     (permission) => hasPermission(grant.permissions, permission)
   ) : null);
   if (firstPartyMcpPermissions && firstPartyMcpPermissions.length === 0) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(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 HTTPException16(403, {
+      throw new HTTPException17(403, {
         message: `cannot grant first-party MCP permission beyond the creating grant: ${permission}`
       });
     }
   }
   if (effectiveGoal && firstPartyMcpPermissions && !firstPartyMcpPermissions.includes("goals:manage")) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "goal-bearing sessions require goals:manage in the resulting first-party MCP permission set"
     });
   }
@@ -10118,7 +10207,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     (tool) => !deploymentFirstPartyMcpToolPolicy.allowed.includes(tool)
   );
   if (disallowedFirstPartyMcpTool) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: `first-party MCP tool is disabled by deployment policy: ${disallowedFirstPartyMcpTool}`
     });
   }
@@ -10170,13 +10259,13 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       (name) => !firstPartyMcpTools.includes(name)
     );
     if (missingGoalTools.length > 0) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `goal-bearing sessions require first-party MCP tools: ${missingGoalTools.join(", ")}`
       });
     }
   }
   if (payload.targetSandboxId && payload.sandbox !== void 0 && payload.sandbox !== "new") {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "targetSandboxId requires an own sandbox (omit sandbox or pass 'new'); it cannot join a shared group"
     });
   }
@@ -10190,7 +10279,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   const rigVersionMatchesGroup = (memberRigVersionId) => memberRigVersionId === frozenRigVersionId;
   if (sandboxChoice === "shared") {
     if (!parentSessionId) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: "sandbox:'shared' requires a parent session (spawn from inside a session); use 'new' for a top-level create."
       });
     }
@@ -10213,7 +10302,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     }
     if (variableSetMismatch || rigMismatch) {
       if (payload.sandbox === "shared") {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(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 sandbox environment as the creator's box (setup is fixed at creation); omit sandbox or pass 'new' when selecting a different sandbox environment."
         });
       }
@@ -10229,7 +10318,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   } else if (typeof sandboxChoice === "object") {
     const member = await getAnySessionInGroup(db, workspaceId, sandboxChoice.groupId);
     if (!member) {
-      throw new HTTPException16(404, {
+      throw new HTTPException17(404, {
         message: `sandbox group not found in workspace: ${sandboxChoice.groupId}`
       });
     }
@@ -10242,7 +10331,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       if (!memberVariableSetSelections.every(
         (memberVariableSetIds) => variableSetsMatchGroup(memberVariableSetIds)
       )) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(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.`
         });
       }
@@ -10254,7 +10343,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
       if (!memberRigVersionIds.every(
         (memberRigVersionId) => rigVersionMatchesGroup(memberRigVersionId)
       )) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: `sandbox group ${sandboxChoice.groupId} uses a different sandbox environment (setup is fixed at creation); select the group's sandbox environment or omit sandbox for a separate box.`
         });
       }
@@ -10264,12 +10353,12 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     inheritedSandboxOs = member.sandboxOs;
   }
   if (payload.workingDir !== void 0 && !payload.targetSandboxId) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "workingDir requires targetSandboxId (it is the targeted machine's working directory)"
     });
   }
   if (inheritedBackend === void 0 && !payload.targetSandboxId && (payload.sandboxBackend ?? settings.sandboxBackend) === "selfhosted") {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "selfhosted sessions require targetSandboxId; select an online Connected Machine"
     });
   }
@@ -10302,7 +10391,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     workingDir: payload.workingDir ?? null
   } : inheritedActiveTarget;
   if (effectiveSandboxBackend === "selfhosted" && effectiveSeedTarget === null && managedSessionGroupBackend(settings.sandboxBackend, effectiveSandboxBackend) === null) {
-    throw new HTTPException16(422, {
+    throw new HTTPException17(422, {
       message: "self-hosted execution runs on a Connected Machine, but no machine was selected or inherited; connect the parent session to a machine or provide machineTarget"
     });
   }
@@ -10333,7 +10422,7 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
   const initialLearning = payload.agentLearning && Object.keys(payload.agentLearning).length ? payload.agentLearning : null;
   const initialLearningContext = initialLearning && authorization ? await knowledgeContextForAccess(deps, authorization, "sessions:control") : null;
   if (initialLearning && initialLearningContext?.actor.kind !== "human") {
-    throw new HTTPException16(403, {
+    throw new HTTPException17(403, {
       message: "Chat learning settings require authenticated human session control"
     });
   }
@@ -10480,27 +10569,27 @@ async function createSessionForRequestInFileScope(unresolvedDeps, grant, workspa
     });
   } catch (error) {
     if (error instanceof PersonalResourceAttachmentAcceptanceError) {
-      throw new HTTPException16(
+      throw new HTTPException17(
         error.kind === "invalid" ? 422 : error.kind === "forbidden" ? 403 : 409,
         { message: error.message, cause: error }
       );
     }
     if (error instanceof AgentCommandAuthorityError) {
-      throw new HTTPException16(403, { message: error.message });
+      throw new HTTPException17(403, { message: error.message });
     }
     if (error instanceof SessionIdConflictError) {
-      throw new HTTPException16(409, {
+      throw new HTTPException17(409, {
         message: "requested session id is already in use"
       });
     }
     if (error instanceof NewSessionDraftConflictError) {
-      throw new HTTPException16(409, {
+      throw new HTTPException17(409, {
         message: error.message,
         cause: error
       });
     }
     if (error instanceof SessionCreateIdempotencyConflictError) {
-      throw new HTTPException16(409, { message: error.message, cause: error });
+      throw new HTTPException17(409, { message: error.message, cause: error });
     }
     throw error;
   }
@@ -10664,7 +10753,7 @@ async function acceptSessionUserMessageInFileScope(deps, grant, workspaceId, ses
       assertSessionAllowsProductModel(existingSession, effectiveModel);
     } catch (error) {
       if (error instanceof CodexCompactionV2ProviderLockedError) {
-        throw new HTTPException16(422, { message: error.message, cause: error });
+        throw new HTTPException17(422, { message: error.message, cause: error });
       }
       throw error;
     }
@@ -10690,7 +10779,7 @@ async function acceptSessionUserMessageInFileScope(deps, grant, workspaceId, ses
         (resource) => !acceptedResources.has(stableJson3(resource))
       );
       if (unacceptedDraftResource) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: "composer draft resources must be included in the accepted resource set"
         });
       }
@@ -10742,7 +10831,7 @@ async function acceptSessionUserMessageInFileScope(deps, grant, workspaceId, ses
       model: effectiveModel
     });
     if (requestedResources.some((resource) => resource.kind === "file") && !objectStorage) {
-      throw new HTTPException16(503, {
+      throw new HTTPException17(503, {
         message: "object storage is not configured"
       });
     }
@@ -10978,7 +11067,7 @@ async function setSessionModel(deps, grant, sessionId, request, surface = "core"
               latencyModeSource: "session"
             });
           } catch (error) {
-            throw new HTTPException16(422, {
+            throw new HTTPException17(422, {
               message: error instanceof Error ? error.message : "Invalid model settings",
               cause: error
             });
@@ -11013,7 +11102,7 @@ async function updateSessionMcpApprovalPolicy(deps, grant, sessionId, serverId,
     async (_session, context) => {
       const result = await context.updateSessionMcpApprovalPolicy(serverId, normalizedPolicy);
       if (!result.server) {
-        throw new HTTPException16(404, {
+        throw new HTTPException17(404, {
           message: "session MCP server not found"
         });
       }
@@ -11134,7 +11223,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       (tool) => !validatedIds.has(`${tool.kind}:${tool.id}`)
     );
     if (unknown) {
-      throw new HTTPException16(422, {
+      throw new HTTPException17(422, {
         message: `unknown MCP server id: ${unknown.id}`
       });
     }
@@ -11171,7 +11260,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       if (session.parentSessionId) {
         const parent = await context.getLockedSession(session.parentSessionId);
         if (!parent) {
-          throw new HTTPException16(409, {
+          throw new HTTPException17(409, {
             message: "parent session is no longer available"
           });
         }
@@ -11184,7 +11273,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
         );
         if (requestedMode === "workspace_default") {
           if (!parentTracksWorkspaceDefaults) {
-            throw new HTTPException16(403, {
+            throw new HTTPException17(403, {
               message: "a child may adopt workspace defaults only while its parent tracks workspace defaults"
             });
           }
@@ -11210,7 +11299,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
             (tool) => !parentFirstPartySet.has(tool)
           );
           if (widenedFirstPartyTool) {
-            throw new HTTPException16(403, {
+            throw new HTTPException17(403, {
               message: `session OpenGeni tools may only narrow the parent policy: ${widenedFirstPartyTool}`
             });
           }
@@ -11231,7 +11320,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       }
       if (connectorOnlyEdit) {
         if (session.toolPolicy.mode !== "workspace_default") {
-          throw new HTTPException16(409, {
+          throw new HTTPException17(409, {
             message: "adopt workspace defaults before editing connector exclusions"
           });
         }
@@ -11285,7 +11374,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
         if (nextPolicy.mode === "workspace_default" && (session.toolPolicy.excludedMcpServerIds ?? []).some(
           (id) => !nextPolicy.excludedMcpServerIds?.includes(id)
         )) {
-          throw new HTTPException16(403, {
+          throw new HTTPException17(403, {
             message: "an agent may not remove session connector exclusions"
           });
         }
@@ -11302,7 +11391,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
           (tool) => !currentFirstPartyCeiling.has(tool)
         );
         if (widenedFirstPartyTool) {
-          throw new HTTPException16(403, {
+          throw new HTTPException17(403, {
             message: `an agent may only narrow its session OpenGeni tools: ${widenedFirstPartyTool}`
           });
         }
@@ -11406,7 +11495,7 @@ async function updateSessionAgent(deps, grant, sessionId, request) {
       if (session.parentSessionId) {
         parent = await context.getLockedSession(session.parentSessionId);
         if (!parent) {
-          throw new HTTPException16(409, { message: "parent session is no longer available" });
+          throw new HTTPException17(409, { message: "parent session is no longer available" });
         }
         parentCeiling = parent.agent?.capabilities ?? legacySessionAgentCapabilities(deps.settings, parent, workspace.settings);
       }
@@ -11515,7 +11604,7 @@ async function updateSessionAgent(deps, grant, sessionId, request) {
       toolPolicy = writeThrough.toolPolicy;
       const nextInstructions = request.agent.instructions !== void 0 ? request.agent.instructions : session.instructions ?? null;
       if (goalOpen && !writeThrough.firstPartyMcpTools.includes("goal_complete")) {
-        throw new HTTPException16(422, {
+        throw new HTTPException17(422, {
           message: "a session with an open goal must keep its goal tools"
         });
       }
@@ -11588,13 +11677,13 @@ async function readSessionLineage(deps, grant, sessionId) {
   if (authorization?.relatedSessionAccess === "target") {
     const session = await getSession3(deps.db, grant.workspaceId, sessionId);
     if (!session) {
-      throw new HTTPException16(404, { message: "session not found" });
+      throw new HTTPException17(404, { message: "session not found" });
     }
     return { ancestors: [], children: [], truncated: false };
   }
   const lineage = await getSessionLineage(deps.db, grant.workspaceId, sessionId);
   if (!lineage) {
-    throw new HTTPException16(404, { message: "session not found" });
+    throw new HTTPException17(404, { message: "session not found" });
   }
   return lineage;
 }
@@ -12110,7 +12199,7 @@ function filenameForMimeType(mimeType) {
 }
 
 // src/application/external-workspace-members.ts
-import { HTTPException as HTTPException17 } from "hono/http-exception";
+import { HTTPException as HTTPException18 } from "hono/http-exception";
 import {
   AddExternalWorkspaceMemberRequest,
   ExternalIdentityReference,
@@ -12121,7 +12210,7 @@ import {
   ensureExternalIdentity as ensureExternalIdentity3,
   grantWorkspaceAccess,
   listWorkspaceMembers,
-  lockExternalWorkspaceMembershipLifecycle as lockExternalWorkspaceMembershipLifecycle2,
+  lockExternalWorkspaceMembershipLifecycle as lockExternalWorkspaceMembershipLifecycle3,
   requireWorkspace as requireWorkspace5,
   setRlsContext,
   withWorkspaceSubjectRls as withWorkspaceSubjectRls3,
@@ -12149,12 +12238,12 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
   requireApiKeyDelegationContext(context, payload.permissions);
   const authority = accountScopedApiKeyWorkspaceAuthority(context);
   if (!authority)
-    throw new HTTPException17(403, {
+    throw new HTTPException18(403, {
       message: "external onboarding requires an organization service key"
     });
   const grant = await requireFreshAccessGrant(c, deps, workspaceId, "members:manage");
   if (grant.accountId !== authority.accountId || payload.permissions.some((permission) => !hasPermission(grant.permissions, permission))) {
-    throw new HTTPException17(403, { message: "membership exceeds key authority" });
+    throw new HTTPException18(403, { message: "membership exceeds key authority" });
   }
   if (payload.operationId) {
     try {
@@ -12172,7 +12261,7 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
     }
   }
   return withWorkspaceSubjectRls3(deps.db, workspaceId, grant.subjectId, async (tx) => {
-    await lockExternalWorkspaceMembershipLifecycle2(tx, grant.accountId);
+    await lockExternalWorkspaceMembershipLifecycle3(tx, grant.accountId);
     const live = await requireFreshAccessGrant(
       c,
       { ...deps, db: tx },
@@ -12180,11 +12269,11 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
       "members:manage"
     );
     if (live.accountId !== grant.accountId || live.subjectId !== grant.subjectId || payload.permissions.some((permission) => !hasPermission(live.permissions, permission))) {
-      throw new HTTPException17(403, { message: "membership authority changed" });
+      throw new HTTPException18(403, { message: "membership authority changed" });
     }
     const workspace = await requireWorkspace5(tx, workspaceId);
     if (workspace.kind !== "shared" || workspace.accountId !== authority.accountId)
-      throw new HTTPException17(403, {
+      throw new HTTPException18(403, {
         message: "external onboarding requires a shared organization workspace"
       });
     const identity = await ensureExternalIdentity3(tx, {
@@ -12198,7 +12287,7 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
     const permissions = [...new Set(payload.permissions)];
     if (existing) {
       if (existing.permissions.length !== permissions.length || existing.permissions.some((permission) => !permissions.includes(permission))) {
-        throw new HTTPException17(409, {
+        throw new HTTPException18(409, {
           message: "existing membership differs; onboarding does not overwrite permissions"
         });
       }
@@ -12217,7 +12306,7 @@ async function addExternalWorkspaceMemberForRequest(c, deps, workspaceId, input)
 function rethrowExternalWorkspaceOperation(error) {
   const status = organizationMembershipHttpStatus(nestedPostgresSqlState4(error));
   if (status)
-    throw new HTTPException17(status, {
+    throw new HTTPException18(status, {
       message: status === 409 ? "External membership operation changed or was cancelled" : "External membership operation is not available"
     });
   throw error;
@@ -12226,7 +12315,7 @@ async function externalService(c, deps, organizationId) {
   const context = await requireAccessContext(c, deps);
   const authority = accountScopedApiKeyWorkspaceAuthority(context);
   if (!authority || authority.accountId !== organizationId || !hasPermission(authority.permissions, "members:manage")) {
-    throw new HTTPException17(403, {
+    throw new HTTPException18(403, {
       message: "External membership operation requires an organization service key"
     });
   }
@@ -12236,7 +12325,7 @@ async function lookupExternalIdentityForRequest(c, deps, organizationId, input)
   const service = await externalService(c, deps, organizationId);
   const identity = ExternalIdentityReference.safeParse(input);
   if (!identity.success)
-    throw new HTTPException17(422, { message: "Invalid external identity reference" });
+    throw new HTTPException18(422, { message: "Invalid external identity reference" });
   try {
     return await lookupExternalIdentity(deps.db, service, identity.data);
   } catch (error) {
@@ -12247,7 +12336,7 @@ async function cancelExternalWorkspaceMemberGrantForRequest(c, deps, organizatio
   const service = await externalService(c, deps, organizationId);
   const request = CancelExternalWorkspaceMemberGrantRequest.safeParse(input);
   if (!request.success)
-    throw new HTTPException17(422, { message: "Invalid external grant cancellation" });
+    throw new HTTPException18(422, { message: "Invalid external grant cancellation" });
   try {
     return await cancelExternalWorkspaceMemberGrant(
       deps.db,
@@ -12262,7 +12351,7 @@ async function updateExternalWorkspaceMemberForRequest(c, deps, organizationId,
   const service = await externalService(c, deps, organizationId);
   const request = UpdateExternalWorkspaceMemberRequest.safeParse(input);
   if (!request.success)
-    throw new HTTPException17(422, {
+    throw new HTTPException18(422, {
       message: `Invalid external member update: ${request.error.issues.slice(0, 5).map((issue) => `${issue.path.map(String).join(".") || "request"}: ${issue.message}`).join("; ")}`
     });
   requireApiKeyDelegationContext(await requireAccessContext(c, deps), request.data.permissions);
@@ -12278,7 +12367,7 @@ async function updateExternalWorkspaceMemberForRequest(c, deps, organizationId,
 }
 
 // src/application/external-identity-lifecycle.ts
-import { HTTPException as HTTPException18 } from "hono/http-exception";
+import { HTTPException as HTTPException19 } from "hono/http-exception";
 import { UpdateExternalIdentityMembershipRequest } from "@opengeni/contracts/external-identities";
 import { updateOrganizationMember } from "@opengeni/db";
 async function updateExternalIdentityMembershipForRequest(context, deps, organizationId, membershipId, input) {
@@ -12288,13 +12377,13 @@ async function updateExternalIdentityMembershipForRequest(context, deps, organiz
     (grant) => grant.accountId === organizationId && grant.subjectId === access.subjectId
   );
   if (!service || service.accountId !== organizationId || !account?.permissions.includes("account:admin")) {
-    throw new HTTPException18(403, {
+    throw new HTTPException19(403, {
       message: "external identity administration requires an organization service key"
     });
   }
   const parsed = UpdateExternalIdentityMembershipRequest.safeParse(input);
   if (!parsed.success)
-    throw new HTTPException18(422, { message: "invalid external identity transition" });
+    throw new HTTPException19(422, { message: "invalid external identity transition" });
   return updateOrganizationMember(deps.db, {
     organizationId,
     membershipId,
@@ -12316,7 +12405,7 @@ import {
   rotateSessionMcpCredentialsAtomically,
   SessionMcpCredentialRotationError
 } from "@opengeni/db/session-mcp-credential-rotation";
-import { HTTPException as HTTPException19 } from "hono/http-exception";
+import { HTTPException as HTTPException20 } from "hono/http-exception";
 
 // src/domain/session-native-connection-replacement.ts
 import { connectionMetadataMatchesBinding } from "@opengeni/db/session-mcp-credential-rotation";
@@ -12360,7 +12449,7 @@ function sessionMcpRotationFingerprint(key, scope, request) {
 }
 function requireRotationGrant(grant) {
   if (grantHasAgentAttemptAuthority(grant))
-    throw new HTTPException19(403, { message: "host authorization required" });
+    throw new HTTPException20(403, { message: "host authorization required" });
   requirePermission(grant, "sessions:control");
   requirePermission(grant, "mcp_servers:attach");
 }
@@ -12372,7 +12461,7 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
   requireRotationGrant(grant);
   const parsed = RotateSessionMcpCredentialsRequest.safeParse(raw);
   if (!parsed.success)
-    throw new HTTPException19(422, { message: "invalid credential rotation request" });
+    throw new HTTPException20(422, { message: "invalid credential rotation request" });
   const encryptionKey = requireVariableSetEncryption(deps.settings);
   let request;
   try {
@@ -12395,7 +12484,7 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
     if (new Set(request.updates.map((update) => update.id)).size !== request.updates.length)
       throw new Error();
   } catch {
-    throw new HTTPException19(422, { message: "invalid credential rotation headers or server IDs" });
+    throw new HTTPException20(422, { message: "invalid credential rotation headers or server IDs" });
   }
   const scope = {
     accountId: grant.accountId,
@@ -12446,17 +12535,17 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
         await externalAuthorize?.(tx);
         const fresh = await reauthorize(tx);
         if (fresh.accountId !== grant.accountId || fresh.workspaceId !== grant.workspaceId || fresh.subjectId !== grant.subjectId || fresh.principalKind !== grant.principalKind)
-          throw new HTTPException19(403, { message: "credential rotation authority changed" });
+          throw new HTTPException20(403, { message: "credential rotation authority changed" });
         requireRotationGrant(fresh);
         if (fresh.principalKind === "human_session" && !externalAuthorize) {
           const live = await getWorkspaceGrant4(tx, fresh.subjectId, fresh.workspaceId);
           if (live) {
             requireRotationGrant(live);
           } else if (!authorization.canonicalManagedHumanSession) {
-            throw new HTTPException19(403, { message: "credential rotation authority changed" });
+            throw new HTTPException20(403, { message: "credential rotation authority changed" });
           }
           if (!await subjectHasLiveWorkspaceAuthorityInScope(tx, scope)) {
-            throw new HTTPException19(403, { message: "credential rotation authority changed" });
+            throw new HTTPException20(403, { message: "credential rotation authority changed" });
           }
         }
         await requireSessionAuthorization({ ...deps, db: tx }, fresh, {
@@ -12468,17 +12557,17 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
       }
     });
   } catch (error) {
-    if (error instanceof HTTPException19)
-      throw new HTTPException19(error.status, { message: "credential rotation access denied" });
+    if (error instanceof HTTPException20)
+      throw new HTTPException20(error.status, { message: "credential rotation access denied" });
     if (error instanceof SessionAuthorizationDeniedError)
-      throw new HTTPException19(403, { message: "credential rotation access denied" });
+      throw new HTTPException20(403, { message: "credential rotation access denied" });
     if (error instanceof SessionAuthorizationUnavailableError)
-      throw new HTTPException19(503, { message: "credential rotation authorization unavailable" });
+      throw new HTTPException20(503, { message: "credential rotation authorization unavailable" });
     if (error instanceof SessionMcpCredentialRotationError) {
       const status = error.code === "receipt_key_unavailable" ? 503 : error.code === "authority_revoked" ? 403 : error.code === "not_found" ? 404 : error.code === "invalid_request" || error.code === "brokered_server" || error.code === "connection_unavailable" ? 422 : 409;
-      throw new HTTPException19(status, { message: `credential_rotation_${error.code}` });
+      throw new HTTPException20(status, { message: `credential_rotation_${error.code}` });
     }
-    throw new HTTPException19(503, { message: "credential rotation unavailable" });
+    throw new HTTPException20(503, { message: "credential rotation unavailable" });
   }
 }
 
@@ -12486,19 +12575,19 @@ async function rotateSessionMcpCredentialsForRequest(deps, authorization, sessio
 import {
   getWorkspaceGrant as getWorkspaceGrant5,
   resolveNamedManagedPersonalWorkspaceGrant as resolveNamedManagedPersonalWorkspaceGrant2,
-  lockExternalWorkspaceMembershipLifecycle as lockExternalWorkspaceMembershipLifecycle3,
+  lockExternalWorkspaceMembershipLifecycle as lockExternalWorkspaceMembershipLifecycle4,
   withWorkspaceSubjectRls as withWorkspaceSubjectRls4,
   lockConnectionSetupKey,
   nestedPostgresSqlState as nestedPostgresSqlState5
 } from "@opengeni/db";
-import { HTTPException as HTTPException20 } from "hono/http-exception";
+import { HTTPException as HTTPException21 } from "hono/http-exception";
 async function requireConnectOwnerAuthority(db, state, permission = "connections:write", origin = null) {
   async function requireExternal(continuation) {
     try {
       await requireExternalContinuationAuthority(db, continuation, state, permission);
     } catch (error) {
       const denied2 = nestedPostgresSqlState5(error) === "42501" || error instanceof Error && error.message === "External continuation authority unavailable";
-      throw new HTTPException20(denied2 ? 403 : 503, {
+      throw new HTTPException21(denied2 ? 403 : 503, {
         message: denied2 ? "Connection origin authority changed" : "Connection origin authority unavailable",
         cause: error
       });
@@ -12510,19 +12599,19 @@ async function requireConnectOwnerAuthority(db, state, permission = "connections
     return;
   }
   if (state.subjectId.startsWith("external_user:"))
-    throw new HTTPException20(403, { message: "External Connect continuation required" });
+    throw new HTTPException21(403, { message: "External Connect continuation required" });
   if (state.subjectId.startsWith("api_key:")) {
     const permissions = await lockConnectionSetupKey(db, state);
     if (!permissions || !hasPermission(permissions, permission))
-      throw new HTTPException20(403, { message: "Connection API key authority changed" });
+      throw new HTTPException21(403, { message: "Connection API key authority changed" });
     return;
   }
   await withWorkspaceSubjectRls4(db, state.workspaceId, state.subjectId, async (tx) => {
-    await lockExternalWorkspaceMembershipLifecycle3(tx, state.accountId);
+    await lockExternalWorkspaceMembershipLifecycle4(tx, state.accountId);
     const membership = await getWorkspaceGrant5(tx, state.subjectId, state.workspaceId);
     const grant = membership?.accountId === state.accountId ? membership : state.personalOwnerVerified ? await resolveNamedManagedPersonalWorkspaceGrant2(tx, state) : null;
     if (!grant || grant.accountId !== state.accountId || !hasPermission(grant.permissions, permission))
-      throw new HTTPException20(403, { message: "Connection owner authority changed" });
+      throw new HTTPException21(403, { message: "Connection owner authority changed" });
   });
 }
 
@@ -12585,7 +12674,7 @@ import {
   PORTABLE_SKILL_MAX_FILES,
   PORTABLE_SKILL_MAX_TOTAL_BYTES
 } from "@opengeni/runtime/skill-library";
-import { HTTPException as HTTPException21 } from "hono/http-exception";
+import { HTTPException as HTTPException22 } 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;
@@ -12597,7 +12686,7 @@ async function resolveSkillImport(rawUrl, client) {
   }
   const sourceCommit = await client.resolveCommit(parsed.owner, parsed.repository, parsed.ref);
   if (!gitCommit.test(sourceCommit)) {
-    throw new HTTPException21(422, { message: "GitHub returned an invalid source commit" });
+    throw new HTTPException22(422, { message: "GitHub returned an invalid source commit" });
   }
   const tree = await client.listTree(parsed.owner, parsed.repository, sourceCommit);
   const blobs = /* @__PURE__ */ new Map();
@@ -12613,12 +12702,12 @@ async function resolveSkillImport(rawUrl, client) {
   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 HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: `Skill contains more than ${PORTABLE_SKILL_MAX_FILES} files`
     });
   }
   if (declaredBytes > PORTABLE_SKILL_MAX_TOTAL_BYTES) {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: `Skill exceeds ${PORTABLE_SKILL_MAX_TOTAL_BYTES} bytes`
     });
   }
@@ -12628,7 +12717,7 @@ async function resolveSkillImport(rawUrl, client) {
     try {
       content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
     } catch {
-      throw new HTTPException21(422, {
+      throw new HTTPException22(422, {
         message: `Skill file is not valid UTF-8 text: ${relativeSkillPath(entry.path, sourcePath)}`
       });
     }
@@ -12641,14 +12730,14 @@ function buildResolvedImport(parsed, files, sourcePath, commit) {
   try {
     artifact = buildPortableSkillArtifact2(files);
   } catch (error) {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: error instanceof Error ? error.message : "Skill artifact is invalid"
     });
   }
   const repositoryUrl = `https://github.com/${parsed.owner}/${parsed.repository}`;
   const sourceCommit = commit ?? artifact.contentSha256;
   if (!commit && artifact.name.toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "") !== parsed.skillSlug.toLowerCase()) {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: "The downloaded skill does not match the requested name"
     });
   }
@@ -12705,10 +12794,10 @@ function parseSkillSource(rawUrl) {
   try {
     url = new URL(rawUrl);
   } catch {
-    throw new HTTPException21(422, { message: "Enter a valid GitHub or skills.sh URL" });
+    throw new HTTPException22(422, { message: "Enter a valid GitHub or skills.sh URL" });
   }
   if (url.protocol !== "https:" || url.username || url.password || url.hash) {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: "Skill imports require a credential-free HTTPS URL without a fragment"
     });
   }
@@ -12716,18 +12805,18 @@ function parseSkillSource(rawUrl) {
   try {
     segments = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
   } catch {
-    throw new HTTPException21(422, { message: "The Skill URL contains invalid encoding" });
+    throw new HTTPException22(422, { message: "The Skill URL contains invalid encoding" });
   }
   if (url.hostname === "skills.sh" || url.hostname === "www.skills.sh") {
     if (segments.length !== 3) {
-      throw new HTTPException21(422, {
+      throw new HTTPException22(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 HTTPException21(422, { message: "The skills.sh Skill name is invalid" });
+      throw new HTTPException22(422, { message: "The skills.sh Skill name is invalid" });
     }
     return {
       source: "skills_sh",
@@ -12740,12 +12829,12 @@ function parseSkillSource(rawUrl) {
     };
   }
   if (url.hostname !== "github.com" && url.hostname !== "www.github.com") {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: "Only github.com and skills.sh imports are supported"
     });
   }
   if (segments.length < 2) {
-    throw new HTTPException21(422, { message: "A GitHub URL must identify a repository" });
+    throw new HTTPException22(422, { message: "A GitHub URL must identify a repository" });
   }
   const owner = segments[0];
   const repository = stripGitSuffix(segments[1]);
@@ -12763,15 +12852,15 @@ function parseSkillSource(rawUrl) {
   }
   const mode = segments[2];
   if (mode !== "tree" && mode !== "blob") {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: "Use a GitHub repository, tree, folder, or SKILL.md URL"
     });
   }
   const ref = segments[3];
-  if (!ref) throw new HTTPException21(422, { message: "The GitHub URL is missing a revision" });
+  if (!ref) throw new HTTPException22(422, { message: "The GitHub URL is missing a revision" });
   const pathSegments = segments.slice(4);
   if (pathSegments.length === 0 && mode === "blob") {
-    throw new HTTPException21(422, { message: "The GitHub URL is missing a Skill folder" });
+    throw new HTTPException22(422, { message: "The GitHub URL is missing a Skill folder" });
   }
   const folderSegments = mode === "blob" && pathSegments.at(-1)?.toLowerCase() === "skill.md" ? pathSegments.slice(0, -1) : pathSegments;
   const requestedPath = folderSegments.length === 0 ? "." : normalizeGitHubPath(folderSegments);
@@ -12792,7 +12881,7 @@ async function selectSkillRoot(source, tree, readBlob, sourceCommit) {
   if (source.requestedPath) {
     const root = source.requestedPath;
     if (!skillFiles.includes(root)) {
-      throw new HTTPException21(422, {
+      throw new HTTPException22(422, {
         message: `No top-level SKILL.md was found in ${root}`
       });
     }
@@ -12801,7 +12890,7 @@ async function selectSkillRoot(source, tree, readBlob, sourceCommit) {
   let candidates = skillFiles;
   if (source.skillSlug) {
     if (skillFiles.length > PORTABLE_SKILL_MAX_FILES) {
-      throw new HTTPException21(422, {
+      throw new HTTPException22(422, {
         message: "Too many Skill candidates; paste the exact GitHub folder URL"
       });
     }
@@ -12810,14 +12899,14 @@ async function selectSkillRoot(source, tree, readBlob, sourceCommit) {
     const matches = await mapConcurrent(skillFiles, maxConcurrentBlobReads, async (root) => {
       const entry = entriesByPath.get(root === "." ? "SKILL.md" : `${root}/SKILL.md`);
       if ((entry.size ?? 0) > PORTABLE_SKILL_MAX_FILE_BYTES) {
-        throw new HTTPException21(422, {
+        throw new HTTPException22(422, {
           message: "Skill metadata is too large; paste the exact GitHub folder URL"
         });
       }
       const bytes = await readBlob(entry.sha);
       metadataBytes += bytes.byteLength;
       if (bytes.byteLength > PORTABLE_SKILL_MAX_FILE_BYTES || metadataBytes > PORTABLE_SKILL_MAX_TOTAL_BYTES) {
-        throw new HTTPException21(422, {
+        throw new HTTPException22(422, {
           message: "Skill metadata is too large; paste the exact GitHub folder URL"
         });
       }
@@ -12825,7 +12914,7 @@ async function selectSkillRoot(source, tree, readBlob, sourceCommit) {
       try {
         markdown = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
       } catch {
-        throw new HTTPException21(422, {
+        throw new HTTPException22(422, {
           message: "Skill metadata is not valid UTF-8; paste the exact GitHub folder URL"
         });
       }
@@ -12835,16 +12924,16 @@ async function selectSkillRoot(source, tree, readBlob, sourceCommit) {
     if (candidates.length === 0) {
       const folders = skillFiles.filter((path) => path.split("/").at(-1) === source.skillSlug);
       const exactPath = folders.length === 1 ? encodeGitHubPath(folders[0]) : "<exact-skill-folder-path>";
-      throw new HTTPException21(422, {
+      throw new HTTPException22(422, {
         message: `No Skill frontmatter name matches skills.sh slug "${source.skillSlug}"; the link may be stale. Check the current Skill name, or explicitly select the intended Skill using its exact GitHub folder URL: https://github.com/${source.owner}/${source.repository}/tree/${sourceCommit}/${exactPath}`
       });
     }
   }
   if (candidates.length === 0) {
-    throw new HTTPException21(422, { message: "No Skill folder with SKILL.md was found" });
+    throw new HTTPException22(422, { message: "No Skill folder with SKILL.md was found" });
   }
   if (candidates.length > 1) {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(422, {
       message: "This source contains multiple Skills; paste the exact GitHub folder URL"
     });
   }
@@ -12857,13 +12946,13 @@ function skillFilesUnderRoot(tree, root) {
     (entry) => entry.type === "commit" || entry.type === "blob" && entry.mode === "120000"
   );
   if (unsupported) {
-    throw new HTTPException21(422, {
+    throw new HTTPException22(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 HTTPException21(422, { message: "The selected Skill folder is empty" });
+    throw new HTTPException22(422, { message: "The selected Skill folder is empty" });
   }
   return files;
 }
@@ -12874,7 +12963,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 HTTPException21(422, { message: "The GitHub Skill path is invalid" });
+    throw new HTTPException22(422, { message: "The GitHub Skill path is invalid" });
   }
   return segments.join("/");
 }
@@ -12886,7 +12975,7 @@ function stripGitSuffix(value) {
 }
 function assertGitHubRepository(owner, repository) {
   if (!githubSegment.test(owner) || !githubSegment.test(stripGitSuffix(repository))) {
-    throw new HTTPException21(422, { message: "The GitHub owner or repository name is invalid" });
+    throw new HTTPException22(422, { message: "The GitHub owner or repository name is invalid" });
   }
 }
 async function mapConcurrent(values, concurrency, map) {
@@ -13057,7 +13146,7 @@ function parseRetryAfter(value) {
 }
 
 // src/domain/github-skill-source.ts
-import { HTTPException as HTTPException22 } from "hono/http-exception";
+import { HTTPException as HTTPException23 } from "hono/http-exception";
 import { pinnedFetch as pinnedFetch3, readResponseJsonBounded as readResponseJsonBounded2, readResponseTextBounded } from "@opengeni/network";
 import {
   PORTABLE_SKILL_MAX_FILES as PORTABLE_SKILL_MAX_FILES2,
@@ -13167,7 +13256,7 @@ async function downloadSkillSnapshot(settings, owner, repository, slug) {
   );
   if (!response.ok) {
     await response.body?.cancel();
-    throw new HTTPException22(response.status === 429 ? 429 : 422, {
+    throw new HTTPException23(response.status === 429 ? 429 : 422, {
       message: response.status === 429 ? "skills.sh is busy. Try again shortly." : response.status === 404 ? "This skill has no downloadable snapshot. Import its GitHub folder URL instead." : "Could not download this skill from skills.sh. Try again shortly."
     });
   }
@@ -13181,11 +13270,11 @@ async function downloadSkillSnapshot(settings, owner, repository, slug) {
     "Skill download"
   );
   if (!Array.isArray(payload.files) || payload.files.length === 0 || payload.files.length > PORTABLE_SKILL_MAX_FILES2) {
-    throw new HTTPException22(422, { message: "The downloaded skill has an invalid file list" });
+    throw new HTTPException23(422, { message: "The downloaded skill has an invalid file list" });
   }
   return payload.files.map((file) => {
     if (!file || typeof file !== "object" || typeof file.path !== "string" || typeof file.contents !== "string") {
-      throw new HTTPException22(422, { message: "The downloaded skill contains an invalid file" });
+      throw new HTTPException23(422, { message: "The downloaded skill contains an invalid file" });
     }
     return { path: file.path, content: file.contents };
   });
@@ -13212,7 +13301,7 @@ async function githubJson(settings, path, maxBytes, label) {
       await readResponseTextBounded(response, 8192, `${label} error`).catch(() => void 0);
       if (response.status === 404) throw new Error(`${label} was not found or is not public`);
       if (response.status === 403 || response.status === 429) {
-        throw new HTTPException22(429, {
+        throw new HTTPException23(429, {
           message: "GitHub's public request limit has been reached. Skill search is still available; try previewing again after the limit resets."
         });
       }
@@ -13256,7 +13345,7 @@ import {
   RigChangeTransitionError,
   updateScopedRig
 } from "@opengeni/db";
-import { HTTPException as HTTPException23 } from "hono/http-exception";
+import { HTTPException as HTTPException24 } from "hono/http-exception";
 import { boundedParallelMap } from "@opengeni/runtime/mcp-network";
 var MAX_RIGS_PER_WORKSPACE = 50;
 var MAX_CHECKS_PER_RIG = 100;
@@ -13295,21 +13384,21 @@ function rigActorForGrant(grant) {
 async function requireRigForApi(db, grant, rigId) {
   const rig = await getRig3(db, grant, rigId);
   if (!rig) {
-    throw new HTTPException23(404, { message: "sandbox environment not found" });
+    throw new HTTPException24(404, { message: "sandbox environment 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 HTTPException23(404, { message: "sandbox environment change not found" });
+    throw new HTTPException24(404, { message: "sandbox environment change not found" });
   }
   return change;
 }
 function trimmedRigName(name) {
   const trimmed = name.trim();
   if (!trimmed) {
-    throw new HTTPException23(422, { message: "sandbox environment name is required" });
+    throw new HTTPException24(422, { message: "sandbox environment name is required" });
   }
   return trimmed;
 }
@@ -13320,7 +13409,7 @@ function assertUniqueCheckNames(checks) {
   const seen = /* @__PURE__ */ new Set();
   for (const check of checks) {
     if (seen.has(check.name)) {
-      throw new HTTPException23(422, {
+      throw new HTTPException24(422, {
         message: `duplicate sandbox environment check name: ${check.name}`
       });
     }
@@ -13340,12 +13429,12 @@ async function assertVariableSetsExist(db, access, rigScope, ids) {
   for (const id of unique) {
     const variableSet = await getVariableSet2(db, access, id);
     if (!variableSet) {
-      throw new HTTPException23(422, {
+      throw new HTTPException24(422, {
         message: `unknown defaultVariableSetId: ${id}`
       });
     }
     if (!variableSetScopeAllowedForRig(rigScope, variableSet.scope)) {
-      throw new HTTPException23(422, {
+      throw new HTTPException24(422, {
         message: `${rigScope}-scoped sandbox environments cannot use ${variableSet.scope}-scoped variable sets`
       });
     }
@@ -13364,12 +13453,12 @@ async function createRigForApi(deps, grant, payload, options = {}) {
     payload.defaultVariableSetIds.length > 0 ? payload.defaultVariableSetIds : void 0
   );
   if (await countRigs(deps.db, grant, payload.scope) >= MAX_RIGS_PER_WORKSPACE) {
-    throw new HTTPException23(422, {
+    throw new HTTPException24(422, {
       message: `a workspace supports at most ${MAX_RIGS_PER_WORKSPACE} sandbox environments`
     });
   }
   if (await getRigByName(deps.db, grant, name, payload.scope)) {
-    throw new HTTPException23(409, {
+    throw new HTTPException24(409, {
       message: `sandbox environment name is already in use: ${name}`
     });
   }
@@ -13405,7 +13494,7 @@ async function updateRigForApi(deps, grant, rig, payload, options = {}) {
   if (name !== void 0 && name !== rig.name) {
     const existing = await getRigByName(deps.db, grant, name, rig.scope);
     if (existing && existing.id !== rig.id) {
-      throw new HTTPException23(409, {
+      throw new HTTPException24(409, {
         message: `sandbox environment name is already in use: ${name}`
       });
     }
@@ -13431,7 +13520,7 @@ async function deleteRigForApi(deps, grant, rig, options = {}) {
     let current = error;
     while (current instanceof Error) {
       if (current.message.includes("active sessions")) {
-        throw new HTTPException23(409, { message: current.message });
+        throw new HTTPException24(409, { message: current.message });
       }
       current = current.cause;
     }
@@ -13446,7 +13535,7 @@ async function deleteRigForApi(deps, grant, rig, options = {}) {
 async function proposeRigChangeForApi(deps, grant, rig, request, options = {}) {
   const workspaceId = rig.workspaceId;
   if (!rig.activeVersion) {
-    throw new HTTPException23(422, {
+    throw new HTTPException24(422, {
       message: "sandbox environment has no active version to base a change on"
     });
   }
@@ -13498,37 +13587,37 @@ 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 HTTPException23(409, {
+      throw new HTTPException24(409, {
         message: `sandbox environment moved since this change was verified (base ${error.expectedVersionId}, now ${error.actualVersionId ?? "none"}); re-verify before promoting`
       });
     }
     if (error instanceof RigChangeTransitionError) {
-      throw new HTTPException23(409, { message: error.message });
+      throw new HTTPException24(409, { message: error.message });
     }
     throw error;
   }
 }
 async function promoteSetupAppendChange(deps, grant, rig, change) {
   if (change.kind !== "setup_append") {
-    throw new HTTPException23(422, {
+    throw new HTTPException24(422, {
       message: "only setup_append changes auto-promote through this path"
     });
   }
   if (change.status !== "proposed" && change.status !== "verifying") {
-    throw new HTTPException23(409, {
+    throw new HTTPException24(409, {
       message: `sandbox environment change is ${change.status}; cannot promote`
     });
   }
   if (!change.baseVersionId) {
-    throw new HTTPException23(422, { message: "sandbox environment change has no base version" });
+    throw new HTTPException24(422, { message: "sandbox environment change has no base version" });
   }
   const base = await getRigVersion2(deps.db, rig.workspaceId, rig.id, change.baseVersionId);
   if (!base) {
-    throw new HTTPException23(404, { message: "base sandbox environment version not found" });
+    throw new HTTPException24(404, { message: "base sandbox environment version not found" });
   }
   const payload = change.payload;
   if (typeof payload.command !== "string" || !payload.command.trim()) {
-    throw new HTTPException23(422, {
+    throw new HTTPException24(422, {
       message: "setup_append change is missing command"
     });
   }
@@ -13576,26 +13665,26 @@ async function promoteSetupAppendChange(deps, grant, rig, change) {
 }
 async function promoteVerifiedDefinitionEditChangeForApi(deps, grant, rig, change) {
   if (change.kind !== "definition_edit") {
-    throw new HTTPException23(422, {
+    throw new HTTPException24(422, {
       message: "only definition_edit changes use explicit promote"
     });
   }
   if (change.status !== "proposed") {
-    throw new HTTPException23(409, {
+    throw new HTTPException24(409, {
       message: `sandbox environment change is ${change.status}; cannot promote`
     });
   }
   if (change.verification?.passed !== true) {
-    throw new HTTPException23(422, {
+    throw new HTTPException24(422, {
       message: "definition_edit change must pass verification before promote"
     });
   }
   if (!change.baseVersionId) {
-    throw new HTTPException23(422, { message: "sandbox environment change has no base version" });
+    throw new HTTPException24(422, { message: "sandbox environment change has no base version" });
   }
   const base = await getRigVersion2(deps.db, rig.workspaceId, rig.id, change.baseVersionId);
   if (!base) {
-    throw new HTTPException23(404, { message: "base sandbox environment version not found" });
+    throw new HTTPException24(404, { message: "base sandbox environment version not found" });
   }
   const payload = change.payload;
   const nextDefinition = {
@@ -13642,7 +13731,7 @@ async function promoteVerifiedDefinitionEditChangeForApi(deps, grant, rig, chang
 }
 async function createRigVersionForApi(deps, grant, rig, payload) {
   if (!rig.activeVersion) {
-    throw new HTTPException23(422, { message: "sandbox environment has no active version" });
+    throw new HTTPException24(422, { message: "sandbox environment has no active version" });
   }
   assertUniqueCheckNames(payload.checks);
   await assertVariableSetsExist(
@@ -13703,7 +13792,7 @@ import {
   readTurnExecutionPolicyV1 as readTurnExecutionPolicyV13
 } from "@opengeni/contracts";
 import { getSession as getSession4, getSessionTurnForAttempt as getSessionTurnForAttempt4 } from "@opengeni/db";
-import { HTTPException as HTTPException24 } from "hono/http-exception";
+import { HTTPException as HTTPException25 } from "hono/http-exception";
 
 // src/domain/pr-review.ts
 import { createHash as createHash4, createHmac as createHmac2, timingSafeEqual } from "crypto";
@@ -14234,7 +14323,7 @@ async function automationCredentialRestrictionForGrant(db, grant) {
   );
   const session = await getSession4(db, grant.workspaceId, actor.sessionId);
   if (!turn || turn.id !== actor.turnId || !session || session.accountId !== grant.accountId) {
-    throw new HTTPException24(403, {
+    throw new HTTPException25(403, {
       message: "the creating automation agent attempt is not available"
     });
   }
@@ -14243,7 +14332,7 @@ async function automationCredentialRestrictionForGrant(db, grant) {
     try {
       policy = readTurnExecutionPolicyV13(metadata);
     } catch {
-      throw new HTTPException24(409, {
+      throw new HTTPException25(409, {
         message: "The frozen automation creator credential ceiling is invalid"
       });
     }
@@ -14259,7 +14348,7 @@ function requireAutomationCredentialRestrictionPermissions(restriction, permissi
     (permission) => !isDeveloperSetupDelegatedPermissionAllowed(permission)
   );
   if (forbidden) {
-    throw new HTTPException24(403, {
+    throw new HTTPException25(403, {
       message: `Developer setup cannot delegate automation permission: ${forbidden}`
     });
   }
@@ -14725,7 +14814,7 @@ import {
   withWorkspaceSubjectRls as withWorkspaceSubjectRls5,
   resolveXaiProviderAccountAuthoritySnapshotForAcceptance
 } from "@opengeni/db";
-import { HTTPException as HTTPException25 } from "hono/http-exception";
+import { HTTPException as HTTPException26 } from "hono/http-exception";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 function scheduledTaskToolsProvided(rawPayload) {
   if (!rawPayload || typeof rawPayload !== "object") {
@@ -14746,9 +14835,7 @@ function workspaceCustomModelCommitGuard(input) {
       reference
     });
     if (!active) {
-      throw new HTTPException25(422, {
-        message: `model is not available: ${input.modelId}`
-      });
+      throw modelUnavailableHttpException(input.modelId);
     }
   };
 }
@@ -14796,7 +14883,7 @@ async function createValidatedScheduledTask(input) {
     "scheduled_tasks:manage"
   ) : null;
   if (learning && learningContext?.actor.kind !== "human") {
-    throw new HTTPException25(403, {
+    throw new HTTPException26(403, {
       message: "Only an authenticated person can configure Agent learning"
     });
   }
@@ -14826,7 +14913,7 @@ async function createValidatedScheduledTask(input) {
     verifySlackChannel: input.verifySlackChannel
   });
   if (knowledgeAction && input.payload.overlapPolicy === "allow_concurrent")
-    throw new HTTPException25(422, { message: "Source tasks require skip or buffer_one overlap" });
+    throw new HTTPException26(422, { message: "Source tasks require skip or buffer_one overlap" });
   const id = crypto.randomUUID();
   validateScheduledTaskSchedule(input.payload.schedule);
   const target = await validateScheduledTaskTarget({
@@ -14843,14 +14930,14 @@ async function createValidatedScheduledTask(input) {
     agentConfig
   });
   if (knowledgeAction?.destination.kind === "personal" && input.payload.runMode !== "new_session_per_run")
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "Personal source tasks create a private session for each run"
     });
   if (learning) {
     const workspace = await requireWorkspace6(input.db, input.grant.workspaceId);
     const destination = knowledgeAction?.destination.kind === "personal" || workspace.kind === "personal" || target?.tenancy?.visibility === "private" || target?.memoryScope === "user" ? "personal" : "workspace";
     if (learning.scope !== destination)
-      throw new HTTPException25(422, {
+      throw new HTTPException26(422, {
         message: `This task saves Knowledge in the ${destination} scope. Set its Agent learning override for that scope.`
       });
   }
@@ -15016,7 +15103,7 @@ async function frozenScheduledTaskCreatorPolicy(input) {
   }
   const session = await getSession5(input.db, input.grant.workspaceId, input.actor.sessionId);
   if (!session) {
-    throw new HTTPException25(403, {
+    throw new HTTPException26(403, {
       message: "the calling agent session is not available in this workspace"
     });
   }
@@ -15027,7 +15114,7 @@ async function frozenScheduledTaskCreatorPolicy(input) {
     input.actor.attemptId
   );
   if (!turn || turn.id !== input.actor.turnId) {
-    throw new HTTPException25(403, { message: "the calling agent attempt is not available" });
+    throw new HTTPException26(403, { message: "the calling agent attempt is not available" });
   }
   const turnPolicy = readTurnExecutionPolicyV14(turn.metadata);
   const sessionPolicy = readTurnExecutionPolicyV14(session.metadata);
@@ -15040,7 +15127,7 @@ async function frozenScheduledTaskCreatorPolicy(input) {
   );
   const firstPartyMcpPermissions = (session.firstPartyMcpPermissions ?? [...DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3]).filter((permission) => hasPermission(input.grant.permissions, permission));
   if (firstPartyMcpPermissions.length === 0) {
-    throw new HTTPException25(403, {
+    throw new HTTPException26(403, {
       message: "the calling agent session holds no first-party MCP permission it could delegate to scheduled runs"
     });
   }
@@ -15083,16 +15170,16 @@ async function withScheduledTaskAuthorityWriteErrors(run) {
     return await run();
   } catch (error) {
     if (error instanceof ScheduledTaskHeadChangedError)
-      throw new HTTPException25(409, {
+      throw new HTTPException26(409, {
         message: "Scheduled task changed. Reload it before saving."
       });
     if (nestedPostgresSqlState6(error) === "40001")
-      throw new HTTPException25(409, {
+      throw new HTTPException26(409, {
         message: "Scheduled task learning settings changed. Reload the task before saving."
       });
     if (nestedPostgresSqlState6(error) === "42501") {
       const detail = nestedPostgresMessage(error);
-      throw new HTTPException25(409, {
+      throw new HTTPException26(409, {
         message: detail ? `scheduled task authority denied: ${detail}` : "scheduled task authority denied"
       });
     }
@@ -15116,7 +15203,7 @@ async function updateScheduledTaskForApi(db, grant, taskId, update, learning) {
       "scheduled_tasks:manage"
     );
     if (context.actor.kind !== "human")
-      throw new HTTPException25(403, {
+      throw new HTTPException26(403, {
         message: "Only an authenticated person can configure Agent learning"
       });
     context.actor.settingsScopes = [learning.request.scope];
@@ -15138,7 +15225,7 @@ async function updateScheduledTaskForApi(db, grant, taskId, update, learning) {
           );
         const baseline = await getAgentLearningSettings(tx, context, baselineScope, source);
         if (baseline.version !== learning.request.expectedVersion)
-          throw new HTTPException25(409, {
+          throw new HTTPException26(409, {
             message: "Scheduled task learning settings changed. Reload the task before saving."
           });
         const task = await updateScheduledTask(tx, workspaceId, taskId, update);
@@ -15179,7 +15266,7 @@ async function assertScheduledTaskMutationOwner(db, grant, taskId) {
     createdByActor: writer.actor ?? null
   });
   if (!matches)
-    throw new HTTPException25(403, {
+    throw new HTTPException26(403, {
       message: "Only the schedule owner can change or run it. Copy it to create your own schedule."
     });
 }
@@ -15206,7 +15293,7 @@ async function scheduledTaskCredentialRestrictionForGrant(db, grant, actor) {
     actor.attemptId
   );
   if (!session || !turn || turn.id !== actor.turnId) {
-    throw new HTTPException25(403, { message: "the calling agent attempt is not available" });
+    throw new HTTPException26(403, { message: "the calling agent attempt is not available" });
   }
   const policies = [
     readTurnExecutionPolicyV14(turn.metadata),
@@ -15219,20 +15306,20 @@ async function scheduledTaskCredentialRestrictionForGrant(db, grant, actor) {
 async function validateScheduledTaskTarget(input) {
   if (input.runMode !== "existing_session") {
     if (input.targetSessionId) {
-      throw new HTTPException25(422, {
+      throw new HTTPException26(422, {
         message: "targetSessionId requires runMode=existing_session"
       });
     }
     return null;
   }
   if (!input.targetSessionId) {
-    throw new HTTPException25(input.missingTargetStatus ?? 422, {
+    throw new HTTPException26(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 HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "agentConfig.goal cannot be used with an existing-session target"
     });
   }
@@ -15251,44 +15338,44 @@ async function validateScheduledTaskTarget(input) {
     );
   } catch (error) {
     if (error instanceof SessionAuthorizationDeniedError) {
-      throw new HTTPException25(404, { message: "target session not found" });
+      throw new HTTPException26(404, { message: "target session not found" });
     }
     if (error instanceof SessionAuthorizationUnavailableError) {
-      throw new HTTPException25(503, { message: "session authorization is unavailable" });
+      throw new HTTPException26(503, { message: "session authorization is unavailable" });
     }
     throw error;
   }
   const session = await getSession5(input.db, input.grant.workspaceId, input.targetSessionId);
   if (!session || session.accountId !== input.grant.accountId) {
-    throw new HTTPException25(404, { message: "target session not found" });
+    throw new HTTPException26(404, { message: "target session not found" });
   }
   if (input.agentConfig.bundledSkillIds !== void 0 && !isDeepStrictEqual2(input.agentConfig.bundledSkillIds, session.bundledSkillIds)) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "An existing-session schedule cannot change that session's bundled Skill selection"
     });
   }
   if (session.status === "cancelled") {
-    throw new HTTPException25(409, {
+    throw new HTTPException26(409, {
       message: "target session is cancelled; choose a revivable session"
     });
   }
   if ((session.variableSetId ?? null) !== (input.variableSetId ?? null)) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "target session variableSet attachment does not match the scheduled task"
     });
   }
   if (!input.adoptTargetRig && (session.rigId ?? null) !== (input.rigId ?? null)) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "target session sandbox environment does not match the scheduled task"
     });
   }
   if (input.agentConfig.sandboxBackend !== void 0 && input.agentConfig.sandboxBackend !== session.sandboxBackend) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "target session sandbox backend does not match the scheduled task"
     });
   }
   if (scheduledSlackBotConnectionId(session.metadata) !== (input.agentConfig.slackBotConnectionId ?? null)) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "target session OpenGeni Slack bot binding does not match the scheduled task"
     });
   }
@@ -15298,19 +15385,19 @@ async function validateScheduledTaskMachineTarget(input) {
   const machineTarget = input.agentConfig.machineTarget;
   if (!machineTarget) {
     if (input.runMode !== "existing_session" && (input.agentConfig.sandboxBackend ?? input.settings.sandboxBackend) === "selfhosted") {
-      throw new HTTPException25(422, {
+      throw new HTTPException26(422, {
         message: "self-hosted scheduled tasks require a Connected Machine; select a machine before saving"
       });
     }
     return null;
   }
   if (input.runMode === "existing_session") {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "machineTarget cannot be used with an existing-session target"
     });
   }
   if (!input.settings.sandboxOwnershipEnabled || !input.settings.sandboxSelfhostedEnabled) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "Connected Machines are not enabled for scheduled tasks in this deployment"
     });
   }
@@ -15321,23 +15408,23 @@ async function validateScheduledTaskMachineTarget(input) {
   };
   const sandbox = await getSandbox5(input.db, access, machineTarget.targetSandboxId);
   if (!sandbox || sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "the selected Connected Machine is unavailable"
     });
   }
   if (sandbox.scope === "user") {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "personal Connected Machines cannot run unattended schedules; select a workspace or organization machine"
     });
   }
   const enrollment = input.requireOnline ? await getLiveEnrollmentConnection3(input.db, access, sandbox.enrollmentId) : await getEnrollment3(input.db, access, sandbox.enrollmentId);
   if (!enrollment || enrollment.status !== "active") {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: input.requireOnline ? "the selected Connected Machine is offline" : "the selected Connected Machine is unavailable"
     });
   }
   if (input.requireOnline && !enrollment.workspaceRoot) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "the selected Connected Machine has not reported a workspace root; reconnect it with a current agent"
     });
   }
@@ -15406,7 +15493,7 @@ async function requireScheduledTaskRigVariableSetAttachments(input) {
 async function requireScheduledTaskRig(db, access, rigId) {
   const rig = await getRig4(db, access, rigId);
   if (!rig) {
-    throw new HTTPException25(422, { message: `unknown rigId: ${rigId}` });
+    throw new HTTPException26(422, { message: `unknown rigId: ${rigId}` });
   }
   return rig;
 }
@@ -15418,7 +15505,7 @@ async function validatedScheduledTaskUpdate(input) {
       "scheduled_tasks:manage"
     ) : null;
     if (context?.actor.kind !== "human")
-      throw new HTTPException25(403, {
+      throw new HTTPException26(403, {
         message: "Only an authenticated person can configure Agent learning"
       });
   }
@@ -15438,7 +15525,7 @@ async function validatedScheduledTaskUpdate(input) {
     };
   }
   if (input.payload.action && input.payload.action.kind !== "agent_turn") {
-    throw new HTTPException25(422, { message: "Source ingestion uses an ordinary agent task" });
+    throw new HTTPException26(422, { message: "Source ingestion uses an ordinary agent task" });
   }
   const knowledgeSource = input.payload.agentConfig?.knowledgeSource ?? scheduledTaskKnowledgeSource(input.existing);
   if (knowledgeSource && requestedKnowledgeSource && !isDeepStrictEqual2(requestedKnowledgeSource, existingKnowledgeSource)) {
@@ -15449,16 +15536,16 @@ async function validatedScheduledTaskUpdate(input) {
     });
   }
   if (knowledgeSource && (input.payload.overlapPolicy ?? input.existing.overlapPolicy) === "allow_concurrent")
-    throw new HTTPException25(422, { message: "Source tasks require skip or buffer_one overlap" });
+    throw new HTTPException26(422, { message: "Source tasks require skip or buffer_one overlap" });
   if (knowledgeSource?.destination.kind === "personal" && (input.payload.runMode ?? input.existing.runMode) !== "new_session_per_run")
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "Personal source tasks create a private session for each run"
     });
   const existingTarget = input.existing.targetSessionId;
   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 HTTPException25(409, {
+    throw new HTTPException26(409, {
       message: "cannot target an existing session after this task created its reusable session; create a new task"
     });
   }
@@ -15484,7 +15571,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 HTTPException25(409, {
+      throw new HTTPException26(409, {
         message: "cannot change variableSet of a task with a live reusable session; recreate the task"
       });
     }
@@ -15505,7 +15592,7 @@ async function validatedScheduledTaskUpdate(input) {
   }
   if (input.payload.rigId !== void 0) {
     if (input.existing.runMode === "reusable_session" && input.existing.reusableSessionId !== null && input.payload.rigId !== input.existing.rigId) {
-      throw new HTTPException25(409, {
+      throw new HTTPException26(409, {
         message: "A reusable-session task cannot change rigId after materialization; recreate it"
       });
     }
@@ -15580,7 +15667,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) !== (nextAgentConfig2.slackBotConnectionId ?? null)) {
-      throw new HTTPException25(409, {
+      throw new HTTPException26(409, {
         message: "cannot change the OpenGeni Slack bot connection of a task with a live reusable session; recreate the task"
       });
     }
@@ -15628,7 +15715,7 @@ async function validatedScheduledTaskUpdate(input) {
     input.existing.id
   );
   if (existingXaiAuthority.scope === "user" && materialExecutionChange && (input.existing.createdBy.kind !== "subject" || input.existing.createdBy.subjectId !== input.grant.subjectId)) {
-    throw new HTTPException25(409, {
+    throw new HTTPException26(409, {
       message: "changing a user-scoped xAI scheduled task requires the same causal human"
     });
   }
@@ -15753,7 +15840,7 @@ async function validatedScheduledTaskUpdate(input) {
 async function requireScheduledTaskForApi(db, workspaceId, taskId) {
   const task = await getScheduledTask(db, workspaceId, taskId);
   if (!task) {
-    throw new HTTPException25(404, { message: "scheduled task not found" });
+    throw new HTTPException26(404, { message: "scheduled task not found" });
   }
   return task;
 }
@@ -15779,12 +15866,12 @@ async function restoreScheduledTask(db, previous) {
 }
 async function validateKnowledgeSourceSyncAction(input) {
   if (input.action.initiatingSubjectId !== input.grant.subjectId) {
-    throw new HTTPException25(403, {
+    throw new HTTPException26(403, {
       message: "knowledge source sync must preserve the exact initiating subject"
     });
   }
   if (input.action.connection.ownerSubjectId !== input.grant.subjectId) {
-    throw new HTTPException25(403, {
+    throw new HTTPException26(403, {
       message: "knowledge source connection must belong to the initiating subject"
     });
   }
@@ -15795,10 +15882,10 @@ async function validateKnowledgeSourceSyncAction(input) {
     initiatingSubjectId: input.grant.subjectId
   });
   if (!resolved || resolved.source.lifecycleState !== "active") {
-    throw new HTTPException25(404, { message: "knowledge source not found" });
+    throw new HTTPException26(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 HTTPException25(409, {
+    throw new HTTPException26(409, {
       message: "knowledge source authority or generation changed"
     });
   }
@@ -15809,7 +15896,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 HTTPException25(409, {
+    throw new HTTPException26(409, {
       message: "knowledge source connection authority changed or requires reconnect"
     });
   }
@@ -15833,11 +15920,11 @@ async function deleteScheduledTaskLifecycle(input) {
         input.workspaceId,
         input.taskId
       );
-      if (!task2) throw new HTTPException25(404, { message: "Scheduled task not found" });
+      if (!task2) throw new HTTPException26(404, { message: "Scheduled task not found" });
       await input.beforeDeleteCommit?.(tx);
       const wasLive = task2.deletedAt === null;
       if (scheduledTaskKnowledgeSource(task2) && (requireScheduledTaskKnowledgeSource(task2).initiatingSubjectId !== input.subjectId || requireScheduledTaskKnowledgeSource(task2).connection.ownerSubjectId !== input.subjectId)) {
-        throw new HTTPException25(403, {
+        throw new HTTPException26(403, {
           message: "knowledge source schedule requires the exact initiating subject"
         });
       }
@@ -15926,7 +16013,7 @@ async function validateScheduledTaskAgentConfig(input) {
   const actor = scheduledTaskInitiatorForGrant(input.grant).actor;
   const parent = actor ? await getSession5(input.db, input.workspaceId, actor.sessionId) : null;
   if (actor && (!parent || parent.accountId !== input.grant.accountId)) {
-    throw new HTTPException25(403, {
+    throw new HTTPException26(403, {
       message: "Scheduled Skill selection requires the creating agent's session"
     });
   }
@@ -15937,7 +16024,7 @@ async function validateScheduledTaskAgentConfig(input) {
       parent?.bundledSkillIds
     );
   } catch (error) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: error instanceof Error ? error.message : "Invalid bundled Skill selection"
     });
   }
@@ -15953,7 +16040,7 @@ async function validateScheduledTaskAgentConfig(input) {
   const requestedTools = validateToolRefs(input.payload.agentConfig.tools ?? [], runtimeSettings);
   const workspace = await requireWorkspace6(input.db, input.workspaceId);
   if (parent?.tenancy?.visibility === "private" && workspace.kind !== "personal" && input.payload.runMode !== "existing_session" && !input.payload.targetSessionId) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "Schedule this private chat as the existing-session target, or create the task in your Personal workspace."
     });
   }
@@ -15966,16 +16053,16 @@ async function validateScheduledTaskAgentConfig(input) {
   );
   const prompt = input.payload.agentConfig.prompt.trim();
   if (!prompt) {
-    throw new HTTPException25(422, { message: "scheduled task prompt is required" });
+    throw new HTTPException26(422, { message: "scheduled task prompt is required" });
   }
   if (hasReservedOpenGeniSlackBotSessionMetadata(input.payload.agentConfig.metadata)) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(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 HTTPException25(503, { message: "object storage is not configured" });
+    throw new HTTPException26(503, { message: "object storage is not configured" });
   }
   const fileActor = resources.some((resource) => resource.kind === "file") && hasPermission(input.grant.permissions, "files:read") ? input.authorization ? await fileOwnerContextForAccess({ db: input.db }, input.authorization, "files:read") : input.grant.principalKind === "agent_attempt" ? await fileOwnerContextForAgent({ db: input.db }, input.grant, "files:read") : { subjectId: input.grant.subjectId, privateFileOwnerSubjectId: null } : { subjectId: input.grant.subjectId, privateFileOwnerSubjectId: null };
   await withSessionRlsActorContext5(fileActor, async () => {
@@ -16011,7 +16098,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 HTTPException25(403, {
+      throw new HTTPException26(403, {
         message: `scheduled task maxNestedAgentDepth ${requestedMaxDepth} exceeds inherited limit ${inheritedMaxDepth}; workspace:admin is required to increase it`
       });
     }
@@ -16032,13 +16119,13 @@ function validateIncidentTelemetryPreflightSelection(settings, agentConfig) {
   const preflight = agentConfig.incidentTelemetryPreflight;
   if (executionClass === void 0 && preflight === void 0) return;
   if (executionClass !== "incident_telemetry" || !preflight) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "executionClass=incident_telemetry and incidentTelemetryPreflight must be configured together"
     });
   }
   for (const required of preflight.requiredResources) {
     if (!agentConfig.resources.some((selected) => isDeepStrictEqual2(selected, required))) {
-      throw new HTTPException25(422, {
+      throw new HTTPException26(422, {
         message: "incidentTelemetryPreflight.requiredResources must be exact selected resources"
       });
     }
@@ -16046,13 +16133,13 @@ function validateIncidentTelemetryPreflightSelection(settings, agentConfig) {
   const selectedMcpServerIds = new Set(agentConfig.tools.map((tool) => tool.id));
   selectedMcpServerIds.add("opengeni");
   if (preflight.requiredMcpServerIds.some((id) => !selectedMcpServerIds.has(id))) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "incidentTelemetryPreflight.requiredMcpServerIds must be exact selected MCP servers"
     });
   }
   const selectedFirstPartyTools = new Set(resolveFirstPartyMcpToolPolicy2(settings).default);
   if (preflight.requiredFirstPartyMcpTools.some((tool) => !selectedFirstPartyTools.has(tool))) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "incidentTelemetryPreflight.requiredFirstPartyMcpTools must be present in the selected first-party tool policy"
     });
   }
@@ -16060,18 +16147,18 @@ function validateIncidentTelemetryPreflightSelection(settings, agentConfig) {
   if ((preflight.requiredFirstPartyMcpPermissions ?? []).some(
     (permission) => !selectedFirstPartyPermissions.has(permission)
   )) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "incidentTelemetryPreflight.requiredFirstPartyMcpPermissions must be present in the scheduled responder permission policy"
     });
   }
   const route = preflight.dataSource.route;
   if (route.kind === "mcp" && !selectedMcpServerIds.has(route.serverId)) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "incidentTelemetryPreflight.dataSource.route must use a selected MCP server"
     });
   }
   if (route.kind === "first_party" && !selectedFirstPartyTools.has(route.tool)) {
-    throw new HTTPException25(422, {
+    throw new HTTPException26(422, {
       message: "incidentTelemetryPreflight.dataSource.route must use a selected first-party tool"
     });
   }
@@ -16079,14 +16166,14 @@ function validateIncidentTelemetryPreflightSelection(settings, agentConfig) {
     const declaredSets = new Set(preflight.requiredVariableSetNames);
     const declaredVariables = new Set(preflight.requiredVariableNames);
     if (!declaredSets.has(route.variableSetName) || route.variableNames.some((name) => !declaredVariables.has(name))) {
-      throw new HTTPException25(422, {
+      throw new HTTPException26(422, {
         message: "incidentTelemetryPreflight.dataSource.route variable metadata must be declared as required"
       });
     }
   }
   if (route.kind === "rig_credential_hook") {
     if (!preflight.requiredRig?.credentialHookIds.includes(route.credentialHookId)) {
-      throw new HTTPException25(422, {
+      throw new HTTPException26(422, {
         message: "incidentTelemetryPreflight.dataSource.route rig hook must be declared as required"
       });
     }
@@ -16097,13 +16184,13 @@ function validateScheduledTaskSchedule(schedule) {
     return;
   }
   if (new Date(schedule.startAt).getTime() >= new Date(schedule.endAt).getTime()) {
-    throw new HTTPException25(422, { message: "interval schedule endAt must be after startAt" });
+    throw new HTTPException26(422, { message: "interval schedule endAt must be after startAt" });
   }
 }
 function trimmedScheduledTaskName(name) {
   const trimmed = name.trim();
   if (!trimmed) {
-    throw new HTTPException25(422, { message: "scheduled task name is required" });
+    throw new HTTPException26(422, { message: "scheduled task name is required" });
   }
   return trimmed;
 }
@@ -16135,7 +16222,7 @@ import {
   requireWorkspace as requireWorkspace7,
   ScheduledTaskHeadChangedError as ScheduledTaskHeadChangedError2
 } from "@opengeni/db";
-import { HTTPException as HTTPException26 } from "hono/http-exception";
+import { HTTPException as HTTPException27 } from "hono/http-exception";
 import { z as z2 } from "zod";
 var ALWAYS_ATTACHED_CONNECTOR = "opengeni";
 var PRESERVED_ACCOUNT_SURFACES = /* @__PURE__ */ new Set([
@@ -16467,25 +16554,25 @@ async function refreshScheduledTaskAccess(input) {
   const { grant } = input.authorization;
   requirePermission(grant, "scheduled_tasks:manage");
   if (!isScheduledTaskAccessRefreshHuman(input.authorization, grant.workspaceId)) {
-    throw new HTTPException26(403, {
+    throw new HTTPException27(403, {
       message: "Only a signed-in person can refresh a schedule's access. API keys, services and agents cannot."
     });
   }
   const existing = await requireScheduledTaskForApi(input.db, grant.workspaceId, input.taskId);
   if (!hasAgentAccess(existing)) {
-    throw new HTTPException26(422, {
+    throw new HTTPException27(422, {
       message: "This schedule has no connectors or tools to refresh."
     });
   }
   if (existing.executionDigest !== input.request.executionDigest) {
-    throw new HTTPException26(409, {
+    throw new HTTPException27(409, {
       message: "This schedule changed. Reload it and review the refresh again."
     });
   }
   await assertScheduledTaskMutationOwner(input.db, grant, existing.id);
   const source = scheduledTaskAccessSource(existing, grant);
   if (!source) {
-    throw new HTTPException26(403, {
+    throw new HTTPException27(403, {
       message: "Only the schedule owner can refresh its access."
     });
   }
@@ -16526,7 +16613,7 @@ async function refreshScheduledTaskAccess(input) {
   update.expectedExecutionDigest = existing.executionDigest;
   if (plan.creatorFirstPartyPolicy) {
     if (plan.creatorFirstPartyPolicy.firstPartyMcpPermissions.length === 0) {
-      throw new HTTPException26(403, {
+      throw new HTTPException27(403, {
         message: "You hold none of the permissions this schedule's OpenGeni tools need, so it cannot be refreshed with your access."
       });
     }
@@ -16536,7 +16623,7 @@ async function refreshScheduledTaskAccess(input) {
     return await updateScheduledTaskForApi(input.db, grant, existing.id, update);
   } catch (error) {
     if (error instanceof ScheduledTaskHeadChangedError2) {
-      throw new HTTPException26(409, {
+      throw new HTTPException27(409, {
         message: "This schedule changed. Reload it and review the refresh again."
       });
     }
@@ -16744,6 +16831,7 @@ import {
   countSessionsAttachedToGroups,
   enumerateUtcDays,
   enumerateUtcHours,
+  getSessionAccessProjection,
   listFloorSessions,
   listLiveWarmLeases,
   listScheduledTasks,
@@ -16828,13 +16916,22 @@ var WORKSPACE_INSIGHTS_MODEL_FILTER_MAX_UTF8_BYTES = 512;
 var WorkspaceInsightsFilterValidationError = class extends Error {
   field;
   maxUtf8Bytes;
-  constructor(field, maxUtf8Bytes) {
-    super(`${field} must be at most ${maxUtf8Bytes} UTF-8 bytes`);
+  constructor(field, maxUtf8Bytes, message) {
+    super(message ?? `${field} must be at most ${maxUtf8Bytes} UTF-8 bytes`);
     this.name = "WorkspaceInsightsFilterValidationError";
     this.field = field;
     this.maxUtf8Bytes = maxUtf8Bytes;
   }
 };
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function normalizeWorkspaceInsightsSessionScope(value, field) {
+  const normalized = value?.trim() || null;
+  if (normalized === null || normalized === "all") return null;
+  if (!UUID_PATTERN.test(normalized)) {
+    throw new WorkspaceInsightsFilterValidationError(field, 36, `${field} must be a UUID`);
+  }
+  return normalized.toLowerCase();
+}
 function normalizeWorkspaceInsightsFilter(value, field) {
   const normalized = value?.trim() || null;
   if (normalized === null || normalized === "all") return null;
@@ -16955,18 +17052,40 @@ function insightsSessionLabel(input) {
   if (title) return title;
   return `${(input.depth ?? 0) > 0 ? "Agent" : "Session"} ${input.id.slice(0, 8)}`;
 }
+function insightsProjectLabel(input) {
+  switch (input.kind) {
+    case "project":
+      return input.name?.trim() || "Untitled project";
+    case "other":
+      return `${input.projects.toLocaleString("en-US")} other ${input.projects === 1 ? "project" : "projects"}`;
+    case "unfiled":
+      return "No project";
+    case "unavailable":
+      return "Root session not visible";
+  }
+}
 async function getWorkspaceInsights(db, settings, input, observePhase) {
   const provider = normalizeWorkspaceInsightsFilter(input.provider, "provider");
   const model = normalizeWorkspaceInsightsFilter(input.model, "model");
+  const rootSessionId = normalizeWorkspaceInsightsSessionScope(
+    input.rootSessionId,
+    "rootSessionId"
+  );
+  const sessionId = normalizeWorkspaceInsightsSessionScope(input.sessionId, "sessionId");
   await measureInsightsPhase(
     observePhase,
     "require_workspace",
     () => requireWorkspace8(db, input.workspaceId)
   );
+  const [visibleRootScope, visibleSessionScope] = await Promise.all([
+    rootSessionId ? getSessionAccessProjection(db, input.workspaceId, rootSessionId) : null,
+    sessionId ? getSessionAccessProjection(db, input.workspaceId, sessionId) : null
+  ]);
   const now = input.now ?? /* @__PURE__ */ new Date();
   const window = resolveRangeWindow(input.range, now);
   const modelFilterActive = Boolean(provider || model);
-  const filter = { provider, model };
+  const scopeActive = Boolean(rootSessionId || sessionId);
+  const filter = { provider, model, rootSessionId, sessionId };
   const [modelBundle, usageBundle, liveWarm, tasks, depth, floorRows, machinesOnline] = await Promise.all([
     measureInsightsPhase(
       observePhase,
@@ -17027,10 +17146,18 @@ async function getWorkspaceInsights(db, settings, input, observePhase) {
     factBuckets: factDays,
     rootDrivers,
     priorRootDrivers,
+    projects,
+    privateChats,
+    privateChatsTruncated,
     scheduleFacts,
     facets,
     recentCalls,
-    promptContributions
+    promptContributions,
+    dataThrough,
+    driverGroups,
+    driversTruncated,
+    facetsTruncated,
+    recentCallsTruncated
   } = modelBundle;
   const {
     workspaceCreditMicros,
@@ -17121,6 +17248,8 @@ async function getWorkspaceInsights(db, settings, input, observePhase) {
     0
   );
   const modelCalls = modelRows.reduce((sum, row) => sum + row.calls, 0);
+  const cachedTokens = modelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
+  const cacheInputTokens = modelRows.reduce((sum, row) => sum + row.cacheInputTokens, 0);
   const priorInputTokens = priorModelRows.reduce((sum, row) => sum + row.inputTokens, 0);
   const priorTotalTokens = priorModelRows.reduce((sum, row) => sum + row.totalTokens, 0);
   const priorCachedTokens = priorModelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
@@ -17145,7 +17274,7 @@ async function getWorkspaceInsights(db, settings, input, observePhase) {
       cacheKnownCalls: 0,
       calls: 0
     };
-    const modelCostMicros = modelFilterActive ? facts.costMicros : usageBuckets.get(bucket)?.costMicros ?? facts.costMicros;
+    const modelCostMicros = modelFilterActive || scopeActive ? facts.costMicros : usageBuckets.get(bucket)?.costMicros ?? facts.costMicros;
     return {
       label: input.range === "today" ? bucket.slice(11) : bucket.slice(5),
       modelCostUsd: microsToUsd(modelCostMicros),
@@ -17193,6 +17322,19 @@ async function getWorkspaceInsights(db, settings, input, observePhase) {
       deltaUsdVsPrior: creditUsd - priorUsd
     };
   });
+  const projectRows = projects.map((row) => ({
+    id: row.kind === "project" && row.channelId ? `project:${row.channelId}` : row.kind,
+    kind: row.kind,
+    label: insightsProjectLabel(row),
+    projects: row.projects,
+    rootSessions: row.rootSessions,
+    calls: row.calls,
+    creditUsd: microsToUsd(row.pricedCostMicros),
+    estimatedProviderUsd: microsToUsd(row.estimatedProviderCostMicros),
+    estimatedProviderCostKnownCalls: row.estimatedProviderCostKnownCalls,
+    tokens: row.totalTokens,
+    cacheHitPct: cacheHitPct(row.cachedTokens, row.cacheInputTokens)
+  }));
   const scheduleFactById = new Map(scheduleFacts.map((row) => [row.scheduledTaskId, row]));
   const schedules = tasks.map((task) => {
     const fact = scheduleFactById.get(task.id);
@@ -17247,6 +17389,9 @@ async function getWorkspaceInsights(db, settings, input, observePhase) {
       sessions: bucket.sessions
     })),
     drivers,
+    projects: projectRows,
+    privateChats,
+    privateChatsTruncated,
     schedules,
     recentCalls: recentCalls.map((row) => ({
       id: row.id,
@@ -17330,7 +17475,17 @@ async function getWorkspaceInsights(db, settings, input, observePhase) {
     billableTokenCap: limits.maxMonthlyTokensPerWorkspace ?? null,
     agentRunsUsed,
     agentRunCap: limits.maxMonthlyAgentRunsPerWorkspace ?? null,
-    modelFilterActive
+    modelFilterActive: modelFilterActive || scopeActive,
+    dataThrough: dataThrough?.toISOString() ?? null,
+    cacheHitPct: cacheHitPct(cachedTokens, cacheInputTokens),
+    scope: {
+      rootSessionId: visibleRootScope ? rootSessionId : null,
+      sessionId: visibleSessionScope ? sessionId : null
+    },
+    driverGroups,
+    driversTruncated,
+    facetsTruncated,
+    recentCallsTruncated
   });
   return { snapshot };
 }
@@ -17375,7 +17530,7 @@ function sanitizeSlackPublicationText(value) {
 }
 
 // src/domain/memory-slack-publication.ts
-var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var UUID_PATTERN2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var SELECTOR_SEGMENT_PATTERN = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/;
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -17496,7 +17651,7 @@ function validIdentity(input) {
     input.memory.supersededById,
     input.change.relatedMemoryId
   ].filter((value) => value !== null);
-  return uuids.every((value) => UUID_PATTERN.test(value)) && Number.isSafeInteger(input.memory.version) && input.memory.version > 0 && typeof input.memory.namespace === "string" && Array.isArray(input.memory.labels) && input.memory.labels.every((label) => typeof label === "string") && (input.change.ownerLabel === void 0 || input.change.ownerLabel === null || typeof input.change.ownerLabel === "string") && typeof input.distribution.shareSummary === "string" && IMPORTANCES.has(input.distribution.importance) && REQUESTED_MODES.has(input.distribution.slackMode) && CHANGE_KINDS.has(input.change.kind) && ORIGINS.has(input.change.origin) && AUDIENCES.has(input.distribution.audience) && SCOPE_TYPES.has(input.memory.scopeType) && MEMORY_STATUSES.has(input.memory.status) && MEMORY_KINDS.has(input.memory.kind);
+  return uuids.every((value) => UUID_PATTERN2.test(value)) && Number.isSafeInteger(input.memory.version) && input.memory.version > 0 && typeof input.memory.namespace === "string" && Array.isArray(input.memory.labels) && input.memory.labels.every((label) => typeof label === "string") && (input.change.ownerLabel === void 0 || input.change.ownerLabel === null || typeof input.change.ownerLabel === "string") && typeof input.distribution.shareSummary === "string" && IMPORTANCES.has(input.distribution.importance) && REQUESTED_MODES.has(input.distribution.slackMode) && CHANGE_KINDS.has(input.change.kind) && ORIGINS.has(input.change.origin) && AUDIENCES.has(input.distribution.audience) && SCOPE_TYPES.has(input.memory.scopeType) && MEMORY_STATUSES.has(input.memory.status) && MEMORY_KINDS.has(input.memory.kind);
 }
 function evaluateValidity(input) {
   const now = Date.parse(input.context.now);
@@ -18782,7 +18937,7 @@ function providerReceiptWire(receipt2) {
 }
 
 // src/domain/workspace-members.ts
-import { HTTPException as HTTPException27 } from "hono/http-exception";
+import { HTTPException as HTTPException28 } 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));
@@ -18792,27 +18947,27 @@ function isUserMember(member) {
 }
 function resolveMemberSubjectId(userId) {
   if (!userId) {
-    throw new HTTPException27(404, { message: "user is not registered" });
+    throw new HTTPException28(404, { message: "user is not registered" });
   }
   return `user:${userId}`;
 }
 function assertWorkspaceMemberRemovable(input) {
   const { members, subjectId, callerSubjectId } = input;
   if (subjectId === callerSubjectId) {
-    throw new HTTPException27(409, {
+    throw new HTTPException28(409, {
       message: "you cannot remove your own membership"
     });
   }
   const target = members.find((member) => member.subjectId === subjectId);
   if (!target) {
-    throw new HTTPException27(404, { message: "member not found" });
+    throw new HTTPException28(404, { message: "member not found" });
   }
   if (memberCanAdminister(target)) {
     const remainingAdmins = members.filter(
       (member) => member.subjectId !== subjectId && memberCanAdminister(member)
     );
     if (remainingAdmins.length === 0) {
-      throw new HTTPException27(409, {
+      throw new HTTPException28(409, {
         message: "cannot remove the last member who can manage this workspace"
       });
     }
@@ -18821,28 +18976,28 @@ function assertWorkspaceMemberRemovable(input) {
 function assertWorkspaceMemberUpdateAllowed(input) {
   const { members, subjectId, callerSubjectId, nextPermissions } = input;
   if (subjectId === callerSubjectId) {
-    throw new HTTPException27(409, {
+    throw new HTTPException28(409, {
       message: "you cannot change your own workspace access"
     });
   }
   const target = members.find((member) => member.subjectId === subjectId);
   if (!target) {
-    throw new HTTPException27(404, { message: "member not found" });
+    throw new HTTPException28(404, { message: "member not found" });
   }
   if (memberCanAdminister(target) && !memberCanAdminister({ permissions: nextPermissions }) && !members.some((member) => member.subjectId !== subjectId && memberCanAdminister(member))) {
-    throw new HTTPException27(409, {
+    throw new HTTPException28(409, {
       message: "the workspace must keep at least one administrator"
     });
   }
 }
 function assertWorkspaceDeletable(input) {
   if (input.workspaceCountForAccount <= 1) {
-    throw new HTTPException27(409, {
+    throw new HTTPException28(409, {
       message: "cannot delete the account's only workspace"
     });
   }
   if (input.activeSessionCount > 0) {
-    throw new HTTPException27(409, {
+    throw new HTTPException28(409, {
       message: "stop the workspace's running sessions before deleting it"
     });
   }
@@ -19102,7 +19257,7 @@ import {
   saveNewSessionDraftInTransaction,
   withWorkspaceSubjectRls as withWorkspaceSubjectRls6
 } from "@opengeni/db";
-import { HTTPException as HTTPException28 } from "hono/http-exception";
+import { HTTPException as HTTPException29 } from "hono/http-exception";
 import { canonicalizeConfiguredModelId as canonicalizeConfiguredModelId3 } from "@opengeni/config";
 function hasOwn(value, key) {
   return typeof value === "object" && value !== null && Object.hasOwn(value, key);
@@ -19282,7 +19437,7 @@ async function saveActorNewSessionDraftInFileScope(deps, grant, workspaceId, raw
   const tools = toolsProvided ? validateToolRefs(input.tools, runtimeSettings) : [];
   await validateGitHubRepositorySelection(deps.db, workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !deps.objectStorage) {
-    throw new HTTPException28(503, {
+    throw new HTTPException29(503, {
       message: "object storage is not configured"
     });
   }
@@ -19334,7 +19489,7 @@ async function saveActorNewSessionDraftInFileScope(deps, grant, workspaceId, raw
     return { ...mapped, modelProvided: draftModelProvided(deps.settings, mapped) };
   } catch (error) {
     if (error instanceof NewSessionDraftAccessError) {
-      throw new HTTPException28(403, { message: error.message });
+      throw new HTTPException29(403, { message: error.message });
     }
     throw error;
   }
@@ -19400,7 +19555,7 @@ async function submitComposerDraftForRequest(deps, grant, workspaceId, sessionId
 
 // src/application/session-commands.ts
 import { DraftTimelineAnnotations as DraftTimelineAnnotations3 } from "@opengeni/contracts";
-import { HTTPException as HTTPException29 } from "hono/http-exception";
+import { HTTPException as HTTPException30 } from "hono/http-exception";
 import {
   checkWorkspaceAllowance as checkWorkspaceAllowance3,
   deleteSessionQueueItemInTransaction,
@@ -19481,7 +19636,7 @@ function agentActor(context) {
 async function assertFreshAgentCommandAllowance(tx, deps, context, targetSessionId) {
   const target = await getSession7(tx, context.workspaceId, targetSessionId);
   if (!target || target.accountId !== context.accountId) {
-    throw new HTTPException29(404, { message: "Target session not found" });
+    throw new HTTPException30(404, { message: "Target session not found" });
   }
   if (deps.settings) {
     const { settings } = await resolveWorkspaceCatalogSettings(tx, deps.settings, {
@@ -19506,7 +19661,7 @@ async function assertFreshAgentCommandAllowance(tx, deps, context, targetSession
     subjectId: initiatingHumanForAllowance(frozen)
   });
   if (refusal) {
-    throw new HTTPException29(402, {
+    throw new HTTPException30(402, {
       message: refusal.message,
       cause: { allowed: false, ...refusal }
     });
@@ -20223,13 +20378,13 @@ import {
   withSessionRlsActorContext as withSessionRlsActorContext7
 } from "@opengeni/db";
 import { publishDurableSessionEvents as publishDurableSessionEvents4 } from "@opengeni/events";
-import { HTTPException as HTTPException30 } from "hono/http-exception";
+import { HTTPException as HTTPException31 } from "hono/http-exception";
 import { ArchivedSessionImportError as ArchivedSessionImportError2 } from "@opengeni/db";
 function requireImportAuthorization(authorization, workspaceId, permission) {
   const grant = requireResolvedAccessGrantAuthorization(authorization, workspaceId);
   requirePermission(grant, permission);
   if (grantHasAgentAttemptAuthority(grant)) {
-    throw new HTTPException30(403, {
+    throw new HTTPException31(403, {
       message: "Session history imports require a user or service request"
     });
   }
@@ -20266,7 +20421,7 @@ async function importArchivedSessionForRequest(deps, authorization, workspaceId,
   }
   const creator = creationInitiatorForGrant(grant);
   if (!creator.initiator)
-    throw new HTTPException30(403, { message: "Import creator is unavailable" });
+    throw new HTTPException31(403, { message: "Import creator is unavailable" });
   const actor = await fileOwnerContextForAccess(deps, authorization, "sessions:create");
   const result = await withSessionRlsActorContext7(
     actor,
@@ -20820,13 +20975,13 @@ import { createPinnedIntegrationTransport as createPinnedIntegrationTransport2 }
 import {
   buildConnectionTokenResolver,
   getConnectionMetadata as getConnectionMetadata5,
-  listConnectionsMetadata as listConnectionsMetadata3,
+  listConnectionsMetadata as listConnectionsMetadata4,
   listEnabledMcpCapabilityServers as listEnabledMcpCapabilityServers3,
   listConnectorToolPermissionPolicies,
   updateConnectorToolPermissionPolicies,
   resolveConnectorActionPolicy as resolveConnectorActionPolicy2
 } from "@opengeni/db";
-import { HTTPException as HTTPException31 } from "hono/http-exception";
+import { HTTPException as HTTPException32 } from "hono/http-exception";
 import { GMAIL_REST_MCP_TOOLS, isOfficialGmailMcpConfig } from "@opengeni/runtime";
 function connectorToolGroup(tool) {
   if (tool.annotations?.destructiveHint === true || tool.annotations?.readOnlyHint === false)
@@ -20834,25 +20989,38 @@ function connectorToolGroup(tool) {
   if (tool.annotations?.readOnlyHint === true) return "read";
   return "other";
 }
+function unpinnedConnectorToolPermissionAccount(ref, visible, subjectId) {
+  const matches = visible.filter(
+    (candidate) => candidate.subjectId === (ref.subjectScope === "subject" ? subjectId : null) && candidate.providerDomain === ref.providerDomain && (!ref.kind || candidate.kind === ref.kind) && candidate.status === "active"
+  );
+  if (matches.length > 1)
+    throw new HTTPException32(409, {
+      message: "Choose one account to manage its tool permissions"
+    });
+  return matches[0] ?? null;
+}
+function connectorToolPermissionReference(ref, connectionId) {
+  return { ...ref, accountSelection: void 0, connectionId };
+}
 async function resolveTarget2(input) {
   if (input.capabilityId.startsWith("api:")) {
-    throw new HTTPException31(404, {
+    throw new HTTPException32(404, {
       message: "Connected MCP connector not found; API Integration tool approval is set with installApiIntegration autoApprovedTools"
     });
   }
   const catalog = await buildCapabilityCatalog(input);
   const item = catalog.items.find((candidate) => candidate.id === input.capabilityId);
   if (!item || !item.enabled || item.kind !== "mcp" || !item.runtime.mcpServerId || item.source === "built_in") {
-    throw new HTTPException31(404, { message: "Connected MCP connector not found" });
+    throw new HTTPException32(404, { message: "Connected MCP connector not found" });
   }
   const enabled = await listEnabledMcpCapabilityServers3(input.db, input.workspaceId);
   const settings = settingsWithMcpCapabilityServers(input.settings, enabled);
   const server = settings.mcpServers.find((candidate) => candidate.id === item.runtime.mcpServerId);
   if (!server || server.url !== item.endpointUrl)
-    throw new HTTPException31(409, { message: "Connector configuration is unavailable" });
+    throw new HTTPException32(409, { message: "Connector configuration is unavailable" });
   const ref = server.connectionRef;
   if (ref?.authoritySource === "host")
-    throw new HTTPException31(409, {
+    throw new HTTPException32(409, {
       message: "Tool permissions for this connection are managed by its host"
     });
   let connection = ref?.connectionId ? await getConnectionMetadata5(
@@ -20861,21 +21029,19 @@ async function resolveTarget2(input) {
     ref.connectionId,
     input.grant.subjectId
   ) : null;
-  if (ref?.subjectScope === "subject" && !ref.connectionId) {
-    const visible = await listConnectionsMetadata3(
+  if (ref && !ref.connectionId && (ref.subjectScope === "subject" || ref.accountSelection === "all_eligible")) {
+    const visible = await listConnectionsMetadata4(
       input.db,
       input.workspaceId,
       input.grant.subjectId
     );
-    connection = visible.find(
-      (candidate) => candidate.subjectId === input.grant.subjectId && candidate.providerDomain === ref.providerDomain && (!ref.kind || candidate.kind === ref.kind) && candidate.status === "active"
-    ) ?? null;
+    connection = unpinnedConnectorToolPermissionAccount(ref, visible, input.grant.subjectId);
   }
   if (ref && (!connection || connection.providerDomain !== ref.providerDomain || ref.kind && connection.kind !== ref.kind || (ref.subjectScope === "subject" ? connection.subjectId !== input.grant.subjectId : connection.subjectId !== null))) {
-    throw new HTTPException31(409, { message: "Reconnect this connector to manage its tools" });
+    throw new HTTPException32(409, { message: "Reconnect this connector to manage its tools" });
   }
   if (connection?.subjectId && !input.personalOwnerVerified)
-    throw new HTTPException31(403, {
+    throw new HTTPException32(403, {
       message: "Only the authenticated connection owner may manage personal tool permissions"
     });
   const connectionId = connection?.id ?? `session-mcp:${server.id}:${createHash11("sha256").update(server.url, "utf8").digest("hex")}`;
@@ -20897,7 +21063,10 @@ async function listTools(input, target) {
       ...target.connection?.subjectId ? { subjectId: input.grant.subjectId } : {},
       serverId: target.server.id,
       toolName: "tools/list",
-      connectionRef: { ...target.server.connectionRef, connectionId: target.connectionId },
+      connectionRef: connectorToolPermissionReference(
+        target.server.connectionRef,
+        target.connectionId
+      ),
       destinationUrl: target.server.url
     });
     if (result.status !== "ok") throw new Error("Reconnect this connector to load its tools.");
@@ -21010,14 +21179,14 @@ function canManageConnectorPermissions(grant) {
 }
 async function updateConnectorToolPermissions(input) {
   if (!canManageConnectorPermissions(input.grant))
-    throw new HTTPException31(403, { message: "Connector management permission required" });
+    throw new HTTPException32(403, { message: "Connector management permission required" });
   if (input.payload.target === "tools" && input.payload.toolNames.some((name) => name === "*" || name !== name.trim()))
-    throw new HTTPException31(400, {
+    throw new HTTPException32(400, {
       message: "Tool names must be exact and cannot use the connector-default wildcard."
     });
   const target = await resolveTarget2(input);
   if (target.connectionId !== input.payload.connectionId)
-    throw new HTTPException31(409, {
+    throw new HTTPException32(409, {
       message: "The connector account changed. Reload its permissions."
     });
   await updateConnectorToolPermissionPolicies(input.db, {
@@ -21230,6 +21399,7 @@ export {
   computeScheduledTaskAccessPlan,
   configureManagedUserAdmission,
   connectorToolGroup,
+  connectorToolPermissionReference,
   consentManagedHumanSandboxRecovery,
   controlAgentSessionWorkstream,
   controlHumanSessionWorkstream,
@@ -21350,6 +21520,7 @@ export {
   importArchivedSessionForRequest,
   initialAutomaticTitleForSessionStart,
   initiatingHumanForAllowance,
+  insightsProjectLabel,
   insightsSessionLabel,
   inspectEditableArtifactLiveWireEnvelope,
   installSkill,
@@ -21406,6 +21577,7 @@ export {
   mergeRigDefaultVariableSetEnvironment,
   mergeToolRefs,
   modelFundingForAdmission,
+  modelUnavailableHttpException,
   moveHumanQueuePrompt,
   nativeConnectionCapabilityRecommendations,
   normalizeConversationActor,
@@ -21422,6 +21594,7 @@ export {
   normalizeResources,
   normalizeVideoGenerationRequest,
   normalizeWorkspaceInsightsFilter,
+  normalizeWorkspaceInsightsSessionScope,
   normalizedSessionMcpCredentialHeaders,
   officialMcpRegistryUrl,
   ogatxEditableArtifactMutationIntentCodec,
@@ -21617,6 +21790,7 @@ export {
   syncUpdatedScheduledTask,
   triggerScheduledTaskForGrant,
   unboundGitHubRepositoryResources,
+  unpinnedConnectorToolPermissionAccount,
   unsupportedEditableArtifactExport,
   updateConnectorToolPermissions,
   updateExternalIdentityMembershipForRequest,
@@ -21649,6 +21823,7 @@ export {
   validateVariableSetAttachment,
   validatedScheduledTaskUpdate,
   variableSetScopeAllowedForRig,
+  verifyDirectModelAccess,
   verifyPrReviewWebhook,
   videoGenerationAdmissionKey,
   videoGenerationCapabilitiesForPolicy,
@@ -21672,6 +21847,7 @@ export {
   workspaceCustomModelReference,
   workspaceInsightsPhaseMetricObserver,
   workspaceSessionEffectiveToolsContext,
+  workspaceSessionToolPolicyContext,
   workspaceSessionToolPolicyDefaultServerIds,
   workspaceSessionToolPolicyDefaultServerIdsFor,
   workspaceSessionToolPolicyServerIds,