@opengeni/core 0.11.8 → 0.12.0

package/dist/index.js

@@ -83,7 +83,8 @@ function routingEnabled(settings) {
 }
 function wrapChannelABoxWithRouting(services, ids, established) {
   const { db, settings, bus } = services;
-  const beforeMutation = async ({
+  const homeLease = ids.homeLease;
+  const beforeMutation = homeLease ? async ({
     op,
     backend
   }) => {
@@ -99,15 +100,15 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       sessionId: ids.sessionId,
       requestId: ids.directRequest.requestId,
       holderId: ids.directRequest.holderId,
-      sandboxGroupId: ids.homeLease.sandboxGroupId,
+      sandboxGroupId: homeLease.sandboxGroupId,
       expectedEpoch: backend.leaseEpoch,
       expectedInstanceId: backend.providerInstanceId,
       routeTargetId: backend.sandboxId,
       routeEpoch: backend.activeEpoch,
       operation: op
     });
-  };
-  const afterMutation = async ({
+  } : void 0;
+  const afterMutation = homeLease ? async ({
     op,
     backend,
     admission,
@@ -133,7 +134,7 @@ function wrapChannelABoxWithRouting(services, ids, established) {
           kind: "direct",
           requestId: ids.directRequest.requestId,
           holderId: ids.directRequest.holderId,
-          sandboxGroupId: ids.homeLease.sandboxGroupId,
+          sandboxGroupId: homeLease.sandboxGroupId,
           expectedEpoch: backend.leaseEpoch,
           expectedInstanceId: backend.providerInstanceId,
           routeTargetId: exactAdmission.routeTargetId,
@@ -148,7 +149,7 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       sessionId: ids.sessionId,
       requestId: ids.directRequest.requestId,
       holderId: ids.directRequest.holderId,
-      sandboxGroupId: ids.homeLease.sandboxGroupId,
+      sandboxGroupId: homeLease.sandboxGroupId,
       expectedEpoch: backend.leaseEpoch,
       expectedInstanceId: backend.providerInstanceId,
       routeTargetId: exactAdmission.routeTargetId,
@@ -157,8 +158,8 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       operation: op,
       outcome
     });
-  };
-  const beforeProcessMutation = async ({
+  } : void 0;
+  const beforeProcessMutation = homeLease ? async ({
     op,
     process
   }) => await advanceWorkspaceGenerationForRetainedProcess(db, {
@@ -167,8 +168,8 @@ function wrapChannelABoxWithRouting(services, ids, established) {
     sessionId: ids.sessionId,
     processId: process.id,
     operation: op
-  });
-  const afterProcessMutation = async ({
+  }) : void 0;
+  const afterProcessMutation = homeLease ? async ({
     op,
     process,
     admission,
@@ -186,8 +187,8 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       operation: op,
       outcome
     });
-  };
-  const settleProcess = async ({
+  } : void 0;
+  const settleProcess = homeLease ? async ({
     backend,
     process,
     proof
@@ -201,7 +202,9 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       processId: process.id
     });
     if (!durable || durable.providerSessionId !== process.providerSessionId || durable.providerBackend !== backend.kind || durable.providerInstanceId !== backend.providerInstanceId || durable.leaseEpoch !== backend.leaseEpoch || durable.routeKind !== (backend.sandboxId === null ? "home" : "active") || durable.routeTargetId !== backend.sandboxId || durable.routeEpoch !== backend.activeEpoch) {
-      throw new Error("API retained-process settlement lost its exact durable backend identity");
+      throw new Error(
+        "API retained-process settlement lost its exact durable backend identity"
+      );
     }
     await settleRetainedProcess(db, {
       accountId: ids.accountId,
@@ -214,7 +217,7 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       reason: proof.reason,
       idleGraceMs: settings.sandboxIdleGraceMs
     });
-  };
+  } : void 0;
   const resolver = makeActiveBackendResolver({
     workspaceId: ids.workspaceId,
     defaultBackend: established.session,
@@ -230,21 +233,34 @@ function wrapChannelABoxWithRouting(services, ids, established) {
     },
     controlRpcFactory: controlRpcFactory(bus),
     relay: relayConfigFromSettings(settings),
-    resolveDefaultBackend: async () => ({
-      session: established.session,
-      sandboxId: null,
-      kind: established.backendId,
-      leaseEpoch: ids.homeLease.leaseEpoch,
-      providerInstanceId: ids.homeLease.instanceId
-    })
+    selfhostedTimeoutMs: settings.sandboxSelfhostedControlTimeoutMs,
+    selfhostedExecTimeoutMs: settings.sandboxSelfhostedExecTimeoutMs,
+    ...ids.pinnedSelfhosted ? {
+      pinnedSelfhosted: {
+        sandboxId: ids.pinnedSelfhosted.sandboxId,
+        epoch: ids.pinnedSelfhosted.epoch,
+        session: established.session
+      }
+    } : {},
+    ...homeLease ? {
+      resolveDefaultBackend: async () => ({
+        session: established.session,
+        sandboxId: null,
+        kind: established.backendId,
+        leaseEpoch: homeLease.leaseEpoch,
+        providerInstanceId: homeLease.instanceId
+      })
+    } : {}
   });
   const proxy = new RoutingSandboxSession({
     defaultResolved: {
       session: established.session,
       sandboxId: null,
       kind: established.backendId,
-      leaseEpoch: ids.homeLease.leaseEpoch,
-      providerInstanceId: ids.homeLease.instanceId
+      ...homeLease ? {
+        leaseEpoch: homeLease.leaseEpoch,
+        providerInstanceId: homeLease.instanceId
+      } : {}
     },
     readPointer: async () => {
       if (!routingEnabled(settings)) {
@@ -254,36 +270,38 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       return pointer ?? { activeSandboxId: null, activeEpoch: 0 };
     },
     resolveActiveBackend: resolver,
-    beforeMutation,
-    afterMutation,
-    beforeProcessMutation,
-    afterProcessMutation,
-    settleProcess,
-    onDefaultBackendError: async ({ error }) => {
-      if (!isProviderSandboxGoneDuringRoutedOperation(ids.homeLease.backend, error)) return null;
-      const marked = await markWarmLeaseInstanceLost(db, {
-        accountId: ids.accountId,
-        workspaceId: ids.workspaceId,
-        sandboxGroupId: ids.homeLease.sandboxGroupId,
-        expectedEpoch: ids.homeLease.leaseEpoch,
-        expectedInstanceId: ids.homeLease.instanceId,
-        diagnostic: "provider_not_found_during_routed_operation"
-      });
-      if (marked.status === "marked" && bus) {
-        await appendAndPublishEvents(db, bus, ids.workspaceId, ids.sessionId, [
-          {
-            type: "sandbox.box.lost",
-            payload: { sandboxId: ids.homeLease.instanceId }
-          }
-        ]).catch(() => void 0);
+    ...beforeMutation ? { beforeMutation } : {},
+    ...afterMutation ? { afterMutation } : {},
+    ...beforeProcessMutation ? { beforeProcessMutation } : {},
+    ...afterProcessMutation ? { afterProcessMutation } : {},
+    ...settleProcess ? { settleProcess } : {},
+    ...homeLease ? {
+      onDefaultBackendError: async ({ error }) => {
+        if (!isProviderSandboxGoneDuringRoutedOperation(homeLease.backend, error)) return null;
+        const marked = await markWarmLeaseInstanceLost(db, {
+          accountId: ids.accountId,
+          workspaceId: ids.workspaceId,
+          sandboxGroupId: homeLease.sandboxGroupId,
+          expectedEpoch: homeLease.leaseEpoch,
+          expectedInstanceId: homeLease.instanceId,
+          diagnostic: "provider_not_found_during_routed_operation"
+        });
+        if (marked.status === "marked" && bus) {
+          await appendAndPublishEvents(db, bus, ids.workspaceId, ids.sessionId, [
+            {
+              type: "sandbox.box.lost",
+              payload: { sandboxId: homeLease.instanceId }
+            }
+          ]).catch(() => void 0);
+        }
+        const lease = marked.lease;
+        const restore = lease?.recovery.restore.status;
+        return {
+          leaseEpoch: lease?.leaseEpoch ?? homeLease.leaseEpoch,
+          recovery: marked.status === "stale" ? "superseded" : restore === "pending" ? "pending" : restore === "degraded" ? "degraded" : "unrecoverable"
+        };
       }
-      const lease = marked.lease;
-      const restore = lease?.recovery.restore.status;
-      return {
-        leaseEpoch: lease?.leaseEpoch ?? ids.homeLease.leaseEpoch,
-        recovery: marked.status === "stale" ? "superseded" : restore === "pending" ? "pending" : restore === "degraded" ? "degraded" : "unrecoverable"
-      };
-    }
+    } : {}
   });
   return { ...established, session: proxy };
 }
@@ -3291,6 +3309,7 @@ function sessionWithEffectiveToolPolicy(session, workspaceServerIds, workspaceDe
 }
 
 // src/domain/scheduled-tasks.ts
+import { OPENGENI_SLACK_BOT_SESSION_METADATA_KEY as OPENGENI_SLACK_BOT_SESSION_METADATA_KEY3 } from "@opengeni/contracts";
 import {
   createScheduledTask,
   deleteScheduledTask,
@@ -3300,7 +3319,7 @@ import {
   requireWorkspace as requireWorkspace2,
   updateScheduledTask
 } from "@opengeni/db";
-import { HTTPException as HTTPException10 } from "hono/http-exception";
+import { HTTPException as HTTPException11 } from "hono/http-exception";
 
 // src/domain/sessions.ts
 import { CODEX_MODEL_ID_PREFIX } from "@opengeni/codex";
@@ -3313,6 +3332,7 @@ import {
 import {
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
+  OPENGENI_SLACK_BOT_SESSION_METADATA_KEY as OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2,
   SessionSpawnDenial,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
@@ -3359,7 +3379,68 @@ import {
   publishDurableSessionEvents,
   publishDurableWorkspaceControlEvent
 } from "@opengeni/events";
+import { HTTPException as HTTPException10 } from "hono/http-exception";
+
+// src/domain/slack-bot.ts
+import {
+  OPENGENI_SLACK_BOT_CREDENTIAL_LABEL,
+  OPENGENI_SLACK_BOT_REQUIRED_SCOPES,
+  OPENGENI_SLACK_BOT_CREDENTIAL_ROLE,
+  OPENGENI_SLACK_BOT_SESSION_METADATA_KEY,
+  OpenGeniSlackBotConnectionMetadata
+} from "@opengeni/contracts";
+import {
+  getConnectionMetadata as getConnectionMetadata2
+} from "@opengeni/db";
 import { HTTPException as HTTPException9 } from "hono/http-exception";
+function openGeniSlackBotMetadata(metadata) {
+  const parsed = OpenGeniSlackBotConnectionMetadata.safeParse(metadata);
+  return parsed.success ? parsed.data : null;
+}
+function isOpenGeniSlackBotConnection(connection) {
+  const granted = new Set(connection.grantedScopes);
+  return connection.verifiedInstallAt != null && connection.verifiedInstallVersion === connection.version && connection.subjectId === null && connection.providerDomain === "slack.com" && connection.kind === "app_install" && granted.size === OPENGENI_SLACK_BOT_REQUIRED_SCOPES.length && OPENGENI_SLACK_BOT_REQUIRED_SCOPES.every((scope) => granted.has(scope)) && openGeniSlackBotMetadata(connection.metadata)?.credentialRole === OPENGENI_SLACK_BOT_CREDENTIAL_ROLE;
+}
+function hasReservedOpenGeniSlackBotMetadata(metadata) {
+  return metadata?.credentialRole === OPENGENI_SLACK_BOT_CREDENTIAL_ROLE || metadata?.credentialLabel === OPENGENI_SLACK_BOT_CREDENTIAL_LABEL;
+}
+function hasReservedOpenGeniSlackBotSessionMetadata(metadata) {
+  return Boolean(
+    metadata && Object.prototype.hasOwnProperty.call(metadata, OPENGENI_SLACK_BOT_SESSION_METADATA_KEY)
+  );
+}
+async function requireOpenGeniSlackBotConnection(db, workspaceId, connectionId) {
+  const connection = await getConnectionMetadata2(db, workspaceId, connectionId, null);
+  if (!connection || !isOpenGeniSlackBotConnection(connection)) {
+    throw new HTTPException9(422, {
+      message: "slackBotConnectionId must reference an OpenGeni Slack bot connection"
+    });
+  }
+  if (connection.status !== "active") {
+    throw new HTTPException9(422, {
+      message: `OpenGeni Slack bot connection is not active (${connection.status})`
+    });
+  }
+  return connection;
+}
+async function validateOpenGeniSlackBotConnectionSelection(db, grant, workspaceId, connectionId) {
+  requirePermission(grant, "connections:read");
+  return await requireOpenGeniSlackBotConnection(db, workspaceId, connectionId);
+}
+function scheduledSlackBotConnectionId(metadata) {
+  const value = metadata?.[OPENGENI_SLACK_BOT_SESSION_METADATA_KEY];
+  return typeof value === "string" && zUuid(value) ? value : null;
+}
+function isTrustedScheduledSlackBotSession(session) {
+  const scheduledTaskId = session.metadata.scheduledTaskId;
+  const scheduledTaskRunId = session.metadata.scheduledTaskRunId;
+  return session.createdBy?.kind === "service" && session.createdBy.subjectId === "scheduler" && typeof scheduledTaskId === "string" && zUuid(scheduledTaskId) && typeof scheduledTaskRunId === "string" && zUuid(scheduledTaskRunId) && session.createdByContext.scheduledTaskId === scheduledTaskId && session.createdByContext.scheduledTaskRunId === scheduledTaskRunId && scheduledSlackBotConnectionId(session.metadata) !== null;
+}
+function zUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+
+// src/domain/sessions.ts
 var reservedSessionMcpServerIds = /* @__PURE__ */ new Set(["opengeni", "files", "docs", "codex_apps"]);
 var maxSessionMcpCredentialHeaders = 16;
 var maxSessionMcpCredentialHeaderValueLength = 4096;
@@ -3391,7 +3472,7 @@ function sessionSpawnDenialEnvelope(error) {
 function serviceInitiatorForGrant(grant) {
   if (!grant.serviceInitiator) {
     if (grant.serviceInitiatorContext) {
-      throw new HTTPException9(403, {
+      throw new HTTPException10(403, {
         message: "service initiator context requires a signed service initiator"
       });
     }
@@ -3399,13 +3480,13 @@ function serviceInitiatorForGrant(grant) {
   }
   const initiator = ServiceTurnInitiator.safeParse(grant.serviceInitiator);
   if (!initiator.success) {
-    throw new HTTPException9(403, {
+    throw new HTTPException10(403, {
       message: "a delegated command initiator must be a bounded service principal"
     });
   }
   const context = ServiceTurnInitiatorContext.safeParse(grant.serviceInitiatorContext ?? {});
   if (!context.success) {
-    throw new HTTPException9(403, {
+    throw new HTTPException10(403, {
       message: "delegated service initiator context is invalid or reserved"
     });
   }
@@ -3413,7 +3494,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 HTTPException9(403, {
+    throw new HTTPException10(403, {
       message: "a service initiator cannot replace an exact agent-attempt initiator"
     });
   }
@@ -3431,7 +3512,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 HTTPException9(403, { message: "caller attempt claims are incomplete" });
+      throw new HTTPException10(403, { message: "caller attempt claims are incomplete" });
     }
     const actor = {
       type: "agent_attempt",
@@ -3460,27 +3541,27 @@ 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 HTTPException9(422, {
+    throw new HTTPException10(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 HTTPException9(422, { message: `invalid credential header name: ${name}` });
+      throw new HTTPException10(422, { message: `invalid credential header name: ${name}` });
     }
     const lower = name.toLowerCase();
     if (seen.has(lower)) {
-      throw new HTTPException9(422, { message: `duplicate credential header name: ${name}` });
+      throw new HTTPException10(422, { message: `duplicate credential header name: ${name}` });
     }
     seen.add(lower);
     if (value.length === 0 || value.length > maxSessionMcpCredentialHeaderValueLength) {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: `credential header ${name} must be 1-${maxSessionMcpCredentialHeaderValueLength} characters`
       });
     }
     if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: `credential header ${name} contains forbidden control characters`
       });
     }
@@ -3547,11 +3628,11 @@ function validateSessionMcpServersForCreate(settings, grant, servers) {
   const metadata = [];
   for (const server of servers) {
     if (seenIds.has(server.id)) {
-      throw new HTTPException9(422, { message: `duplicate session MCP server id: ${server.id}` });
+      throw new HTTPException10(422, { message: `duplicate session MCP server id: ${server.id}` });
     }
     seenIds.add(server.id);
     if (reservedSessionMcpServerIds.has(server.id) || existingIds.has(server.id)) {
-      throw new HTTPException9(422, { message: `MCP server id already exists: ${server.id}` });
+      throw new HTTPException10(422, { message: `MCP server id already exists: ${server.id}` });
     }
     const headers = normalizedSessionMcpCredentialHeaders(server.headers);
     const headersEncrypted = Object.fromEntries(
@@ -3591,13 +3672,13 @@ function validateInheritedSessionMcpServersForCreate(servers) {
   const seenIds = /* @__PURE__ */ new Set();
   for (const server of servers) {
     if (seenIds.has(server.id)) {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: `duplicate inherited session MCP server id: ${server.id}`
       });
     }
     seenIds.add(server.id);
     if (reservedSessionMcpServerIds.has(server.id)) {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: `reserved inherited session MCP server id: ${server.id}`
       });
     }
@@ -3629,13 +3710,13 @@ function validateSessionMcpCredentialUpdates(input) {
   const seenIds = /* @__PURE__ */ new Set();
   const encryptedUpdates = input.updates.map((update) => {
     if (seenIds.has(update.id)) {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: `duplicate session MCP credential update id: ${update.id}`
       });
     }
     seenIds.add(update.id);
     if (!knownIds.has(update.id)) {
-      throw new HTTPException9(422, { message: `unknown session MCP server id: ${update.id}` });
+      throw new HTTPException10(422, { message: `unknown session MCP server id: ${update.id}` });
     }
     const headers = normalizedSessionMcpCredentialHeaders(update.headers);
     return {
@@ -3739,7 +3820,7 @@ async function createAndStartSession(input) {
 async function finishStartSession(input, session) {
   if (input.seedTargetSandbox) {
     if (session.sandboxBackend === "none") {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: "cannot target a machine for a session with no sandbox (backend: none)"
       });
     }
@@ -3759,7 +3840,7 @@ async function finishStartSession(input, session) {
       input.seedTargetSandbox.workingDir ?? null
     );
     if (!seeded.swapped) {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: `cannot target sandbox ${input.seedTargetSandbox.sandboxId}: ${seeded.reason ?? "target is not attachable"}`
       });
     }
@@ -3811,7 +3892,7 @@ function canonicalConfiguredModel(settings, model) {
   if (settings.codexSubscriptionEnabled && canonicalModel.startsWith(CODEX_MODEL_ID_PREFIX)) {
     return canonicalModel;
   }
-  throw new HTTPException9(422, { message: `model is not available: ${model}` });
+  throw new HTTPException10(422, { message: `model is not available: ${model}` });
 }
 function assertConfiguredModel(settings, model) {
   canonicalConfiguredModel(settings, model);
@@ -3834,7 +3915,7 @@ async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model
     modelId: canonicalModel
   });
   if (!verdict.allowed) {
-    throw new HTTPException9(422, {
+    throw new HTTPException10(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`
     });
   }
@@ -3842,10 +3923,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 HTTPException9(404, { message: "session turn not found" });
+    throw new HTTPException10(404, { message: "session turn not found" });
   }
   if (turn.status !== "queued") {
-    throw new HTTPException9(409, {
+    throw new HTTPException10(409, {
       message: `turn is ${turn.status}; only queued turns can be changed`
     });
   }
@@ -3898,13 +3979,13 @@ async function postUserMessageTurn(input) {
     );
   } catch (error) {
     if (error instanceof QueueCommandConflictError || error instanceof SessionControlConflictError) {
-      throw new HTTPException9(409, { message: error.message });
+      throw new HTTPException10(409, { message: error.message });
     }
     if (error instanceof Error && error.message.includes("cancelled")) {
-      throw new HTTPException9(409, { message: error.message });
+      throw new HTTPException10(409, { message: error.message });
     }
     if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
-      throw new HTTPException9(422, { message: error.message });
+      throw new HTTPException10(422, { message: error.message });
     }
     throw error;
   }
@@ -3957,6 +4038,11 @@ async function postUserMessageTurn(input) {
 async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
+  if (hasReservedOpenGeniSlackBotSessionMetadata(payload.metadata)) {
+    throw new HTTPException10(422, {
+      message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY2} is reserved for scheduler routing`
+    });
+  }
   if (payload.idempotencyKey) {
     const denial = await getSessionSpawnDenialByIdempotencyKey(
       db,
@@ -3977,7 +4063,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   }
   const parentSession = parentSessionId ? await getSession2(db, workspaceId, parentSessionId) : null;
   if (parentSessionId && !parentSession) {
-    throw new HTTPException9(404, {
+    throw new HTTPException10(404, {
       message: `parent session not found in workspace: ${parentSessionId}`
     });
   }
@@ -4042,7 +4128,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   const tools = withFirstPartyTools(selectedTools, runtimeSettings);
   await validateGitHubRepositorySelection(db, workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException9(503, { message: "object storage is not configured" });
+    throw new HTTPException10(503, { message: "object storage is not configured" });
   }
   await validateFileResources(db, workspaceId, resources);
   const variableSet = payload.variableSetId ? await validateVariableSetAttachment(
@@ -4058,7 +4144,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     const rig = await getRig2(db, workspaceId, requestedRigId);
     if (!rig || !rig.activeVersion) {
       if (payload.rigId) {
-        throw new HTTPException9(422, {
+        throw new HTTPException10(422, {
           message: rig ? `rig ${payload.rigId} has no active version to bind` : `unknown rigId: ${payload.rigId}`
         });
       }
@@ -4084,7 +4170,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   if (parentFirstPartyMcpPermissions && payload.firstPartyMcpPermissions?.some(
     (permission) => !hasPermission(parentFirstPartyMcpPermissions, permission)
   )) {
-    throw new HTTPException9(403, {
+    throw new HTTPException10(403, {
       message: "child first-party MCP permissions may only narrow the parent session grant"
     });
   }
@@ -4092,19 +4178,19 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     (permission) => hasPermission(grant.permissions, permission)
   ) : null);
   if (firstPartyMcpPermissions && firstPartyMcpPermissions.length === 0) {
-    throw new HTTPException9(422, {
+    throw new HTTPException10(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 HTTPException9(403, {
+      throw new HTTPException10(403, {
         message: `cannot grant first-party MCP permission beyond the creating grant: ${permission}`
       });
     }
   }
   if (payload.goal && firstPartyMcpPermissions && !firstPartyMcpPermissions.includes("goals:manage")) {
-    throw new HTTPException9(422, {
+    throw new HTTPException10(422, {
       message: "goal-bearing sessions require goals:manage in the resulting first-party MCP permission set"
     });
   }
@@ -4116,7 +4202,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   const rigVersionMatchesGroup = (memberRigVersionId) => memberRigVersionId === frozenRigVersionId;
   if (sandboxChoice === "shared") {
     if (!parentSessionId) {
-      throw new HTTPException9(422, {
+      throw new HTTPException10(422, {
         message: "sandbox:'shared' requires a parent session (spawn from inside a session); use 'new' for a top-level create."
       });
     }
@@ -4139,7 +4225,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     }
     if (variableSetMismatch || rigMismatch) {
       if (payload.sandbox === "shared") {
-        throw new HTTPException9(422, {
+        throw new HTTPException10(422, {
           message: variableSetMismatch ? "sandbox:'shared' requires the same variableSet / same environment as the creator's box (the box variable set/environment is fixed at creation); omit sandbox or pass 'new' when attaching a different variableSet/environment." : "sandbox:'shared' requires the same rig as the creator's box (the box's rig setup is fixed at creation); omit sandbox or pass 'new' when binding a different rig."
         });
       }
@@ -4150,7 +4236,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   } else if (typeof sandboxChoice === "object") {
     const member = await getAnySessionInGroup(db, workspaceId, sandboxChoice.groupId);
     if (!member) {
-      throw new HTTPException9(404, {
+      throw new HTTPException10(404, {
         message: `sandbox group not found in workspace: ${sandboxChoice.groupId}`
       });
     }
@@ -4163,7 +4249,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
       if (!memberVariableSetIds.every(
         (memberVariableSetId) => variableSetMatchesGroup(memberVariableSetId)
       )) {
-        throw new HTTPException9(422, {
+        throw new HTTPException10(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.`
         });
       }
@@ -4175,7 +4261,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
       if (!memberRigVersionIds.every(
         (memberRigVersionId) => rigVersionMatchesGroup(memberRigVersionId)
       )) {
-        throw new HTTPException9(422, {
+        throw new HTTPException10(422, {
           message: `sandbox group ${sandboxChoice.groupId} runs a different rig (the box's rig setup is fixed at creation); create with the group's rig or omit sandbox for an own box.`
         });
       }
@@ -4184,7 +4270,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     inheritedBackend = member.sandboxBackend;
   }
   if (payload.workingDir !== void 0 && !payload.targetSandboxId) {
-    throw new HTTPException9(422, {
+    throw new HTTPException10(422, {
       message: "workingDir requires targetSandboxId (it is the targeted machine's working directory)"
     });
   }
@@ -4272,10 +4358,10 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     });
   } catch (error) {
     if (error instanceof AgentCommandAuthorityError) {
-      throw new HTTPException9(403, { message: error.message });
+      throw new HTTPException10(403, { message: error.message });
     }
     if (error instanceof SessionIdConflictError) {
-      throw new HTTPException9(409, {
+      throw new HTTPException10(409, {
         message: "requested session id is already in use"
       });
     }
@@ -4300,7 +4386,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
 }
 async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, input) {
   if (input.toolsProvided && !deps.settings.sessionTurnToolReplacementEnabled) {
-    throw new HTTPException9(503, {
+    throw new HTTPException10(503, {
       message: "explicit follow-up tool replacement is temporarily unavailable until provenance-aware turn workers finish rolling out; omit tools to inherit the session policy and retry"
     });
   }
@@ -4362,7 +4448,7 @@ async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, inp
     model: effectiveModel
   });
   if (requestedResources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException9(503, { message: "object storage is not configured" });
+    throw new HTTPException10(503, { message: "object storage is not configured" });
   }
   await validateFileResources(db, workspaceId, requestedResources);
   await validateGitHubRepositorySelection(db, workspaceId, [
@@ -4469,7 +4555,7 @@ async function updateSessionMcpApprovalPolicy(deps, grant, sessionId, serverId,
     async (_session, context) => {
       const result = await context.updateSessionMcpApprovalPolicy(serverId, normalizedPolicy);
       if (!result.server) {
-        throw new HTTPException9(404, { message: "session MCP server not found" });
+        throw new HTTPException10(404, { message: "session MCP server not found" });
       }
       outcome.server = result.server;
       return {
@@ -4543,7 +4629,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       (tool) => !validatedIds.has(`${tool.kind}:${tool.id}`)
     );
     if (unknown) {
-      throw new HTTPException9(422, { message: `unknown MCP server id: ${unknown.id}` });
+      throw new HTTPException10(422, { message: `unknown MCP server id: ${unknown.id}` });
     }
     return withFirstPartyTools(validatedTools, runtimeSettings);
   })() : null;
@@ -4565,7 +4651,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
       if (session.parentSessionId) {
         const parent = await context.getLockedSession(session.parentSessionId);
         if (!parent) {
-          throw new HTTPException9(409, { message: "parent session is no longer available" });
+          throw new HTTPException10(409, { message: "parent session is no longer available" });
         }
         const parentTracksWorkspaceDefaults = parent.toolPolicy?.mode === "workspace_default";
         const parentEffective = withFirstPartyTools(
@@ -4578,7 +4664,7 @@ async function updateSessionToolPolicy(deps, grant, sessionId, request) {
         );
         if (requestedMode === "workspace_default") {
           if (!parentTracksWorkspaceDefaults) {
-            throw new HTTPException9(403, {
+            throw new HTTPException10(403, {
               message: "a child may adopt workspace defaults only while its parent tracks workspace defaults"
             });
           }
@@ -4648,13 +4734,13 @@ async function readSessionLineage(deps, grant, sessionId) {
   if (authorization?.relatedSessionAccess === "target") {
     const session = await getSession2(deps.db, grant.workspaceId, sessionId);
     if (!session) {
-      throw new HTTPException9(404, { message: "session not found" });
+      throw new HTTPException10(404, { message: "session not found" });
     }
     return { ancestors: [], children: [], truncated: false };
   }
   const lineage = await getSessionLineage(deps.db, grant.workspaceId, sessionId);
   if (!lineage) {
-    throw new HTTPException9(404, { message: "session not found" });
+    throw new HTTPException10(404, { message: "session not found" });
   }
   return lineage;
 }
@@ -4718,7 +4804,7 @@ async function createValidatedScheduledTask(input) {
 async function requireScheduledTaskRig(db, workspaceId, rigId) {
   const rig = await getRig3(db, workspaceId, rigId);
   if (!rig) {
-    throw new HTTPException10(422, { message: `unknown rigId: ${rigId}` });
+    throw new HTTPException11(422, { message: `unknown rigId: ${rigId}` });
   }
 }
 async function validatedScheduledTaskUpdate(input) {
@@ -4745,7 +4831,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 HTTPException10(409, {
+      throw new HTTPException11(409, {
         message: "cannot change variableSet of a task with a live reusable session; recreate the task"
       });
     }
@@ -4775,7 +4861,7 @@ async function validatedScheduledTaskUpdate(input) {
     if (willHaveVariableSet) {
       requirePermission(input.grant, "variable-sets:use");
     }
-    update.agentConfig = await validateScheduledTaskAgentConfig({
+    const nextAgentConfig = await validateScheduledTaskAgentConfig({
       settings: input.settings,
       db: input.db,
       objectStorage: input.objectStorage,
@@ -4784,13 +4870,19 @@ async function validatedScheduledTaskUpdate(input) {
       payload: { agentConfig: input.payload.agentConfig },
       ...input.toolsProvided !== void 0 ? { toolsProvided: input.toolsProvided } : {}
     });
+    if (input.existing.reusableSessionId && input.existing.runMode === "reusable_session" && (input.existing.agentConfig.slackBotConnectionId ?? null) !== (nextAgentConfig.slackBotConnectionId ?? null)) {
+      throw new HTTPException11(409, {
+        message: "cannot change the OpenGeni Slack bot connection of a task with a live reusable session; recreate the task"
+      });
+    }
+    update.agentConfig = nextAgentConfig;
   }
   return update;
 }
 async function requireScheduledTaskForApi(db, workspaceId, taskId) {
   const task = await getScheduledTask(db, workspaceId, taskId);
   if (!task) {
-    throw new HTTPException10(404, { message: "scheduled task not found" });
+    throw new HTTPException11(404, { message: "scheduled task not found" });
   }
   return task;
 }
@@ -4855,13 +4947,26 @@ async function validateScheduledTaskAgentConfig(input) {
   const tools = input.toolsProvided ?? true ? requestedTools : withDefaultEnabledCapabilityMcpTools(requestedTools, input.settings, runtimeSettings);
   const prompt = input.payload.agentConfig.prompt.trim();
   if (!prompt) {
-    throw new HTTPException10(422, { message: "scheduled task prompt is required" });
+    throw new HTTPException11(422, { message: "scheduled task prompt is required" });
+  }
+  if (hasReservedOpenGeniSlackBotSessionMetadata(input.payload.agentConfig.metadata)) {
+    throw new HTTPException11(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 HTTPException10(503, { message: "object storage is not configured" });
+    throw new HTTPException11(503, { message: "object storage is not configured" });
   }
   await validateFileResources(input.db, input.workspaceId, resources);
+  if (input.payload.agentConfig.slackBotConnectionId) {
+    await validateOpenGeniSlackBotConnectionSelection(
+      input.db,
+      input.grant,
+      input.workspaceId,
+      input.payload.agentConfig.slackBotConnectionId
+    );
+  }
   const requestedMaxDepth = input.payload.agentConfig.maxNestedAgentDepth;
   if (requestedMaxDepth !== void 0) {
     const workspace = await requireWorkspace2(input.db, input.workspaceId);
@@ -4869,7 +4974,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 HTTPException10(403, {
+      throw new HTTPException11(403, {
         message: `scheduled task maxNestedAgentDepth ${requestedMaxDepth} exceeds inherited limit ${inheritedMaxDepth}; workspace:admin is required to increase it`
       });
     }
@@ -4887,19 +4992,19 @@ function validateScheduledTaskSchedule(schedule) {
     return;
   }
   if (new Date(schedule.startAt).getTime() >= new Date(schedule.endAt).getTime()) {
-    throw new HTTPException10(422, { message: "interval schedule endAt must be after startAt" });
+    throw new HTTPException11(422, { message: "interval schedule endAt must be after startAt" });
   }
 }
 function trimmedScheduledTaskName(name) {
   const trimmed = name.trim();
   if (!trimmed) {
-    throw new HTTPException10(422, { message: "scheduled task name is required" });
+    throw new HTTPException11(422, { message: "scheduled task name is required" });
   }
   return trimmed;
 }
 
 // src/domain/workspace-members.ts
-import { HTTPException as HTTPException11 } from "hono/http-exception";
+import { HTTPException as HTTPException12 } 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));
@@ -4909,25 +5014,25 @@ function isUserMember(member) {
 }
 function resolveMemberSubjectId(userId) {
   if (!userId) {
-    throw new HTTPException11(404, { message: "user is not registered" });
+    throw new HTTPException12(404, { message: "user is not registered" });
   }
   return `user:${userId}`;
 }
 function assertWorkspaceMemberRemovable(input) {
   const { members, subjectId, callerSubjectId } = input;
   if (subjectId === callerSubjectId) {
-    throw new HTTPException11(409, { message: "you cannot remove your own membership" });
+    throw new HTTPException12(409, { message: "you cannot remove your own membership" });
   }
   const target = members.find((member) => member.subjectId === subjectId);
   if (!target) {
-    throw new HTTPException11(404, { message: "member not found" });
+    throw new HTTPException12(404, { message: "member not found" });
   }
   if (memberCanAdminister(target)) {
     const remainingAdmins = members.filter(
       (member) => member.subjectId !== subjectId && memberCanAdminister(member)
     );
     if (remainingAdmins.length === 0) {
-      throw new HTTPException11(409, {
+      throw new HTTPException12(409, {
         message: "cannot remove the last member who can manage this workspace"
       });
     }
@@ -4935,10 +5040,10 @@ function assertWorkspaceMemberRemovable(input) {
 }
 function assertWorkspaceDeletable(input) {
   if (input.workspaceCountForAccount <= 1) {
-    throw new HTTPException11(409, { message: "cannot delete the account's only workspace" });
+    throw new HTTPException12(409, { message: "cannot delete the account's only workspace" });
   }
   if (input.activeSessionCount > 0) {
-    throw new HTTPException11(409, {
+    throw new HTTPException12(409, {
       message: "stop the workspace's running sessions before deleting it"
     });
   }
@@ -4962,7 +5067,7 @@ import {
   saveNewSessionDraftInTransaction,
   withWorkspaceSubjectRls as withWorkspaceSubjectRls2
 } from "@opengeni/db";
-import { HTTPException as HTTPException12 } from "hono/http-exception";
+import { HTTPException as HTTPException13 } from "hono/http-exception";
 function hasOwn(value, key) {
   return typeof value === "object" && value !== null && Object.hasOwn(value, key);
 }
@@ -5084,7 +5189,7 @@ async function saveActorNewSessionDraft(deps, grant, workspaceId, rawInput) {
   const tools = toolsProvided ? validateToolRefs(input.tools, runtimeSettings) : [];
   await validateGitHubRepositorySelection(deps.db, workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !deps.objectStorage) {
-    throw new HTTPException12(503, { message: "object storage is not configured" });
+    throw new HTTPException13(503, { message: "object storage is not configured" });
   }
   await validateFileResources(deps.db, workspaceId, resources);
   assertConfiguredModel(deps.settings, input.model);
@@ -5118,7 +5223,7 @@ async function saveActorNewSessionDraft(deps, grant, workspaceId, rawInput) {
     return mapNewSessionDraft(saved);
   } catch (error) {
     if (error instanceof NewSessionDraftAccessError) {
-      throw new HTTPException12(403, { message: error.message });
+      throw new HTTPException13(403, { message: error.message });
     }
     throw error;
   }
@@ -5656,8 +5761,12 @@ export {
   getCapabilityPack,
   getHumanComposerDraft,
   hasPermission,
+  hasReservedOpenGeniSlackBotMetadata,
+  hasReservedOpenGeniSlackBotSessionMetadata,
   isAuthoritativeGitHubRepositorySelectionError,
   isBuiltInCapabilityPack,
+  isOpenGeniSlackBotConnection,
+  isTrustedScheduledSlackBotSession,
   isUserMember,
   listCapabilityPacks,
   listFleet,
@@ -5672,6 +5781,7 @@ export {
   moveHumanQueuePrompt,
   normalizeResources,
   officialMcpRegistryUrl,
+  openGeniSlackBotMetadata,
   postUserMessageTurn,
   promoteSetupAppendChange,
   promoteVerifiedDefinitionEditChangeForApi,
@@ -5688,6 +5798,7 @@ export {
   requireAccessGrant,
   requireEnvironmentEncryption,
   requireLimit,
+  requireOpenGeniSlackBotConnection,
   requirePermission,
   requireQueuedTurnForApi,
   requireRigChangeForApi,
@@ -5706,6 +5817,7 @@ export {
   runOnSandbox,
   saveActorNewSessionDraft,
   saveHumanComposerDraft,
+  scheduledSlackBotConnectionId,
   scheduledTaskTemporalScheduleId,
   scheduledTaskToolsProvided,
   scheduledTaskTriggerToken,
@@ -5731,6 +5843,7 @@ export {
   validateGitHubRepositorySelectionShape,
   validateGitHubRepositorySelectionShapes,
   validateMcpCapabilityConnection,
+  validateOpenGeniSlackBotConnectionSelection,
   validateToolRefs,
   validateToolRefsForSessionPolicy,
   validateVariableSetAttachment,