@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/dist/{http-nc6pydw5.js → http-ecsar8ez.js}

@@ -6,16 +6,60 @@ import {
   ACP_TARGET_IDS
 } from "./cli-dgnj0zcc.js";
 import {
+  SIMILARITY_THRESHOLD,
+  writeSkillsToFilesystem
+} from "./cli-pf9q3696.js";
+import {
+  Anthropic
+} from "./cli-j490egb5.js";
+import {
+  isClaudeBridgeEffective,
+  resolveClaudeTransport
+} from "./cli-eree7rnv.js";
+import {
+  reasoningCapability
+} from "./cli-4yc5d8fk.js";
+import {
+  SCRIPT_SDK_TYPES,
+  SCRIPT_STDLIB_MODULE_TYPES,
+  ensureAgentFsCredentialsForAgent,
+  extractArgsJsonSchema,
+  extractScriptSignature,
+  getScriptAppTypes,
+  inviteEmailToSharedOrg,
+  scriptSdkTypesWithGeneratedApis,
+  scriptStdlibTypesWithGeneratedApis,
+  typecheckScript,
+  typecheckWithAmbient
+} from "./cli-5jd2z7av.js";
+import {
+  checkHeartbeatChecklist,
+  runHeartbeatSweep,
+  stopHeartbeat
+} from "./cli-9004vfdf.js";
+import {
+  AGENT_MAX_TASKS_CONFIG_KEY,
   ALL_CAPABILITIES,
   AssetKeyAuthorizationError,
   BODY_TOO_LARGE,
   DEFAULT_NEGOTIATED_PROTOCOL_VERSION,
   ExplicitSelfDuplicateError,
+  ExtensionConfigError,
+  ExtensionLifecycleError,
   JSONRPCMessageSchema,
+  MAX_TASK_ATTACHMENT_BYTES,
   McpServer,
+  RawLlmConfigSchema,
+  RawLlmOutputSchema,
+  Redacted,
   RoomOperationSchema,
-  SIMILARITY_THRESHOLD,
+  SCRIPT_SDK_RESPONSE_LIMIT_BYTES,
+  SDK_ALLOWLIST,
   SUPPORTED_PROTOCOL_VERSIONS,
+  TaskCreationBlockedError,
+  TriggerSchemaError,
+  WebhookError,
+  activateVersion,
   agentWithCapacity,
   applyRating,
   applyRoomUpdate,
@@ -24,43 +68,61 @@ import {
   assertSelectOnlyQuery,
   authorizeAssetKeyWrite,
   authorizeRoomNamespace,
+  automationIntegrationFixUrl,
+  calculateNextRun,
   canClaim,
   canReadMemory,
   cancelTaskHandler,
   cancelTaskInputSchema,
   cancelTaskOutputSchema,
+  cancelWorkflowRun,
   changeRoom,
   checkOutputSchemaShape,
   clearJiraMetadata,
   closeRooms,
   createEvent,
   createEventsBatch,
+  createResumeFollowUp,
   createServer,
+  createTaskWithSiblingAwareness,
   createToolRegistrar,
+  createWorkerTaskFollowUp,
   decodeRoomSnapshot,
   dedupeMemoryDocumentIds,
+  deleteExtension,
   deleteJiraWebhook,
   deriveApiBaseUrl,
   describeRequestRoute,
+  disableExtension,
+  dispatchScheduleTarget,
   emitBudgetRefusalSideEffects,
+  enableExtension,
   enforceContentLengthCap,
   enqueueAdmissionRow,
   enqueueAuditRow,
+  executeRawLlm,
   executeReadOnlyQuery,
   expandCandidatesWithGraph,
   extractAndVerifyCookie,
+  findUserById,
+  fingerprintApiKey,
   flushAuditBuffer,
+  getAutomationSetupStates,
   getEnabledCapabilities,
   getEventCountsFiltered,
   getEventsFiltered,
+  getExecutorRegistry,
+  getExtensionById,
+  getExtensionByName,
+  getExtensionFiles,
   getJiraMetadata,
   getKapsoConfig,
   getKapsoNumberMapping,
   getLinksForMemory,
   getOAuthPreset,
-  getParseErrorMessage,
   getPathSegments,
   getRoom,
+  getRuntimeInstanceById,
   getTaskDetailsHandler,
   getTaskDetailsInputSchema,
   getTaskDetailsOutputSchema,
@@ -68,6 +130,7 @@ import {
   getTasksInputSchema,
   getTasksOutputSchema,
   getUserCommsPrefs,
+  getUserIdentities,
   guardTerminalTaskResultWrite,
   handleAgentSessionEvent,
   handleAgentSessionPrompted,
@@ -82,12 +145,14 @@ import {
   handleIssueDelete,
   handleIssueUpdate,
   handleJiraWebhook,
+  handleMcpBridge,
   handleMergeRequest,
   handleMessageReceived,
   handleNote,
   handlePipeline,
   handlePullRequest,
   handlePullRequestReview,
+  handleWebhookTrigger,
   handleWorkflowRun,
   hasCapability,
   httpServerSemconvAttributes,
@@ -98,6 +163,8 @@ import {
   initGitLab,
   initJira,
   initLinear,
+  initWorkflows,
+  installExtension,
   isAgentMailEnabled,
   isGitHubEnabled,
   isGitLabEnabled,
@@ -113,43 +180,68 @@ import {
   issuePageSessionCookie,
   json,
   jsonError,
+  linkIdentity,
+  listEnabledAutomationPreflightInputs,
+  listExtensionRuns,
+  listExtensionVersions,
+  listExtensions,
   listOAuthPresetIds,
   listOAuthPresets,
+  listRuntimeInstancesForAgent,
+  listUserEvents,
+  listUserTokens,
+  loadEnabledExtensions,
   loadGlobalConfigsIntoEnv,
   markKapsoMessageRead,
   markKapsoMessageSeen,
-  markScriptSdkRequestOrigin,
   mcpOverflowAuthError,
+  mcpToolNameForSdkMethod,
   mergeScheduleTiming,
-  normalizeObjectSchema,
+  mintSessionToken,
+  mintToken,
   parseBody,
   parseCookieHeader,
   parseQueryParams,
   parseSkillContent,
   patchWorkflowDefinition,
+  preflightAutomation,
+  readScriptSdkJsonResponse,
+  reconcileAgentMaxTasksPolicy,
+  reconcileAgentStatusFromRuntimes,
+  recordIdentityEvent,
   recordMemoryAccesses,
   recordRetrievals,
+  recordTaskAttachmentUpload,
+  recordUnmappedIdentity,
   refreshLinks,
   registerJiraWebhook,
+  reloadExtension,
   reloadGlobalConfigsAndIntegrations,
   removeAwarenessStates,
   removeNamespaceRooms,
+  renderIdentity,
   reservedNamespaceError,
   reservedRoomKeyError,
+  resetAgentMaxTasksMirror,
   resetRoom,
   resolveHttpAuditUserId,
   resolveHttpFavoriteOwner,
   resolveHttpRequestAuth,
+  resolveIdentity,
   resolveRoomNamespace,
   resolveScopedResourceId,
   resolveScriptsOnlyMode,
   resolveTaskAuditUserId,
+  resolveUserByToken,
+  retryFailedRun,
+  revokeSessionToken,
+  revokeToken,
   roomRequestInfo,
   roomTopic,
   roomView,
   route,
   runtimeInstanceHeader,
-  safeParseAsync,
+  runtimeStaleThresholdMinutes,
   safeRequestUrlForLog,
   scheduleIntegrationsReload,
   scopedResourceScopeIdSchema,
@@ -157,135 +249,70 @@ import {
   sendTaskHandler,
   sendTaskOutputSchema,
   setCorsHeaders,
+  setExtensionLoopbackBaseUrl,
+  setRuntimeCredentialReady,
   shouldPersistAutomaticTaskMemory,
+  snapshotAndUpdateWorkflow,
   snapshotMetric,
   snapshotPage,
   startAuditGc,
   startAuditWriter,
+  startWorkflowExecution,
   steerTaskHandler,
   steerTaskOutputSchema,
   steerTaskUserInputSchema,
   stopAuditGc,
   stopAuditWriter,
+  stopExtensionRuntime,
   sweepRooms,
   taskActionHandler,
   taskActionInputSchema,
   taskActionOutputSchema,
   toolErr,
+  touchRuntimeInstance,
   triggerSchemaErrorResponse,
+  unlinkIdentity,
+  updateExtensionMeta,
   updateJiraMetadata,
+  upsertRuntimeInstance,
+  upsertSwarmConfigWithPolicyMirror,
   userCtx,
+  validateJsonSchema,
   validateRecurringTiming,
   verifyAgentMailWebhook,
   verifyGitLabWebhook,
+  verifyHmacSignature,
   verifyWebhookSignature,
   warnIfCorsAllowsAnyOrigin,
-  wireHttpSpanLifecycle,
-  writeSkillsToFilesystem
-} from "./cli-cv7s5zdq.js";
+  wireHttpSpanLifecycle
+} from "./cli-5tpgq60f.js";
 import"./cli-0z2v4nhw.js";
-import {
-  Anthropic
-} from "./cli-j490egb5.js";
-import {
-  isClaudeBridgeEffective,
-  resolveClaudeTransport
-} from "./cli-eree7rnv.js";
 import {
   REFERENCES_SOURCE_MAX_LENGTH,
   sanitizeReferencesSource
-} from "./cli-xvkmedgn.js";
+} from "./cli-4wppfkcm.js";
 import {
-  reasoningCapability
-} from "./cli-4yc5d8fk.js";
+  deriveCodexKeySuffix,
+  getValidCodexOAuth,
+  loadAllCodexOAuthSlots
+} from "./cli-e7d20cty.js";
 import {
-  calculateNextRun,
-  dispatchScheduleTarget
-} from "./cli-7fehefdf.js";
+  isMultiRuntimeEnabled
+} from "./cli-re8z5p8p.js";
+import"./cli-3dpj7atn.js";
 import {
   getModelsCatalog
-} from "./cli-7xx10h0a.js";
-import {
-  normalizeModelKey
-} from "./cli-5m0qmvdp.js";
+} from "./cli-g69fdc9g.js";
 import {
   getUserGrant
-} from "./cli-6skz3rk8.js";
+} from "./cli-7tgcstn2.js";
 import {
   can,
   clearAuditSink,
   decideToolAdmission,
   isRbacEnabled,
   setAuditSink
-} from "./cli-cmp8g3sw.js";
-import {
-  ensureAgentFsCredentialsForAgent,
-  extractArgsJsonSchema,
-  extractScriptSignature,
-  getScriptAppTypes,
-  inviteEmailToSharedOrg,
-  scriptSdkTypesWithGeneratedApis,
-  scriptStdlibTypesWithGeneratedApis,
-  typecheckScript
-} from "./cli-4260r1tg.js";
-import {
-  collectScriptReferences,
-  getApp,
-  listAppRecords
-} from "./cli-hzqmgcm2.js";
-import {
-  require_dist
-} from "./cli-qgm2pfpq.js";
-import {
-  checkHeartbeatChecklist,
-  runHeartbeatSweep,
-  stopHeartbeat
-} from "./cli-01g3x1ca.js";
-import {
-  AGENT_MAX_TASKS_CONFIG_KEY,
-  createResumeFollowUp,
-  createWorkerTaskFollowUp,
-  getRuntimeInstanceById,
-  listRuntimeInstancesForAgent,
-  reconcileAgentMaxTasksPolicy,
-  reconcileAgentStatusFromRuntimes,
-  resetAgentMaxTasksMirror,
-  runtimeStaleThresholdMinutes,
-  setRuntimeCredentialReady,
-  touchRuntimeInstance,
-  upsertRuntimeInstance,
-  upsertSwarmConfigWithPolicyMirror
-} from "./cli-y3pq4v9g.js";
-import {
-  isMultiRuntimeEnabled
-} from "./cli-07jd68a1.js";
-import {
-  RawLlmConfigSchema,
-  RawLlmOutputSchema,
-  TriggerSchemaError,
-  WebhookError,
-  automationIntegrationFixUrl,
-  cancelWorkflowRun,
-  executeRawLlm,
-  getAutomationSetupStates,
-  getExecutorRegistry,
-  handleWebhookTrigger,
-  initWorkflows,
-  listEnabledAutomationPreflightInputs,
-  preflightAutomation,
-  retryFailedRun,
-  snapshotAndUpdateWorkflow,
-  startWorkflowExecution,
-  validateJsonSchema,
-  verifyHmacSignature
-} from "./cli-ddfw1mc4.js";
-import"./cli-1ebpar1q.js";
-import {
-  deriveCodexKeySuffix,
-  getValidCodexOAuth,
-  loadAllCodexOAuthSlots
-} from "./cli-e7d20cty.js";
-import"./cli-3dpj7atn.js";
+} from "./cli-gbfwcd3k.js";
 import {
   ConnectionAuthInputSchema,
   MAX_SCRIPT_WALL_CLOCK_MS,
@@ -298,6 +325,8 @@ import {
   buildSandboxedCommand,
   buildScriptCredentialBindingsWithFailures,
   callMcpServerTool,
+  checkImportAllowlist,
+  collectScriptReferences,
   computeExpiresAt,
   connectionAuthInputFromFlat,
   connectionAuthSummary,
@@ -315,6 +344,7 @@ import {
   findReusableMcpOAuthClient,
   gcMcpOAuthPending,
   generateEdges,
+  getApp,
   getCredentialBindingById,
   getMcpOAuthToken,
   getOAuthBindingTokenStatus,
@@ -330,6 +360,7 @@ import {
   insertMcpOAuthPending,
   invalidateMcpOAuthClient,
   isInvalidClientError,
+  listAppRecords,
   listRelationalCredentialBindings,
   listScriptApisForScript,
   listScriptConnections,
@@ -346,6 +377,7 @@ import {
   refreshMcpToken,
   refreshScriptConnection,
   registerClient,
+  require_dist,
   require_typescript,
   resolveAdvertisedTokenEndpointAuthMethod,
   restoreScratchScriptLastUsedIfUnchanged,
@@ -363,19 +395,8 @@ import {
   upsertScriptByName,
   upsertScriptConnection,
   validateDefinition
-} from "./cli-svbrpf5q.js";
+} from "./cli-sjaae6ff.js";
 import"./cli-epan13p1.js";
-import {
-  searchScripts
-} from "./cli-3z634pqe.js";
-import {
-  CANDIDATE_SET_MULTIPLIER,
-  getEmbeddingProvider,
-  getMemoryStore,
-  init_constants as init_constants2,
-  init_reranker,
-  rerank
-} from "./cli-jezx9b9c.js";
 import {
   detachedProcessGroup,
   forceTerminateProcessGroup,
@@ -386,7 +407,7 @@ import {
 import {
   getApiKey
 } from "./cli-f14fvzag.js";
-import"./cli-zvz62chv.js";
+import"./cli-fad8m16k.js";
 import {
   acquireOAuthRefreshLock,
   buildAuthorizationUrl,
@@ -410,41 +431,15 @@ import {
   updateAuthorizationIdentity,
   updateOAuthAppById,
   upsertAuthorization
-} from "./cli-cd60fv6j.js";
-import"./cli-fad8m16k.js";
-import"./cli-aehm1rbq.js";
-import"./cli-bsakbbkm.js";
-import"./cli-51tf7ac3.js";
-import {
-  MAX_TASK_ATTACHMENT_BYTES,
-  recordTaskAttachmentUpload
-} from "./cli-sdzq01t9.js";
-import {
-  FilesError,
-  getFileStorageProvider,
-  normalizeFilesError
-} from "./cli-jsp14b6c.js";
+} from "./cli-j9xczhaq.js";
 import {
-  findUserById,
-  fingerprintApiKey,
-  getUserIdentities,
-  linkIdentity,
-  listUserEvents,
-  listUserTokens,
-  mintSessionToken,
-  mintToken,
-  recordIdentityEvent,
-  recordUnmappedIdentity,
-  renderIdentity,
-  resolveIdentity,
-  resolveUserByToken,
-  revokeSessionToken,
-  revokeToken,
-  unlinkIdentity
-} from "./cli-j4d4f6hv.js";
+  normalizeModelKey
+} from "./cli-0qb1z6s2.js";
+import"./cli-bsakbbkm.js";
 import {
-  createTaskWithSiblingAwareness
-} from "./cli-ayvy5kde.js";
+  searchScripts
+} from "./cli-q88st9aj.js";
+import"./cli-51tf7ac3.js";
 import {
   ensure,
   getSlackApp,
@@ -460,10 +455,25 @@ import {
   withRemoteContext,
   withSpan,
   withSpanContext
-} from "./cli-3sysyjve.js";
+} from "./cli-r2q6pevn.js";
 import"./cli-q51yprfq.js";
-import"./cli-9d8ntetj.js";
 import"./cli-yatxqynm.js";
+import {
+  CANDIDATE_SET_MULTIPLIER,
+  getEmbeddingProvider,
+  getMemoryStore,
+  init_constants as init_constants2,
+  init_reranker,
+  rerank
+} from "./cli-ppm4975n.js";
+import"./cli-fm4ytsdk.js";
+import"./cli-aehm1rbq.js";
+import"./cli-2658f6at.js";
+import {
+  FilesError,
+  getFileStorageProvider,
+  normalizeFilesError
+} from "./cli-jsp14b6c.js";
 import {
   ActiveSessionSchema,
   AgentAcpStatusSchema,
@@ -501,6 +511,11 @@ import {
   EventNameSchema,
   EventSourceSchema,
   EventStatusSchema,
+  ExtensionInstallBodySchema,
+  ExtensionManifestSchema,
+  ExtensionRunSchema,
+  ExtensionSchema,
+  ExtensionVersionSchema,
   FavoriteItemTypeSchema,
   HeartbeatExpiryError,
   InboxItemStateSchema,
@@ -752,6 +767,7 @@ import {
   incrementPageViewCount,
   initTelemetry,
   init_asset_key_audit,
+  init_bundle_path,
   init_context_key,
   init_credential_broker,
   init_date_utils,
@@ -770,6 +786,7 @@ import {
   installMcpServer,
   installSkill,
   isReservedConfigKey,
+  isSafeBundlePath,
   isSteeringEnabled as isSteeringEnabled2,
   isTerminalTaskStatus,
   listAgentsWithCredStatusByProvider,
@@ -865,12 +882,12 @@ import {
   upsertSwarmConfig,
   validateConfigValue,
   withFavoriteFlags
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
 import {
   IDENTITY_FIELD_BUDGETS,
   IdentityFieldBudgetError,
   init_identity_field_budget
-} from "./cli-08b07b4r.js";
+} from "./cli-ht5rs63n.js";
 import {
   getAllTemplateDefinitions,
   getTemplateDefinition,
@@ -881,7 +898,7 @@ import {
   interpolate,
   isSteeringEnabled,
   resolveTemplate
-} from "./cli-3apbzgyk.js";
+} from "./cli-z61ykvam.js";
 import {
   MAX_PROFILE_FILE_LENGTH,
   getAppUrl,
@@ -889,7 +906,7 @@ import {
   getMcpBaseUrl,
   getPublicMcpBaseUrl,
   init_constants
-} from "./cli-e29gmdmw.js";
+} from "./cli-dv6cdjs2.js";
 import"./cli-c2mk1kgf.js";
 import {
   init_env_flag,
@@ -911,7 +928,7 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-e06a8a7y.js";
+} from "./cli-zkxymas5.js";
 import {
   init_secret_scrubber,
   registerVolatileSecret,
@@ -933,21 +950,21 @@ import {
 } from "./cli-zf8jjwex.js";
 import {
   bedrockProviderModule
-} from "./cli-4xz3pmrq.js";
+} from "./cli-y6x0gqtg.js";
 import"./cli-cg4vnyh4.js";
+import"./cli-txgcknmy.js";
+import"./cli-6map995v.js";
+import"./cli-j8dggbcr.js";
+import"./cli-y2apkfe2.js";
+import"./cli-vapyk8sw.js";
+import"./cli-pdz9qde4.js";
 import {
   setBedrockProviderModule
 } from "./cli-c4eeb5q2.js";
-import"./cli-pdz9qde4.js";
-import"./cli-txgcknmy.js";
-import"./cli-6map995v.js";
+import"./cli-rgvp6r2x.js";
 import"./cli-btbzvq95.js";
 import"./cli-1m2e086m.js";
-import"./cli-j8dggbcr.js";
-import"./cli-rgvp6r2x.js";
 import"./cli-8wrympd7.js";
-import"./cli-y2apkfe2.js";
-import"./cli-vapyk8sw.js";
 import"./cli-bd957dgb.js";
 import"./cli-jyetr64j.js";
 import"./cli-w1d1bgkk.js";
@@ -2108,39 +2125,6 @@ import { createServer as createServer2 } from "node:net";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-// src/scripts-runtime/response-limit.ts
-var SCRIPT_SDK_RESPONSE_LIMIT_BYTES = 64 * 1024 * 1024;
-function responseTooLarge(operation, limitBytes, observedBytes) {
-  return new Error(`Script SDK response for ${operation} exceeded the ${limitBytes}-byte hard limit ` + `(${observedBytes} bytes observed); narrow the query or paginate the request.`);
-}
-async function readScriptSdkJsonResponse(response, operation, limitBytes = SCRIPT_SDK_RESPONSE_LIMIT_BYTES) {
-  const contentLength = Number(response.headers.get("content-length"));
-  if (Number.isFinite(contentLength) && contentLength > limitBytes) {
-    await response.body?.cancel().catch(() => {});
-    throw responseTooLarge(operation, limitBytes, contentLength);
-  }
-  if (!response.body)
-    return {};
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder;
-  const parts = [];
-  let receivedBytes = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    receivedBytes += value.byteLength;
-    if (receivedBytes > limitBytes) {
-      await reader.cancel().catch(() => {});
-      throw responseTooLarge(operation, limitBytes, receivedBytes);
-    }
-    parts.push(decoder.decode(value, { stream: true }));
-  }
-  parts.push(decoder.decode());
-  const text = parts.join("");
-  return text ? JSON.parse(text) : {};
-}
-
 // src/script-workflows/capability-bridge.ts
 var MAX_PENDING_CAPABILITY_CALLS = 64;
 function protocolError(kind, detail) {
@@ -2253,145 +2237,6 @@ function scriptRunMaxAgentTasks() {
   return positiveIntEnv("SCRIPT_RUN_MAX_AGENT_TASKS", DEFAULT_MAX_AGENT_TASKS);
 }
 
-// src/scripts-runtime/sdk-allowlist.ts
-var SDK_TOOL_NAME_MAP = {
-  memory_search: "memory-search",
-  memory_get: "memory-get",
-  memory_edit: "memory-edit",
-  memory_store: "memory-store",
-  memory_rate: "memory_rate",
-  memory_delete: "memory-delete",
-  inject_learning: "inject-learning",
-  task_list: "get-tasks",
-  task_get: "get-task-details",
-  task_storeProgress: "store-progress",
-  task_defer: "defer-task",
-  task_poll: "poll-task",
-  task_send: "send-task",
-  task_cancel: "cancel-task",
-  task_steer: "steer-task",
-  task_action: "task-action",
-  kv_get: "kv-get",
-  kv_getOrNull: "kv-get",
-  kv_set: "kv-set",
-  kv_delete: "kv-delete",
-  kv_del: "kv-delete",
-  kv_incr: "kv-incr",
-  kv_list: "kv-list",
-  room_get: "room-get",
-  room_change: "room-change",
-  room_reset: "room-reset",
-  room_decode: "room-decode",
-  repo_list: "get-repos",
-  repo_update: "update-repo",
-  schedule_list: "list-schedules",
-  schedule_create: "create-schedule",
-  schedule_update: "update-schedule",
-  schedule_patch: "patch-schedule",
-  schedule_delete: "delete-schedule",
-  schedule_runNow: "run-schedule-now",
-  script_search: "script-search",
-  script_run: "script-run",
-  script_upsert: "script-upsert",
-  script_delete: "script-delete",
-  script_queryTypes: "script-query-types",
-  script_launchRun: "launch-script-run",
-  script_getRun: "get-script-run",
-  script_listRuns: "list-script-runs",
-  swarm_get: "get-swarm",
-  agent_info: "my-agent-info",
-  agent_join: "join-swarm",
-  metrics_get: "get-metrics",
-  user_resolve: "resolve-user",
-  user_manage: "manage-user",
-  db_query: "db-query",
-  config_get: "get-config",
-  config_list: "list-config",
-  config_set: "set-config",
-  config_delete: "delete-config",
-  slack_read: "slack-read",
-  slack_listChannels: "slack-list-channels",
-  slack_post: "slack-post",
-  slack_reply: "slack-reply",
-  slack_startThread: "slack-start-thread",
-  slack_createChannel: "slack-create-channel",
-  slack_inviteToChannel: "slack-invite-to-channel",
-  slack_archiveChannel: "slack-archive-channel",
-  slack_uploadFile: "slack-upload-file",
-  slack_downloadFile: "slack-download-file",
-  slack_delete: "slack-delete",
-  slack_update: "slack-update",
-  message_read: "read-messages",
-  message_post: "post-message",
-  profile_update: "update-profile",
-  context_history: "context-history",
-  context_diff: "context-diff",
-  service_list: "list-services",
-  service_register: "register-service",
-  service_unregister: "unregister-service",
-  service_updateStatus: "update-service-status",
-  workflow_list: "list-workflows",
-  workflow_get: "get-workflow",
-  workflow_create: "create-workflow",
-  workflow_update: "update-workflow",
-  workflow_patch: "patch-workflow",
-  workflow_patchNode: "patch-workflow-node",
-  workflow_delete: "delete-workflow",
-  workflow_trigger: "trigger-workflow",
-  workflow_listRuns: "list-workflow-runs",
-  workflow_getRun: "get-workflow-run",
-  workflow_retryRun: "retry-workflow-run",
-  workflow_cancelRun: "cancel-workflow-run",
-  prompt_list: "list-prompt-templates",
-  prompt_get: "get-prompt-template",
-  prompt_set: "set-prompt-template",
-  prompt_delete: "delete-prompt-template",
-  prompt_preview: "preview-prompt-template",
-  tracker_status: "tracker-status",
-  tracker_syncStatus: "tracker-sync-status",
-  tracker_linkTask: "tracker-link-task",
-  tracker_unlink: "tracker-unlink",
-  tracker_mapAgent: "tracker-map-agent",
-  skill_list: "skill-list",
-  skill_get: "skill-get",
-  skill_getFile: "skill-get-file",
-  skill_search: "skill-search",
-  skill_create: "skill-create",
-  skill_update: "skill-update",
-  skill_delete: "skill-delete",
-  skill_install: "skill-install",
-  skill_uninstall: "skill-uninstall",
-  skill_publish: "skill-publish",
-  mcpServer_list: "mcp-server-list",
-  mcpServer_get: "mcp-server-get",
-  mcpServer_create: "mcp-server-create",
-  mcpServer_update: "mcp-server-update",
-  mcpServer_delete: "mcp-server-delete",
-  mcpServer_install: "mcp-server-install",
-  mcpServer_uninstall: "mcp-server-uninstall",
-  app_get: "app-get",
-  app_history: "app-history",
-  app_diff: "app-diff",
-  app_list: "app-list",
-  app_patch: "app-patch",
-  app_query: "app-query",
-  app_rollback: "app-rollback",
-  app_sync: "app-sync",
-  app_upsert: "app-upsert",
-  page_create: "create_page",
-  page_delete: "delete-page",
-  metric_create: "create_metric",
-  request_humanInput: "request-human-input"
-};
-var SDK_ALLOWLIST = Object.keys(SDK_TOOL_NAME_MAP);
-var MCP_TOOL_NAMES = new Set(Object.values(SDK_TOOL_NAME_MAP));
-function isMcpToolAllowedForScripts(mcpToolName) {
-  return MCP_TOOL_NAMES.has(mcpToolName);
-}
-function mcpToolNameForSdkMethod(name) {
-  return SDK_TOOL_NAME_MAP[name] ?? name;
-}
-
 // src/script-workflows/swarm-capabilities.ts
 var WORKFLOW_SWARM_CAPABILITY_ALLOWLIST = [...SDK_ALLOWLIST];
 var WORKFLOW_SWARM_CAPABILITIES = new Set(WORKFLOW_SWARM_CAPABILITY_ALLOWLIST);
@@ -2399,42 +2244,6 @@ function isWorkflowSwarmCapabilityAllowed(method) {
   return WORKFLOW_SWARM_CAPABILITIES.has(method);
 }
 
-// src/scripts-runtime/redacted.ts
-var registry = new WeakMap;
-var proto = {
-  toString() {
-    return "<redacted>";
-  },
-  toJSON() {
-    return "<redacted>";
-  },
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return "<redacted>";
-  }
-};
-function getEntry(self) {
-  const entry = registry.get(self);
-  if (!entry)
-    throw new Error("Redacted value was not in registry");
-  return entry;
-}
-var Redacted = {
-  make(value, meta = { type: "user", isSecret: false }) {
-    const redacted = Object.create(proto);
-    registry.set(redacted, { value, meta });
-    return redacted;
-  },
-  value(self) {
-    return getEntry(self).value;
-  },
-  meta(self) {
-    return getEntry(self).meta;
-  },
-  isSecret(self) {
-    return Redacted.meta(self).isSecret;
-  }
-};
-
 // src/scripts-runtime/stdlib/fetch.ts
 async function runtimeFetch(input, options = {}) {
   const { retries = 3, timeoutMs = 30000, signal, ...init } = options;
@@ -3708,7 +3517,7 @@ var listAgentRuntimeInstances = route({
   path: "/api/agents/{id}/runtime-instances",
   pattern: ["api", "agents", null, "runtime-instances"],
   summary: "List runtime instances serving an agent",
-  description: "Read-only view of the worker processes currently registered for a logical agent. Rows exist only for multi-runtime registrations (MULTI_RUNTIME_ENABLED), so the list is empty in the default configuration. `isLive` combines `status` with `lastSeenAt` freshness against the server's staleness cutoff (`staleThresholdMinutes`); `reportedSlots` is each process's self-reported capacity, distinct from the agent's logical `maxTasks` policy.",
+  description: "Read-only view of the worker processes currently registered for a logical agent. Rows exist only for multi-runtime registrations (MULTI_RUNTIME_ENABLED), so the list is empty when the flag is disabled. `isLive` combines `status` with `lastSeenAt` freshness against the server's staleness cutoff (`staleThresholdMinutes`); `reportedSlots` is each process's self-reported capacity, distinct from the agent's logical `maxTasks` policy.",
   tags: ["Agents"],
   params: exports_external.object({ id: exports_external.string() }),
   responses: {
@@ -5079,6 +4888,7 @@ async function handleApprovalRequests(req, res, pathSegments, queryParams) {
         await createTaskExtended(taskText, {
           agentId: sourceTask.agentId,
           routingReason: sourceTask.agentId ? "continuity" : undefined,
+          routingSource: sourceTask.agentId ? "engine_default" : undefined,
           parentTaskId: updated.sourceTaskId,
           source: "system",
           taskType: "hitl-follow-up",
@@ -5940,7 +5750,8 @@ async function handleConfig(req, res, pathSegments, queryParams) {
     }
     const presence = {};
     for (const key of keys) {
-      presence[key] = process.env[key] !== undefined && process.env[key] !== "";
+      const value = key === "SWARM_ORG_NAME" ? process.env[key]?.trim() : process.env[key];
+      presence[key] = value !== undefined && value !== "";
     }
     envPresence.respond(res, 200, { presence });
     return true;
@@ -6317,94 +6128,1210 @@ var getEventsRoute = route({
       schema: exports_external.object({ events: exports_external.array(SwarmEventSchema) })
     }
   },
-  auth: { apiKey: true }
+  auth: { apiKey: true }
+});
+var getEventCountsRoute = route({
+  method: "get",
+  path: "/api/events/counts",
+  pattern: ["api", "events", "counts"],
+  summary: "Get event counts grouped by event name",
+  tags: ["Events"],
+  query: exports_external.object({
+    category: EventCategorySchema.optional(),
+    source: EventSourceSchema.optional(),
+    agentId: exports_external.string().optional(),
+    taskId: exports_external.string().optional(),
+    sessionId: exports_external.string().optional(),
+    since: exports_external.string().optional(),
+    until: exports_external.string().optional()
+  }),
+  responses: {
+    200: {
+      description: "Event counts",
+      schema: exports_external.object({
+        counts: exports_external.array(exports_external.object({ event: exports_external.string(), count: exports_external.number().int() }))
+      })
+    }
+  },
+  auth: { apiKey: true }
+});
+async function handleEvents(req, res, pathSegments, queryParams, _myAgentId) {
+  if (createEventsBatchRoute.match(req.method, pathSegments)) {
+    const parsed = await createEventsBatchRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    try {
+      const count = await createEventsBatch(parsed.body.events);
+      createEventsBatchRoute.respond(res, 201, { success: true, count });
+    } catch (error) {
+      console.error("[HTTP] Failed to create events batch:", error);
+      jsonError(res, "Failed to store events batch", 500);
+    }
+    return true;
+  }
+  if (getEventCountsRoute.match(req.method, pathSegments)) {
+    const parsed = await getEventCountsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const counts = await getEventCountsFiltered({
+      category: parsed.query.category || undefined,
+      source: parsed.query.source || undefined,
+      agentId: parsed.query.agentId || undefined,
+      taskId: parsed.query.taskId || undefined,
+      sessionId: parsed.query.sessionId || undefined,
+      since: parsed.query.since || undefined,
+      until: parsed.query.until || undefined
+    });
+    getEventCountsRoute.respond(res, 200, { counts });
+    return true;
+  }
+  if (createEventRoute.match(req.method, pathSegments)) {
+    const parsed = await createEventRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    try {
+      const event = await createEvent(parsed.body);
+      createEventRoute.respond(res, 201, { success: true, event });
+    } catch (error) {
+      console.error("[HTTP] Failed to create event:", error);
+      jsonError(res, "Failed to store event", 500);
+    }
+    return true;
+  }
+  if (getEventsRoute.match(req.method, pathSegments)) {
+    const parsed = await getEventsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const events = await getEventsFiltered({
+      category: parsed.query.category || undefined,
+      event: parsed.query.event || undefined,
+      status: parsed.query.status || undefined,
+      source: parsed.query.source || undefined,
+      agentId: parsed.query.agentId || undefined,
+      taskId: parsed.query.taskId || undefined,
+      sessionId: parsed.query.sessionId || undefined,
+      dataField: parsed.query.dataField || undefined,
+      since: parsed.query.since || undefined,
+      until: parsed.query.until || undefined,
+      limit: parsed.query.limit ?? 100
+    });
+    getEventsRoute.respond(res, 200, { events });
+    return true;
+  }
+  return false;
+}
+
+// src/http/extensions.ts
+init_zod();
+init_db();
+
+// src/be/extensions/validate.ts
+init_bundle_path();
+
+// src/extensions/contract-types.generated.ts
+var EXTENSION_TYPE_DEFINITIONS = `// biome-ignore-all lint/suspicious/noConfusingVoidType: Extension handlers may explicitly return no result.
+declare module "swarm-extension" {
+  export type CreateTaskOptions = {
+    key?: string | undefined;
+    agentId?: string | null | undefined;
+    creatorAgentId?: string | undefined;
+    source?:
+      | "workflow"
+      | "schedule"
+      | "slack"
+      | "agentmail"
+      | "mcp"
+      | "api"
+      | "ui"
+      | "github"
+      | "gitlab"
+      | "system"
+      | "linear"
+      | "jira"
+      | undefined;
+    routingReason?:
+      | "skill"
+      | "continuity"
+      | "overflow"
+      | "human_pinned"
+      | "reroute_fault"
+      | undefined;
+    routingSource?: "declared" | "engine_default" | undefined;
+    routingNote?: string | undefined;
+    taskType?: string | undefined;
+    tags?: string[] | undefined;
+    priority?: number | undefined;
+    dependsOn?: string[] | undefined;
+    offeredTo?: string | undefined;
+    status?: "draft" | "backlog" | "unassigned" | undefined;
+    slackChannelId?: string | undefined;
+    slackThreadTs?: string | undefined;
+    slackTriggerMessageTs?: string | undefined;
+    slackUserId?: string | undefined;
+    overrideSlackContext?: boolean | undefined;
+    vcsProvider?: "github" | "gitlab" | undefined;
+    vcsRepo?: string | undefined;
+    vcsEventType?: string | undefined;
+    vcsNumber?: number | undefined;
+    vcsCommentId?: number | undefined;
+    vcsAuthor?: string | undefined;
+    vcsUrl?: string | undefined;
+    vcsInstallationId?: number | undefined;
+    vcsNodeId?: string | undefined;
+    agentmailInboxId?: string | undefined;
+    agentmailMessageId?: string | undefined;
+    agentmailThreadId?: string | undefined;
+    mentionMessageId?: string | undefined;
+    mentionChannelId?: string | undefined;
+    dir?: string | undefined;
+    parentTaskId?: string | undefined;
+    model?: string | undefined;
+    modelTier?: "smol" | "regular" | "smart" | "ultra" | undefined;
+    effort?: "off" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    scheduleId?: string | undefined;
+    workflowRunId?: string | undefined;
+    workflowRunStepId?: string | undefined;
+    sourceTaskId?: string | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    inheritParentOutputSchema?: boolean | undefined;
+    inheritParentRoutingAffinity?: boolean | undefined;
+    followUpConfig?:
+      | {
+          disabled?: boolean | undefined;
+          onCompleted?: string | undefined;
+          onFailed?: string | undefined;
+        }
+      | undefined;
+    requestedByUserId?: string | undefined;
+    contextKey?: string | undefined;
+    bypassTrackerContextDedup?: boolean | undefined;
+    routingAffinity?:
+      | {
+          capabilities: string[];
+          sourceAgentId?: string | undefined;
+          role?: string | undefined;
+          harnessProvider?:
+            | "claude"
+            | "codex"
+            | "pi"
+            | "devin"
+            | "claude-managed"
+            | "opencode"
+            | "acp"
+            | undefined;
+          leadOnly?: boolean | undefined;
+        }
+      | undefined;
+  };
+
+  export type AgentTask = {
+    id: string;
+    key: string;
+    agentId: string | null;
+    task: string;
+    status:
+      | "draft"
+      | "backlog"
+      | "unassigned"
+      | "offered"
+      | "reviewing"
+      | "pending"
+      | "in_progress"
+      | "paused"
+      | "completed"
+      | "failed"
+      | "cancelled"
+      | "superseded";
+    source:
+      | "workflow"
+      | "schedule"
+      | "slack"
+      | "agentmail"
+      | "mcp"
+      | "api"
+      | "ui"
+      | "github"
+      | "gitlab"
+      | "system"
+      | "linear"
+      | "jira";
+    tags: string[];
+    priority: number;
+    dependsOn: string[];
+    createdAt: string;
+    lastUpdatedAt: string;
+    slackReplySent: boolean;
+    wasPaused: boolean;
+    creatorAgentId?: string | undefined;
+    title?: string | undefined;
+    routingReason?:
+      | "skill"
+      | "continuity"
+      | "overflow"
+      | "human_pinned"
+      | "reroute_fault"
+      | undefined;
+    routingSource?: "declared" | "engine_default" | undefined;
+    routingNote?: string | undefined;
+    taskType?: string | undefined;
+    offeredTo?: string | undefined;
+    offeredAt?: string | undefined;
+    acceptedAt?: string | undefined;
+    rejectionReason?: string | undefined;
+    finishedAt?: string | undefined;
+    notifiedAt?: string | undefined;
+    failureReason?: string | undefined;
+    output?: string | undefined;
+    progress?: string | undefined;
+    slackChannelId?: string | undefined;
+    slackThreadTs?: string | undefined;
+    slackTriggerMessageTs?: string | undefined;
+    slackUserId?: string | undefined;
+    slackProgressMessageTs?: string | undefined;
+    slackTreeRootMessageTs?: string | undefined;
+    vcsProvider?: "github" | "gitlab" | undefined;
+    vcsRepo?: string | undefined;
+    vcsEventType?: string | undefined;
+    vcsNumber?: number | undefined;
+    vcsCommentId?: number | undefined;
+    vcsAuthor?: string | undefined;
+    vcsUrl?: string | undefined;
+    vcsInstallationId?: number | undefined;
+    vcsNodeId?: string | undefined;
+    agentmailInboxId?: string | undefined;
+    agentmailMessageId?: string | undefined;
+    agentmailThreadId?: string | undefined;
+    mentionMessageId?: string | undefined;
+    mentionChannelId?: string | undefined;
+    dir?: string | undefined;
+    parentTaskId?: string | undefined;
+    claudeSessionId?: string | undefined;
+    model?: string | undefined;
+    modelTier?: "smol" | "regular" | "smart" | "ultra" | undefined;
+    effort?: "off" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    scheduleId?: string | undefined;
+    workflowRunId?: string | null | undefined;
+    workflowRunStepId?: string | null | undefined;
+    contextKey?: string | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    followUpConfig?:
+      | {
+          disabled?: boolean | undefined;
+          onCompleted?: string | undefined;
+          onFailed?: string | undefined;
+        }
+      | undefined;
+    compactionCount?: number | undefined;
+    peakContextPercent?: number | undefined;
+    peakContextTokens?: number | undefined;
+    contextWindowSize?: number | undefined;
+    credentialKeySuffix?: string | undefined;
+    credentialKeyType?: string | undefined;
+    requestedByUserId?: string | undefined;
+    swarmVersion?: string | undefined;
+    provider?:
+      | "claude"
+      | "codex"
+      | "pi"
+      | "devin"
+      | "claude-managed"
+      | "opencode"
+      | "acp"
+      | undefined;
+    providerMeta?: Record<string, unknown> | undefined;
+    harnessVariant?: string | undefined;
+    harnessVariantMeta?: Record<string, unknown> | undefined;
+    totalCostUsd?: number | undefined;
+    routingAffinity?:
+      | {
+          capabilities: string[];
+          sourceAgentId?: string | undefined;
+          role?: string | undefined;
+          harnessProvider?:
+            | "claude"
+            | "codex"
+            | "pi"
+            | "devin"
+            | "claude-managed"
+            | "opencode"
+            | "acp"
+            | undefined;
+          leadOnly?: boolean | undefined;
+        }
+      | undefined;
+    routingAffinityInvalid?: boolean | undefined;
+  };
+
+  export type ActiveSession = {
+    id: string;
+    agentId: string;
+    taskId: string | null;
+    triggerType: string;
+    inboxMessageId: string | null;
+    taskDescription: string | null;
+    runnerSessionId: string | null;
+    providerSessionId: string | null;
+    startedAt: string;
+    lastHeartbeatAt: string;
+    runtimeInstanceId?: string | null | undefined;
+  };
+
+  export type RequestInfo = {
+    sessionId: string | undefined;
+    agentId: string | undefined;
+    runtimeInstanceId: string | undefined;
+    sourceTaskId: string | undefined;
+    contextKey: string | undefined;
+    callOrigin: "mcp" | "extension" | "script-sdk";
+  };
+
+  import type { SwarmSdk } from "swarm-sdk";
+  import type { z } from "zod";
+  export type Runtime = "api" | "worker";
+  export interface ExtensionManifest {
+    name: string;
+    description: string;
+    version: string;
+    runtime: Runtime;
+    assets: {
+      hooks: string;
+      skills?: string[];
+      workflows?: string[];
+      schedules?: string[];
+    };
+    homepage?: string;
+    author?: string;
+  }
+  export interface HooksModule {
+    default: SwarmExtension;
+    config?: z.ZodTypeAny;
+  }
+  export interface ExtensionState {
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+    incr(key: string, by?: number): Promise<number>;
+    del(key: string): Promise<void>;
+  }
+  export interface ExtensionLogger {
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+  }
+  type ConfigFor<M extends ExtensionManifest> = M extends {
+    config: infer C extends z.ZodTypeAny;
+  }
+    ? z.infer<C>
+    : Record<string, unknown>;
+  export interface ApiCtx<Config = Record<string, unknown>> {
+    swarm: SwarmSdk;
+    state: ExtensionState;
+    config: Config;
+    log: ExtensionLogger;
+    signal: AbortSignal;
+    event: {
+      name: keyof SwarmEventMap;
+      at: string;
+      extension: {
+        id: string;
+        version: number;
+      };
+    };
+  }
+  export interface WorkerCtx<Config = Record<string, unknown>>
+    extends Omit<ApiCtx<Config>, "swarm"> {
+    swarm: SwarmSdk;
+    worker: {
+      agentId: string;
+      taskId: string;
+      harness: string;
+    };
+  }
+  export type CtxFor<M extends ExtensionManifest> = M["runtime"] extends "api"
+    ? ApiCtx<ConfigFor<M>>
+    : WorkerCtx<ConfigFor<M>>;
+  export type PreResult<Modify> =
+    | void
+    | {
+        action: "continue";
+      }
+    | {
+        action: "modify";
+        data: Modify;
+      }
+    | {
+        action: "block";
+        reason: string;
+      };
+  export type TaskCreateOrigin =
+    | "rest"
+    | "app"
+    | "mcp"
+    | "slack"
+    | "schedule"
+    | "workflow"
+    | "webhook"
+    | "followUp"
+    | \`extension:\${string}\`;
+  export interface TaskCreateEvent {
+    options: CreateTaskOptions;
+    description: string;
+    origin: TaskCreateOrigin;
+    requestInfo?: RequestInfo;
+  }
+  export type TaskCreateModify = Partial<
+    Pick<
+      CreateTaskOptions,
+      | "agentId"
+      | "creatorAgentId"
+      | "source"
+      | "taskType"
+      | "tags"
+      | "priority"
+      | "dependsOn"
+      | "offeredTo"
+      | "vcsProvider"
+      | "vcsRepo"
+      | "vcsEventType"
+      | "vcsNumber"
+      | "vcsCommentId"
+      | "vcsAuthor"
+      | "vcsUrl"
+      | "vcsInstallationId"
+      | "vcsNodeId"
+      | "agentmailInboxId"
+      | "agentmailMessageId"
+      | "agentmailThreadId"
+      | "mentionMessageId"
+      | "mentionChannelId"
+      | "dir"
+      | "model"
+      | "modelTier"
+      | "effort"
+      | "outputSchema"
+      | "followUpConfig"
+      | "bypassTrackerContextDedup"
+    >
+  > & {
+    description?: string;
+  };
+  export interface TaskFollowUpEvent {
+    completedTask: AgentTask;
+    status: "completed" | "failed";
+    output?: string;
+    failureReason?: string;
+    workerAgentId: string;
+    leadAgentId: string;
+    summary: string;
+  }
+  export type TaskFollowUpModify = Partial<
+    Pick<CreateTaskOptions, "agentId" | "priority" | "followUpConfig">
+  > & {
+    description?: string;
+  };
+  export interface SlackRouteEvent {
+    channelId: string;
+    userId: string;
+    text: string;
+    threadTs?: string;
+    botMentioned: boolean;
+    threadContext?: {
+      channelId: string;
+      threadTs: string;
+    };
+  }
+  export interface SlackRouteModify {
+    target:
+      | {
+          kind: "agent";
+          agentId: string;
+        }
+      | {
+          kind: "lead";
+        }
+      | {
+          kind: "broadcast";
+        };
+  }
+  export type HeartbeatClassification = "no-session" | "stale-session" | "fresh-stalled";
+  export type HeartbeatAction = "supersede-resume" | "fail" | "record";
+  export interface HeartbeatRemediateEvent {
+    task: AgentTask;
+    session?: ActiveSession;
+    classification: HeartbeatClassification;
+    proposedAction: HeartbeatAction;
+    reason: string;
+    taskAgeMs: number;
+    sessionHeartbeatAgeMs?: number;
+  }
+  export interface HeartbeatRemediateModify {
+    proposedAction: HeartbeatAction;
+  }
+  export interface ToolCallEvent {
+    tool: string;
+    args: unknown;
+    requestInfo: RequestInfo;
+  }
+  export interface ToolCallModify {
+    args: unknown;
+  }
+  export interface TaskEvent {
+    task: AgentTask;
+  }
+  export interface TaskCompletedEvent extends TaskEvent {
+    output: string;
+  }
+  export interface TaskFailedEvent extends TaskEvent {
+    failureReason: string;
+  }
+  export interface TaskSupersededEvent extends TaskEvent {
+    supersededBy: string;
+  }
+  export interface TaskProgressEvent extends TaskEvent {
+    progress: string;
+  }
+  export interface SlackMessageEvent {
+    channelId: string;
+    userId: string;
+    text: string;
+    threadTs?: string;
+    taskId?: string;
+  }
+  export interface ToolCallCompletedEvent extends ToolCallEvent {
+    result: unknown;
+    durationMs: number;
+  }
+  export interface SwarmEventMap {
+    "pre.task.create": {
+      event: TaskCreateEvent;
+      modify: TaskCreateModify;
+      result: PreResult<TaskCreateModify>;
+    };
+    "pre.task.followUp": {
+      event: TaskFollowUpEvent;
+      modify: TaskFollowUpModify;
+      result: PreResult<TaskFollowUpModify>;
+    };
+    "pre.slack.route": {
+      event: SlackRouteEvent;
+      modify: SlackRouteModify;
+      result: PreResult<SlackRouteModify>;
+    };
+    "pre.heartbeat.remediate": {
+      event: HeartbeatRemediateEvent;
+      modify: HeartbeatRemediateModify;
+      result: PreResult<HeartbeatRemediateModify>;
+    };
+    "pre.tool.call": {
+      event: ToolCallEvent;
+      modify: ToolCallModify;
+      result: PreResult<ToolCallModify>;
+    };
+    "post.task.created": {
+      event: TaskEvent;
+      modify: never;
+      result: void;
+    };
+    "post.task.completed": {
+      event: TaskCompletedEvent;
+      modify: never;
+      result: void;
+    };
+    "post.task.failed": {
+      event: TaskFailedEvent;
+      modify: never;
+      result: void;
+    };
+    "post.task.cancelled": {
+      event: TaskEvent;
+      modify: never;
+      result: void;
+    };
+    "post.task.superseded": {
+      event: TaskSupersededEvent;
+      modify: never;
+      result: void;
+    };
+    "post.task.progress": {
+      event: TaskProgressEvent;
+      modify: never;
+      result: void;
+    };
+    "post.slack.message": {
+      event: SlackMessageEvent;
+      modify: never;
+      result: void;
+    };
+    "post.tool.call": {
+      event: ToolCallCompletedEvent;
+      modify: never;
+      result: void;
+    };
+  }
+  export interface ExtensionApi<
+    M extends ExtensionManifest = ExtensionManifest & {
+      runtime: "api";
+    },
+  > {
+    on<E extends keyof SwarmEventMap>(
+      event: E,
+      handler: (
+        event: SwarmEventMap[E]["event"],
+        ctx: CtxFor<M>,
+      ) => Promise<SwarmEventMap[E]["result"]> | SwarmEventMap[E]["result"],
+      opts?: {
+        priority?: number;
+      },
+    ): void;
+  }
+  export type SwarmExtension<
+    M extends ExtensionManifest = ExtensionManifest & {
+      runtime: "api";
+    },
+  > = (api: ExtensionApi<M>) => void;
+  export { block, modify } from "./contract-runtime";
+}
+`;
+
+// src/be/extensions/validate.ts
+init_types();
+async function validateBundle(input) {
+  const parsedManifest = ExtensionManifestSchema.safeParse(input.manifest);
+  const pathDiagnostics = Object.keys(input.files).filter((path) => !isSafeBundlePath(path)).map((path) => `Unsafe bundle file path: ${JSON.stringify(path)}`);
+  if (!parsedManifest.success) {
+    return {
+      ok: false,
+      diagnostics: [
+        ...pathDiagnostics,
+        ...parsedManifest.error.issues.map((issue) => `${issue.path.join(".") || "manifest"}: ${issue.message}`)
+      ]
+    };
+  }
+  if (pathDiagnostics.length > 0)
+    return { ok: false, diagnostics: pathDiagnostics };
+  const manifest = parsedManifest.data;
+  if (manifest.runtime === "worker") {
+    return { ok: false, diagnostics: ['runtime "worker" is not supported in v1'] };
+  }
+  for (const asset of ["skills", "workflows", "schedules"]) {
+    if ((manifest.assets[asset]?.length ?? 0) > 0) {
+      return { ok: false, diagnostics: [`assets.${asset} is not supported in v1`] };
+    }
+  }
+  const hookPath = manifest.assets.hooks;
+  if (!(hookPath in input.files)) {
+    return {
+      ok: false,
+      diagnostics: [`assets.hooks "${hookPath}" does not name a file in files`]
+    };
+  }
+  const extraPaths = Object.keys(input.files).filter((path) => path !== hookPath);
+  if (extraPaths.length > 0) {
+    return {
+      ok: false,
+      diagnostics: [
+        `Only the hooks asset is supported in v1. Unexpected files: ${extraPaths.join(", ")}`
+      ]
+    };
+  }
+  const source = input.files[hookPath];
+  const imports = checkImportAllowlist(source, {
+    allowedBare: ["swarm-extension", "zod", "stdlib"],
+    allowRelative: false,
+    strictDynamic: true
+  });
+  if (!imports.ok)
+    return { ok: false, diagnostics: [imports.diagnostic] };
+  const typecheck = await typecheckWithAmbient({
+    source,
+    modules: {
+      "swarm-extension": EXTENSION_TYPE_DEFINITIONS,
+      "swarm-sdk": SCRIPT_SDK_TYPES,
+      stdlib: SCRIPT_STDLIB_MODULE_TYPES
+    },
+    checkFile: `/// <reference path="./runtime-globals.d.ts" />
+import * as hooks from "./user-script";
+import type { SwarmExtension } from "swarm-extension";
+import type { ZodTypeAny } from "zod";
+const manifest = ${JSON.stringify(manifest)} as const;
+type Manifest = typeof hooks extends { config: infer Config extends ZodTypeAny }
+  ? typeof manifest & { config: Config }
+  : typeof manifest;
+const _extension: SwarmExtension<Manifest> = hooks.default;
+type ConfigIsValid = typeof hooks extends { config: infer Config }
+  ? Config extends ZodTypeAny ? true : false
+  : true;
+const _configIsValid: ConfigIsValid = true;
+void _extension;
+void _configIsValid;
+`
+  });
+  if (!typecheck.ok) {
+    return {
+      ok: false,
+      diagnostics: typecheck.structured.map((diagnostic) => `${diagnostic.file}:${diagnostic.line}:${diagnostic.column} TS${diagnostic.code}: ${diagnostic.message}`)
+    };
+  }
+  return { ok: true, manifest };
+}
+
+// src/http/extensions.ts
+init_types();
+init_request_auth_context();
+init_secret_scrubber();
+var idParamsSchema = exports_external.object({ id: exports_external.string().min(1) });
+var installRoute = route({
+  method: "post",
+  path: "/api/extensions/install",
+  pattern: ["api", "extensions", "install"],
+  operationId: "extensions_install",
+  summary: "Validate and install an extension bundle",
+  tags: ["Extensions"],
+  body: ExtensionInstallBodySchema,
+  responses: {
+    200: {
+      description: "Installed extension",
+      schema: exports_external.object({
+        extension: ExtensionSchema,
+        manifest: ExtensionManifestSchema,
+        contentDeduped: exports_external.boolean()
+      })
+    },
+    400: { description: "Bundle validation failed" },
+    403: { description: "Permission denied" }
+  },
+  rbac: { permission: "extension.write" }
+});
+var listRoute2 = route({
+  method: "get",
+  path: "/api/extensions",
+  pattern: ["api", "extensions"],
+  operationId: "extensions_list",
+  summary: "List installed extensions",
+  tags: ["Extensions"],
+  responses: {
+    200: {
+      description: "Installed extensions",
+      schema: exports_external.object({ extensions: exports_external.array(ExtensionSchema) })
+    }
+  }
+});
+var typeDefsRoute = route({
+  method: "get",
+  path: "/api/extensions/type-defs",
+  pattern: ["api", "extensions", "type-defs"],
+  operationId: "extensions_type_defs",
+  summary: "Get extension authoring type definitions",
+  tags: ["Extensions"],
+  responses: {
+    200: {
+      description: "Generated swarm-extension.d.ts",
+      unstructured: "Plain TypeScript declaration text"
+    }
+  }
+});
+var getRoute = route({
+  method: "get",
+  path: "/api/extensions/{id}",
+  pattern: ["api", "extensions", null],
+  operationId: "extensions_get",
+  summary: "Get an extension bundle",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  responses: {
+    200: {
+      description: "Extension bundle",
+      schema: exports_external.object({
+        extension: ExtensionSchema,
+        manifest: ExtensionManifestSchema,
+        files: exports_external.record(exports_external.string(), exports_external.string())
+      })
+    },
+    404: { description: "Extension not found" }
+  }
+});
+var versionsRoute = route({
+  method: "get",
+  path: "/api/extensions/{id}/versions",
+  pattern: ["api", "extensions", null, "versions"],
+  operationId: "extensions_versions",
+  summary: "List extension versions",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  responses: {
+    200: {
+      description: "Extension versions",
+      schema: exports_external.object({ versions: exports_external.array(ExtensionVersionSchema) })
+    },
+    404: { description: "Extension not found" }
+  }
+});
+var runsRoute = route({
+  method: "get",
+  path: "/api/extensions/{id}/runs",
+  pattern: ["api", "extensions", null, "runs"],
+  operationId: "extensions_runs",
+  summary: "List extension run log entries",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  query: exports_external.object({ limit: exports_external.coerce.number().int().min(1).max(500).optional() }),
+  responses: {
+    200: {
+      description: "Extension run log",
+      schema: exports_external.object({ runs: exports_external.array(ExtensionRunSchema) })
+    },
+    404: { description: "Extension not found" }
+  }
+});
+var patchRoute = route({
+  method: "patch",
+  path: "/api/extensions/{id}",
+  pattern: ["api", "extensions", null],
+  operationId: "extensions_update",
+  summary: "Update extension priority, config, or description",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  body: exports_external.object({
+    priority: exports_external.number().int().optional(),
+    config: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+    description: exports_external.string().optional()
+  }).strict(),
+  responses: {
+    200: { description: "Updated extension", schema: exports_external.object({ extension: ExtensionSchema }) },
+    400: { description: "Extension config validation failed" },
+    403: { description: "Permission denied" },
+    404: { description: "Extension not found" }
+  },
+  rbac: { permission: "extension.write" }
+});
+var deleteRoute = route({
+  method: "delete",
+  path: "/api/extensions/{id}",
+  pattern: ["api", "extensions", null],
+  operationId: "extensions_delete",
+  summary: "Uninstall a disabled extension",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  responses: {
+    200: {
+      description: "Extension uninstalled",
+      schema: exports_external.object({ deleted: exports_external.literal(true) })
+    },
+    403: { description: "Permission denied" },
+    404: { description: "Extension not found" },
+    409: { description: "Enabled extensions cannot be uninstalled" }
+  },
+  rbac: { permission: "extension.write" }
+});
+var enableRoute = route({
+  method: "post",
+  path: "/api/extensions/{id}/enable",
+  pattern: ["api", "extensions", null, "enable"],
+  operationId: "extensions_enable",
+  summary: "Enable an extension",
+  description: "Loads and enables an extension. This route is operator-only.",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  responses: {
+    200: { description: "Enabled extension", schema: exports_external.object({ extension: ExtensionSchema }) },
+    400: { description: "Extension load or config validation failed" },
+    403: { description: "Permission denied" },
+    404: { description: "Extension not found" }
+  },
+  rbac: { permission: "extension.activate" }
+});
+var disableRoute = route({
+  method: "post",
+  path: "/api/extensions/{id}/disable",
+  pattern: ["api", "extensions", null, "disable"],
+  operationId: "extensions_disable",
+  summary: "Disable an extension",
+  description: "Unloads and disables an extension. This route is operator-only.",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  responses: {
+    200: { description: "Disabled extension", schema: exports_external.object({ extension: ExtensionSchema }) },
+    403: { description: "Permission denied" },
+    404: { description: "Extension not found" }
+  },
+  rbac: { permission: "extension.activate" }
 });
-var getEventCountsRoute = route({
-  method: "get",
-  path: "/api/events/counts",
-  pattern: ["api", "events", "counts"],
-  summary: "Get event counts grouped by event name",
-  tags: ["Events"],
-  query: exports_external.object({
-    category: EventCategorySchema.optional(),
-    source: EventSourceSchema.optional(),
-    agentId: exports_external.string().optional(),
-    taskId: exports_external.string().optional(),
-    sessionId: exports_external.string().optional(),
-    since: exports_external.string().optional(),
-    until: exports_external.string().optional()
-  }),
+var activateVersionRoute = route({
+  method: "post",
+  path: "/api/extensions/{id}/activate-version",
+  pattern: ["api", "extensions", null, "activate-version"],
+  operationId: "extensions_activate_version",
+  summary: "Activate an extension version",
+  description: "Activates a stored version. This route is operator-only.",
+  tags: ["Extensions"],
+  params: idParamsSchema,
+  body: exports_external.object({ version: exports_external.number().int().min(1) }).strict(),
   responses: {
-    200: {
-      description: "Event counts",
-      schema: exports_external.object({
-        counts: exports_external.array(exports_external.object({ event: exports_external.string(), count: exports_external.number().int() }))
-      })
-    }
+    200: { description: "Activated extension", schema: exports_external.object({ extension: ExtensionSchema }) },
+    400: { description: "Extension load or config validation failed" },
+    403: { description: "Permission denied" },
+    404: { description: "Extension or version not found" }
   },
-  auth: { apiKey: true }
+  rbac: { permission: "extension.activate" }
 });
-async function handleEvents(req, res, pathSegments, queryParams, _myAgentId) {
-  if (createEventsBatchRoute.match(req.method, pathSegments)) {
-    const parsed = await createEventsBatchRoute.parse(req, res, pathSegments, queryParams);
+function redactExtension(extension) {
+  return { ...extension, configJson: scrubSecrets(extension.configJson) };
+}
+var REDACTED_CONFIG_VALUE = /^\[REDACTED:[A-Za-z0-9_.:-]+\]$/;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function restoreRedacted(incoming, stored) {
+  if (typeof incoming === "string") {
+    return REDACTED_CONFIG_VALUE.test(incoming) && stored !== undefined ? stored : incoming;
+  }
+  if (Array.isArray(incoming)) {
+    const storedArray = Array.isArray(stored) ? stored : [];
+    return incoming.map((item, index) => restoreRedacted(item, storedArray[index]));
+  }
+  if (isPlainObject(incoming)) {
+    const storedObject = isPlainObject(stored) ? stored : {};
+    return Object.fromEntries(Object.entries(incoming).map(([key, value]) => [
+      key,
+      restoreRedacted(value, storedObject[key])
+    ]));
+  }
+  return incoming;
+}
+function preserveRedactedConfigValues(incoming, storedJson) {
+  let parsed;
+  try {
+    parsed = JSON.parse(storedJson);
+  } catch {
+    parsed = {};
+  }
+  return restoreRedacted(incoming, parsed);
+}
+async function extensionPrincipal(req, callerAgentId) {
+  if (callerAgentId) {
+    const agent = await getAgentById(callerAgentId);
+    return { kind: "agent", agentId: callerAgentId, isLead: agent?.isLead ?? false };
+  }
+  const auth = getRequestAuth(req);
+  if (auth?.kind === "operator")
+    return { kind: "operator" };
+  if (auth?.kind === "user")
+    return { kind: "user", userId: auth.userId };
+  return { kind: "agent", agentId: "", isLead: false };
+}
+async function requirePermission(req, res, callerAgentId, verb) {
+  const principal = await extensionPrincipal(req, callerAgentId);
+  const decision = can({ principal, verb, resource: { kind: "none" }, source: "http" });
+  if (decision.allow)
+    return principal;
+  jsonError(res, `Forbidden: ${decision.reason}`, 403);
+  return null;
+}
+function respondLifecycleError(res, error) {
+  const status = error instanceof ExtensionConfigError ? 400 : error instanceof ExtensionLifecycleError ? error.status : 500;
+  jsonError(res, scrubSecrets(error instanceof Error ? error.message : String(error)), status);
+}
+async function handleExtensions(req, res, pathSegments, queryParams, agentId) {
+  if (installRoute.match(req.method, pathSegments)) {
+    const parsed = await installRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
-    try {
-      const count = await createEventsBatch(parsed.body.events);
-      createEventsBatchRoute.respond(res, 201, { success: true, count });
-    } catch (error) {
-      console.error("[HTTP] Failed to create events batch:", error);
-      jsonError(res, "Failed to store events batch", 500);
+    const principal = await requirePermission(req, res, agentId, "extension.write");
+    if (!principal)
+      return true;
+    const validation = await validateBundle(parsed.body);
+    if (!validation.ok) {
+      json(res, { error: "extension_validation_failed", diagnostics: validation.diagnostics }, 400);
+      return true;
+    }
+    const existing = await getExtensionByName(validation.manifest.name);
+    const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
+    const updatedBy = await resolveHttpAuditUserId(req, writerAgentId);
+    const shouldActivate = principal.kind !== "agent" && existing?.enabled === true;
+    const result = await installExtension({
+      manifest: validation.manifest,
+      files: parsed.body.files,
+      priority: parsed.body.priority,
+      config: parsed.body.config,
+      agentId: writerAgentId,
+      createdBy: updatedBy,
+      activate: shouldActivate
+    });
+    let extension = result.extension;
+    if (shouldActivate) {
+      try {
+        extension = await reloadExtension(extension.id, { by: updatedBy });
+      } catch (error) {
+        respondLifecycleError(res, error);
+        return true;
+      }
     }
+    installRoute.respond(res, 200, {
+      extension: redactExtension(extension),
+      manifest: validation.manifest,
+      contentDeduped: result.contentDeduped
+    });
     return true;
   }
-  if (getEventCountsRoute.match(req.method, pathSegments)) {
-    const parsed = await getEventCountsRoute.parse(req, res, pathSegments, queryParams);
+  if (listRoute2.match(req.method, pathSegments)) {
+    const parsed = await listRoute2.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
-    const counts = await getEventCountsFiltered({
-      category: parsed.query.category || undefined,
-      source: parsed.query.source || undefined,
-      agentId: parsed.query.agentId || undefined,
-      taskId: parsed.query.taskId || undefined,
-      sessionId: parsed.query.sessionId || undefined,
-      since: parsed.query.since || undefined,
-      until: parsed.query.until || undefined
+    listRoute2.respond(res, 200, { extensions: (await listExtensions()).map(redactExtension) });
+    return true;
+  }
+  if (typeDefsRoute.match(req.method, pathSegments)) {
+    const parsed = await typeDefsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+    res.end(EXTENSION_TYPE_DEFINITIONS);
+    return true;
+  }
+  if (versionsRoute.match(req.method, pathSegments)) {
+    const parsed = await versionsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await getExtensionById(parsed.params.id)) {
+      jsonError(res, "Extension not found", 404);
+      return true;
+    }
+    versionsRoute.respond(res, 200, {
+      versions: await listExtensionVersions(parsed.params.id)
     });
-    getEventCountsRoute.respond(res, 200, { counts });
     return true;
   }
-  if (createEventRoute.match(req.method, pathSegments)) {
-    const parsed = await createEventRoute.parse(req, res, pathSegments, queryParams);
+  if (runsRoute.match(req.method, pathSegments)) {
+    const parsed = await runsRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await getExtensionById(parsed.params.id)) {
+      jsonError(res, "Extension not found", 404);
+      return true;
+    }
+    runsRoute.respond(res, 200, {
+      runs: await listExtensionRuns(parsed.params.id, parsed.query.limit)
+    });
+    return true;
+  }
+  if (getRoute.match(req.method, pathSegments)) {
+    const parsed = await getRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const extension = await getExtensionById(parsed.params.id);
+    if (!extension) {
+      jsonError(res, "Extension not found", 404);
+      return true;
+    }
+    getRoute.respond(res, 200, {
+      extension: redactExtension(extension),
+      manifest: ExtensionManifestSchema.parse(JSON.parse(extension.manifestJson)),
+      files: await getExtensionFiles(extension.id)
+    });
+    return true;
+  }
+  if (patchRoute.match(req.method, pathSegments)) {
+    const parsed = await patchRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const principal = await requirePermission(req, res, agentId, "extension.write");
+    if (!principal)
+      return true;
+    const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
+    const stored = parsed.body.config ? await getExtensionById(parsed.params.id) : null;
+    const config = parsed.body.config && stored ? preserveRedactedConfigValues(parsed.body.config, stored.configJson) : parsed.body.config;
+    let extension = await updateExtensionMeta(parsed.params.id, {
+      ...parsed.body,
+      ...config === undefined ? {} : { config },
+      updatedBy: await resolveHttpAuditUserId(req, writerAgentId)
+    });
+    if (!extension) {
+      jsonError(res, "Extension not found", 404);
+      return true;
+    }
+    if (extension.enabled) {
+      try {
+        extension = await reloadExtension(extension.id);
+      } catch (error) {
+        respondLifecycleError(res, error);
+        return true;
+      }
+    }
+    patchRoute.respond(res, 200, { extension: redactExtension(extension) });
+    return true;
+  }
+  if (deleteRoute.match(req.method, pathSegments)) {
+    const parsed = await deleteRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const principal = await requirePermission(req, res, agentId, "extension.write");
+    if (!principal)
+      return true;
+    const extension = await getExtensionById(parsed.params.id);
+    if (!extension) {
+      jsonError(res, "Extension not found", 404);
+      return true;
+    }
+    if (extension.enabled) {
+      jsonError(res, "Disable the extension before uninstalling it", 409);
+      return true;
+    }
+    await deleteExtension(extension.id);
+    deleteRoute.respond(res, 200, { deleted: true });
+    return true;
+  }
+  if (enableRoute.match(req.method, pathSegments)) {
+    const parsed = await enableRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
+    const principal = await requirePermission(req, res, agentId, "extension.activate");
+    if (!principal)
+      return true;
+    const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
     try {
-      const event = await createEvent(parsed.body);
-      createEventRoute.respond(res, 201, { success: true, event });
+      const extension = await enableExtension(parsed.params.id, {
+        by: await resolveHttpAuditUserId(req, writerAgentId)
+      });
+      enableRoute.respond(res, 200, { extension: redactExtension(extension) });
     } catch (error) {
-      console.error("[HTTP] Failed to create event:", error);
-      jsonError(res, "Failed to store event", 500);
+      respondLifecycleError(res, error);
     }
     return true;
   }
-  if (getEventsRoute.match(req.method, pathSegments)) {
-    const parsed = await getEventsRoute.parse(req, res, pathSegments, queryParams);
+  if (disableRoute.match(req.method, pathSegments)) {
+    const parsed = await disableRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
-    const events = await getEventsFiltered({
-      category: parsed.query.category || undefined,
-      event: parsed.query.event || undefined,
-      status: parsed.query.status || undefined,
-      source: parsed.query.source || undefined,
-      agentId: parsed.query.agentId || undefined,
-      taskId: parsed.query.taskId || undefined,
-      sessionId: parsed.query.sessionId || undefined,
-      dataField: parsed.query.dataField || undefined,
-      since: parsed.query.since || undefined,
-      until: parsed.query.until || undefined,
-      limit: parsed.query.limit ?? 100
-    });
-    getEventsRoute.respond(res, 200, { events });
+    const principal = await requirePermission(req, res, agentId, "extension.activate");
+    if (!principal)
+      return true;
+    const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
+    try {
+      const extension = await disableExtension(parsed.params.id, {
+        by: await resolveHttpAuditUserId(req, writerAgentId)
+      });
+      disableRoute.respond(res, 200, { extension: redactExtension(extension) });
+    } catch (error) {
+      respondLifecycleError(res, error);
+    }
+    return true;
+  }
+  if (activateVersionRoute.match(req.method, pathSegments)) {
+    const parsed = await activateVersionRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const principal = await requirePermission(req, res, agentId, "extension.activate");
+    if (!principal)
+      return true;
+    const writerAgentId = principal.kind === "agent" ? principal.agentId : undefined;
+    try {
+      const extension = await activateVersion(parsed.params.id, parsed.body.version, {
+        by: await resolveHttpAuditUserId(req, writerAgentId)
+      });
+      activateVersionRoute.respond(res, 200, { extension: redactExtension(extension) });
+    } catch (error) {
+      respondLifecycleError(res, error);
+    }
     return true;
   }
   return false;
@@ -7099,7 +8026,8 @@ var upsertState = route({
     itemType: InboxItemTypeSchema,
     itemId: exports_external.string().min(1),
     status: InboxItemStatusSchema,
-    snoozeUntil: exports_external.string().datetime().optional()
+    snoozeUntil: exports_external.string().datetime().optional(),
+    readAt: exports_external.string().datetime().optional()
   }),
   responses: {
     200: {
@@ -7134,7 +8062,8 @@ async function handleInboxState(req, res, pathSegments, queryParams) {
         itemType: parsed.body.itemType,
         itemId: parsed.body.itemId,
         status: parsed.body.status,
-        snoozeUntil: parsed.body.snoozeUntil
+        snoozeUntil: parsed.body.snoozeUntil,
+        readAt: parsed.body.readAt
       });
       upsertState.respond(res, 200, { item });
     } catch (err) {
@@ -9132,7 +10061,7 @@ async function handleMcp(req, res, transports, sessionActivity = {}, sessionAgen
       };
       const configs = await getResolvedConfig(agentId);
       const configValue = configs.find((config) => config.key === "SCRIPTS_ONLY_MCP")?.value;
-      const preloadEnabled = parseEnvFlag(configs.find((config) => config.key === "TASK_TOOL_PRELOAD_ENABLED")?.value ?? process.env.TASK_TOOL_PRELOAD_ENABLED, false);
+      const preloadEnabled = parseEnvFlag(configs.find((config) => config.key === "TASK_TOOL_PRELOAD_ENABLED")?.value ?? process.env.TASK_TOOL_PRELOAD_ENABLED, true);
       let preloadedTools = [];
       if (preloadEnabled) {
         const taskId = headerValue(req.headers["x-source-task-id"]);
@@ -9182,104 +10111,6 @@ async function handleMcp(req, res, transports, sessionActivity = {}, sessionAgen
   return true;
 }
 
-// src/http/mcp-bridge.ts
-init_zod();
-var _bridgeServer = null;
-async function getBridgeServer() {
-  if (!_bridgeServer) {
-    _bridgeServer = await createServer({ scriptsOnly: false, fullSurface: true });
-  }
-  return _bridgeServer;
-}
-var mcpBridgeRoute = route({
-  method: "post",
-  path: "/api/mcp-bridge",
-  pattern: ["api", "mcp-bridge"],
-  summary: "Generic MCP tool proxy for the scripts SDK bridge",
-  tags: ["Scripts"],
-  headers: runtimeInstanceHeader("acquire work through bridged tools"),
-  body: exports_external.object({
-    tool: exports_external.string().min(1).max(200),
-    args: exports_external.record(exports_external.string(), exports_external.unknown()).default({})
-  }),
-  responses: {
-    200: {
-      description: "Tool result",
-      unstructured: "Generic MCP tool proxy — response shape is whatever the invoked tool's structuredContent/content returns, which varies per tool"
-    },
-    400: { description: "Invalid tool name or args" },
-    403: { description: "Tool not in SDK allowlist" },
-    404: { description: "Tool not found" }
-  }
-});
-async function handleMcpBridge(req, res, pathSegments, _queryParams, myAgentId) {
-  if (!mcpBridgeRoute.match(req.method, pathSegments))
-    return false;
-  const parsed = await mcpBridgeRoute.parse(req, res, pathSegments, new URLSearchParams);
-  if (!parsed)
-    return true;
-  const { tool: toolName, args } = parsed.body;
-  if (!isMcpToolAllowedForScripts(toolName)) {
-    jsonError(res, `Tool '${toolName}' is not in the SDK allowlist`, 403);
-    return true;
-  }
-  const server = await getBridgeServer();
-  const tools = server._registeredTools;
-  const tool = tools[toolName];
-  if (!tool) {
-    jsonError(res, `Tool '${toolName}' not found in the MCP registry`, 404);
-    return true;
-  }
-  if (tool.enabled === false) {
-    jsonError(res, `Tool '${toolName}' is disabled`, 400);
-    return true;
-  }
-  const sourceTaskId = Array.isArray(req.headers["x-source-task-id"]) ? req.headers["x-source-task-id"][0] : req.headers["x-source-task-id"];
-  const runtimeInstanceId = Array.isArray(req.headers["x-runtime-instance-id"]) ? req.headers["x-runtime-instance-id"][0] : req.headers["x-runtime-instance-id"];
-  const extra = markScriptSdkRequestOrigin({
-    sessionId: "mcp-bridge",
-    requestInfo: {
-      headers: {
-        "x-agent-id": myAgentId ?? "",
-        ...sourceTaskId ? { "x-source-task-id": sourceTaskId } : {},
-        ...runtimeInstanceId ? { "x-runtime-instance-id": runtimeInstanceId } : {}
-      }
-    }
-  });
-  let handlerArgs = args;
-  if (tool.inputSchema) {
-    const inputObj = normalizeObjectSchema(tool.inputSchema);
-    const parseResult = await safeParseAsync(inputObj ?? tool.inputSchema, args);
-    if (!parseResult.success) {
-      const parseError = "error" in parseResult ? parseResult.error : "Unknown error";
-      jsonError(res, `Invalid arguments for tool '${toolName}': ${getParseErrorMessage(parseError)}`, 400);
-      return true;
-    }
-    handlerArgs = parseResult.data;
-  }
-  try {
-    const result = tool.inputSchema ? await Promise.resolve(tool.handler(handlerArgs, extra)) : await Promise.resolve(tool.handler(extra));
-    if (result && typeof result === "object" && "structuredContent" in result) {
-      json(res, result.structuredContent);
-    } else if (result && typeof result === "object" && "content" in result) {
-      const content = result.content;
-      const text = content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join(`
-`);
-      try {
-        json(res, JSON.parse(text));
-      } catch {
-        json(res, { result: text });
-      }
-    } else {
-      json(res, result ?? {});
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    jsonError(res, message, 500);
-  }
-  return true;
-}
-
 // src/http/mcp-oauth.ts
 init_zod();
 init_db();
@@ -14946,7 +15777,7 @@ var deleteByIdRoute = route({
   },
   auth: { apiKey: true }
 });
-var listRoute2 = route({
+var listRoute3 = route({
   method: "get",
   path: "/api/prompt-templates",
   pattern: ["api", "prompt-templates"],
@@ -15126,8 +15957,8 @@ ${templateBody}` : templateBody;
     }
     return true;
   }
-  if (listRoute2.match(req.method, pathSegments)) {
-    const parsed = await listRoute2.parse(req, res, pathSegments, queryParams);
+  if (listRoute3.match(req.method, pathSegments)) {
+    const parsed = await listRoute3.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
     const templates = getPromptTemplates({
@@ -15136,7 +15967,7 @@ ${templateBody}` : templateBody;
       scopeId: parsed.query.scopeId || undefined,
       isDefault: parsed.query.isDefault ? parsed.query.isDefault === "true" : undefined
     });
-    listRoute2.respond(res, 200, { templates: templates.map(toPromptTemplateResponse) });
+    listRoute3.respond(res, 200, { templates: templates.map(toPromptTemplateResponse) });
     return true;
   }
   if (upsertRoute.match(req.method, pathSegments)) {
@@ -16319,7 +17150,7 @@ init_secret_scrubber();
 var providerSchema = exports_external.string().min(1).max(255).regex(/^[A-Za-z0-9_-]+$/);
 var scopeSchema = exports_external.enum(["global", "agent", "repo"]);
 var connectionKindSchema = exports_external.enum(["openapi", "graphql", "mcp"]);
-var idParamsSchema = exports_external.object({ id: exports_external.string().uuid() });
+var idParamsSchema2 = exports_external.object({ id: exports_external.string().uuid() });
 var providerParamsSchema = exports_external.object({ provider: providerSchema });
 var oauthResourceIdParamsSchema = exports_external.object({ id: exports_external.string().min(1).max(255) });
 var listConnectionsQuerySchema = exports_external.object({
@@ -16648,7 +17479,7 @@ var getConnectionRoute = route({
   operationId: "script_connections_get",
   summary: "Get script connection detail",
   tags: ["Script Connections"],
-  params: idParamsSchema,
+  params: idParamsSchema2,
   responses: {
     200: {
       description: "Script connection detail",
@@ -16682,7 +17513,7 @@ var refreshConnectionRoute = route({
   operationId: "script_connections_refresh",
   summary: "Refresh a script connection",
   tags: ["Script Connections"],
-  params: idParamsSchema,
+  params: idParamsSchema2,
   responses: {
     200: {
       description: "Refreshed script connection",
@@ -16701,7 +17532,7 @@ var setConnectionEnabledRoute = route({
   operationId: "script_connections_set_enabled",
   summary: "Enable or disable a script connection",
   tags: ["Script Connections"],
-  params: idParamsSchema,
+  params: idParamsSchema2,
   body: disableConnectionBodySchema,
   responses: {
     200: {
@@ -18272,7 +19103,7 @@ init_types();
 init_constants();
 var DEFAULT_SCRIPT_RUN_CONCURRENCY_CAP = 10;
 var runIdParamsSchema = exports_external.object({ runId: exports_external.string().uuid() });
-var idParamsSchema2 = exports_external.object({ id: exports_external.string().uuid() });
+var idParamsSchema3 = exports_external.object({ id: exports_external.string().uuid() });
 var stepParamsSchema = exports_external.object({
   runId: exports_external.string().uuid(),
   stepKey: exports_external.string().min(1)
@@ -18379,7 +19210,7 @@ var getScriptRunRoute = route({
   operationId: "script_runs_get",
   summary: "Get a script workflow run with journal",
   tags: ["Script Runs"],
-  params: idParamsSchema2,
+  params: idParamsSchema3,
   responses: {
     200: {
       description: "Script run detail",
@@ -18395,7 +19226,7 @@ var deleteScriptRunRoute = route({
   operationId: "script_runs_cancel",
   summary: "Cancel a script workflow run",
   tags: ["Script Runs"],
-  params: idParamsSchema2,
+  params: idParamsSchema3,
   responses: {
     204: { description: "Script run cancelled, or already terminal" },
     404: { description: "Script run not found" }
@@ -18775,6 +19606,7 @@ async function handleScriptRuns(req, res, pathSegments, queryParams, agentId) {
         agentId: parsed.body.agentId,
         routingReason: parsed.body.routingReason ?? (parsed.body.agentId ? "human_pinned" : undefined),
         routingNote: parsed.body.routingNote,
+        routingSource: parsed.body.routingReason ? "declared" : parsed.body.agentId ? "engine_default" : undefined,
         tags: parsed.body.tags,
         priority: parsed.body.priority,
         offeredTo: parsed.body.offerMode ? parsed.body.agentId : undefined,
@@ -18841,7 +19673,7 @@ var searchBodySchema = exports_external.object({
 var nameParamsSchema = exports_external.object({ name: scriptNameSchema });
 var scopeQuerySchema = exports_external.object({ scope: ScriptScopeSchema.default("agent") });
 var optionalScopeQuerySchema = exports_external.object({ scope: ScriptScopeSchema.optional() });
-var idParamsSchema3 = exports_external.object({ id: exports_external.string().uuid() });
+var idParamsSchema4 = exports_external.object({ id: exports_external.string().uuid() });
 var listScriptsQuerySchema = exports_external.object({
   scope: ScriptScopeSchema.optional(),
   includeScratch: exports_external.enum(["true", "false"]).optional()
@@ -18976,7 +19808,7 @@ var searchRoute = route({
   },
   rbac: { permission: "script.search" }
 });
-var deleteRoute = route({
+var deleteRoute2 = route({
   method: "delete",
   path: "/api/scripts/{name}",
   pattern: ["api", "scripts", null],
@@ -19024,7 +19856,7 @@ var listScriptsRoute = route({
     400: { description: "Validation error" }
   }
 });
-var typeDefsRoute = route({
+var typeDefsRoute2 = route({
   method: "get",
   path: "/api/scripts/type-defs",
   pattern: ["api", "scripts", "type-defs"],
@@ -19047,7 +19879,7 @@ var getScriptByIdRoute = route({
   summary: "Get a saved script by id",
   description: "Dashboard read: full record including source and parsed signature.",
   tags: ["Scripts"],
-  params: idParamsSchema3,
+  params: idParamsSchema4,
   responses: {
     200: { description: "Script detail", schema: exports_external.object({ script: scriptDetailSchema }) },
     404: { description: "Script not found" }
@@ -19061,7 +19893,7 @@ var listVersionsRoute = route({
   summary: "List versions of a saved script",
   description: "Dashboard read: version history, newest first.",
   tags: ["Scripts"],
-  params: idParamsSchema3,
+  params: idParamsSchema4,
   responses: {
     200: {
       description: "Script versions",
@@ -19093,7 +19925,7 @@ var createScriptApiRoute = route({
   summary: "Expose a script as an external HTTP API endpoint",
   description: "Returns the endpoint plus the plaintext bearer token (when authMode is 'bearer').",
   tags: ["Scripts"],
-  params: idParamsSchema3,
+  params: idParamsSchema4,
   body: createScriptApiBodySchema,
   responses: {
     201: { description: "Endpoint created", schema: scriptApiWithSecretSchema },
@@ -19109,7 +19941,7 @@ var listScriptApisRoute = route({
   operationId: "scripts_api_list",
   summary: "List external API endpoints for a script",
   tags: ["Scripts"],
-  params: idParamsSchema3,
+  params: idParamsSchema4,
   responses: {
     200: {
       description: "Endpoints (without secrets)",
@@ -19472,11 +20304,11 @@ async function handleScripts(req, res, pathSegments, queryParams, agentId) {
     listScriptsRoute.respond(res, 200, { scripts });
     return true;
   }
-  if (typeDefsRoute.match(req.method, pathSegments)) {
+  if (typeDefsRoute2.match(req.method, pathSegments)) {
     const apiTypes = getScriptApiTypes();
     const mcpTypes = getScriptMcpTypes();
     const appTypes = await getScriptAppTypes();
-    typeDefsRoute.respond(res, 200, {
+    typeDefsRoute2.respond(res, 200, {
       sdkTypes: await scriptSdkTypesWithGeneratedApis(apiTypes, mcpTypes, appTypes),
       stdlibTypes: await scriptStdlibTypesWithGeneratedApis(apiTypes, mcpTypes, appTypes)
     });
@@ -19530,8 +20362,8 @@ async function handleScripts(req, res, pathSegments, queryParams, agentId) {
     });
     return true;
   }
-  if (deleteRoute.match(req.method, pathSegments)) {
-    const parsed = await deleteRoute.parse(req, res, pathSegments, queryParams);
+  if (deleteRoute2.match(req.method, pathSegments)) {
+    const parsed = await deleteRoute2.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
     const agent = await requireAgent2(res, agentId);
@@ -19570,7 +20402,7 @@ async function handleScripts(req, res, pathSegments, queryParams, agentId) {
       }, 409);
       return true;
     }
-    deleteRoute.respond(res, 200, { deleted: outcome.deleted });
+    deleteRoute2.respond(res, 200, { deleted: outcome.deleted });
     return true;
   }
   if (createScriptApiRoute.match(req.method, pathSegments)) {
@@ -21590,8 +22422,7 @@ async function harnessMilestone() {
   };
 }
 function embeddingsMilestone() {
-  const embeddingKey = process.env.EMBEDDING_API_KEY ?? process.env.OPENAI_API_KEY;
-  if (embeddingKey) {
+  if (getEmbeddingProvider().isConfigured()) {
     return {
       id: "embeddings",
       label: "Memory search",
@@ -22073,7 +22904,14 @@ var createTask = route({
   }),
   responses: {
     201: { description: "Task created", schema: AgentTaskSchema },
-    400: { description: "Validation error" }
+    400: { description: "Validation error" },
+    422: {
+      description: "Task creation blocked by an extension",
+      schema: exports_external.object({
+        error: exports_external.string(),
+        extension: exports_external.object({ id: exports_external.string(), name: exports_external.string() })
+      })
+    }
   }
 });
 var promoteDraftTaskRoute = route({
@@ -22557,6 +23395,7 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
         key: assetKey,
         agentId: defaultAgentId,
         routingReason: parsed.body.routingReason ?? (defaultAgentId ? parentTask?.agentId === defaultAgentId ? "continuity" : "skill" : undefined),
+        routingSource: parsed.body.routingReason ? "declared" : defaultAgentId ? "engine_default" : undefined,
         routingNote: parsed.body.routingNote,
         creatorAgentId: myAgentId || undefined,
         taskType: parsed.body.taskType || undefined,
@@ -22576,7 +23415,7 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
           modelTier: parsed.body.modelTier
         }),
         effort: parsed.body.effort
-      });
+      }, { origin: "rest" });
       ensure({
         id: "created",
         flow: "task",
@@ -22594,6 +23433,10 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       });
       createTask.respond(res, 201, task);
     } catch (error) {
+      if (error instanceof TaskCreationBlockedError) {
+        createTask.respond(res, 422, { error: error.reason, extension: error.extension });
+        return true;
+      }
       console.error("[HTTP] Failed to create task:", error);
       jsonError(res, "Failed to create task", 500);
     }
@@ -24831,13 +25674,14 @@ async function routeKapsoInbound(payload) {
   const task = await createTaskWithSiblingAwareness(await buildTaskDescription(payload), {
     agentId: mapping.agentId ?? null,
     routingReason: mapping.agentId ? "human_pinned" : undefined,
+    routingSource: mapping.agentId ? "engine_default" : undefined,
     source: "system",
     taskType: "kapso-inbound",
     tags: ["kapso-whatsapp", "inbound"],
     priority: 70,
     requestedByUserId: await resolveKapsoRequestedByUserId(payload),
     contextKey: `kapso:conversation:${payload.conversation?.id ?? messageId}`
-  });
+  }, { origin: "webhook" });
   return { kind: "task", taskId: task.id };
 }
 
@@ -25717,21 +26561,21 @@ var getWorkflowVersionRoute = route({
 });
 async function handleWorkflows(req, res, pathSegments, queryParams, myAgentId) {
   if (listExecutorTypesRoute.match(req.method, pathSegments)) {
-    const registry2 = getExecutorRegistry();
-    listExecutorTypesRoute.respond(res, 200, { executorTypes: registry2.describeAll() });
+    const registry = getExecutorRegistry();
+    listExecutorTypesRoute.respond(res, 200, { executorTypes: registry.describeAll() });
     return true;
   }
   if (getExecutorTypeRoute.match(req.method, pathSegments)) {
     const parsed = await getExecutorTypeRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
-    const registry2 = getExecutorRegistry();
-    if (!registry2.has(parsed.params.type)) {
+    const registry = getExecutorRegistry();
+    if (!registry.has(parsed.params.type)) {
       res.writeHead(404);
       res.end();
       return true;
     }
-    getExecutorTypeRoute.respond(res, 200, registry2.describe(parsed.params.type));
+    getExecutorTypeRoute.respond(res, 200, registry.describe(parsed.params.type));
     return true;
   }
   if (webhookTriggerRoute.match(req.method, pathSegments)) {
@@ -26388,6 +27232,7 @@ function startApiGcInterval() {
 }
 if (globalState.__httpServer) {
   globalState.__closeRealtime?.();
+  await globalState.__stopExtensions?.();
   console.log("[HTTP] Hot reload detected, closing previous server...");
   globalState.__httpServer.close();
 }
@@ -26492,6 +27337,7 @@ var httpServer = createHttpServer(async (req, res) => {
         () => handleApiKeys(req, res, pathSegments, queryParams),
         () => handleHeartbeat(req, res, pathSegments),
         () => handleEvents(req, res, pathSegments, queryParams, myAgentId),
+        () => handleExtensions(req, res, pathSegments, queryParams, myAgentId),
         () => handleFavorites(req, res, pathSegments, queryParams, myAgentId),
         () => handleUsers(req, res, pathSegments, queryParams),
         () => handleSessions(req, res, pathSegments, queryParams),
@@ -26546,6 +27392,7 @@ globalState.__mcpSessionAgents = mcpSessionAgents;
 globalState.__sessionUsers = sessionUsers;
 globalState.__transportActivity = transportActivity;
 globalState.__transportActivityUser = transportActivityUser;
+globalState.__stopExtensions = stopExtensionRuntime;
 async function shutdown() {
   globalState.__closeRealtime?.();
   console.log("Shutting down HTTP server...");
@@ -26555,7 +27402,7 @@ async function shutdown() {
     sessionsProcessed: getServerSessionsProcessed()
   });
   if (hasCapability("scheduling")) {
-    const { stopScheduler } = await import("./index-769nc012.js");
+    const { stopScheduler } = await import("./index-hw26vj40.js");
     stopScheduler();
   }
   stopHeartbeat();
@@ -26563,13 +27410,14 @@ async function shutdown() {
   await stopScriptRunSupervisor();
   await stopSlackApp();
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { stopOAuthKeepalive } = await import("./keepalive-nesm3xb6.js");
+    const { stopOAuthKeepalive } = await import("./keepalive-asqtcm4y.js");
     await stopOAuthKeepalive();
   }
   stopOAuthPendingGc();
   stopMemoryGc();
   await stopDbRetention();
   stopScratchScriptGc();
+  await stopExtensionRuntime();
   stopAuditGc();
   stopAuditWriter();
   await flushAuditBuffer();
@@ -26617,7 +27465,7 @@ if (!globalState.__runId) {
 startApiGcInterval();
 var startupConfigsInjected = [];
 try {
-  startupConfigsInjected = await loadGlobalConfigsIntoEnv(false);
+  startupConfigsInjected = await loadGlobalConfigsIntoEnv(true);
 } catch (err) {
   console.error("[startup] Failed to load global swarm configs before listen:", err);
   process.exitCode = 1;
@@ -26630,15 +27478,15 @@ try {
   console.warn("[startup] CAPABILITIES upgrade seed failed (non-fatal):", err);
 }
 try {
-  const { seedPricingFromModelsDev } = await import("./seed-pricing-49gbgn96.js");
+  const { seedPricingFromModelsDev } = await import("./seed-pricing-jqjs6cws.js");
   seedPricingFromModelsDev();
-  const { startPricingRefreshLoop } = await import("./pricing-refresh-5v56x7gb.js");
+  const { startPricingRefreshLoop } = await import("./pricing-refresh-mx51az05.js");
   startPricingRefreshLoop();
 } catch (err) {
   console.error("[startup] Failed to seed pricing rows:", err);
 }
 try {
-  const { ensureRbacSeedsSynced } = await import("./rbac-roles-0p0s6pbj.js");
+  const { ensureRbacSeedsSynced } = await import("./rbac-roles-wcmrg6sv.js");
   ensureRbacSeedsSynced();
 } catch (err) {
   console.error("[startup] Failed to sync RBAC seed rows:", err);
@@ -26646,11 +27494,16 @@ try {
     throw err;
 }
 try {
-  const { runAllSeeders } = await import("./index-ezxkds2n.js");
+  const { runAllSeeders } = await import("./index-16js521z.js");
   await runAllSeeders({ scriptEmbeddingMode: "skip" });
 } catch (err) {
   console.error("[startup] Failed to seed built-in entities:", err);
 }
+try {
+  await loadEnabledExtensions();
+} catch (err) {
+  console.error("[startup] Failed to initialize extensions:", scrubSecrets(err instanceof Error ? err.message : String(err)));
+}
 setAuditSink(enqueueAuditRow);
 startAuditWriter();
 await startAuditGc();
@@ -26658,6 +27511,10 @@ startScratchScriptGc();
 initialize();
 await initOtel("api");
 httpServer.listen(port, async () => {
+  const boundAddress = httpServer.address();
+  if (boundAddress && typeof boundAddress === "object") {
+    setExtensionLoopbackBaseUrl(`http://127.0.0.1:${boundAddress.port}`);
+  }
   console.log(`MCP HTTP server running on http://localhost:${port}/mcp`);
   ensure({
     id: "listen",
@@ -26677,7 +27534,11 @@ httpServer.listen(port, async () => {
   if (process.env.GITHUB_TOKEN) {
     await emitBuiltInIntegrationConnectedOnce("github");
   }
-  await startSlackApp();
+  try {
+    await startSlackApp();
+  } catch (err) {
+    console.error("[Slack] Failed to start, continuing boot without Slack:", err);
+  }
   startQueueStallAlarm();
   initGitHub();
   initGitLab();
@@ -26687,36 +27548,36 @@ httpServer.listen(port, async () => {
   await initWorkflows();
   await startScriptRunSupervisor(getMcpBaseUrl());
   if (hasCapability("scheduling")) {
-    const { startScheduler } = await import("./index-769nc012.js");
-    const { getExecutorRegistry: getExecutorRegistry2 } = await import("./index-0wdy6gwc.js");
+    const { startScheduler } = await import("./index-hw26vj40.js");
+    const { getExecutorRegistry: getExecutorRegistry2 } = await import("./index-nnrbpcjp.js");
     const intervalMs = Number(process.env.SCHEDULER_INTERVAL_MS) || 1e4;
     startScheduler(getExecutorRegistry2(), intervalMs, {
       runId: globalState.__runId
     });
   }
   if (!isEnvFlagEnabled("HEARTBEAT_DISABLE", false)) {
-    const { startHeartbeat } = await import("./index-x1zcj09z.js");
+    const { startHeartbeat } = await import("./index-zj518gf9.js");
     const heartbeatMs = Number(process.env.HEARTBEAT_INTERVAL_MS) || 90000;
     startHeartbeat(heartbeatMs);
   }
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { startOAuthKeepalive } = await import("./keepalive-nesm3xb6.js");
+    const { startOAuthKeepalive } = await import("./keepalive-asqtcm4y.js");
     startOAuthKeepalive();
   }
   if (process.env.OAUTH_REFRESH_SWEEP_DISABLE !== "true") {
-    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-sh8xjy08.js");
+    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-3s04c6qw.js");
     startOAuthRefreshSweep();
   }
   startOAuthPendingGc();
   await startMemoryGc();
   await startDbRetention();
-  import("./boot-reembed-q5wd3tha.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
+  import("./boot-reembed-nafcmmmc.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
     console.error("[boot-reembed] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-reembed-msweabbp.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
+  import("./boot-reembed-3cmrrmpa.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
     console.error("[boot-reembed-scripts] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-scrub-logs-3g1az933.js").then(({ runBootScrubLogs }) => runBootScrubLogs()).catch((err) => {
+  import("./boot-scrub-logs-cd6a2sq0.js").then(({ runBootScrubLogs }) => runBootScrubLogs()).catch((err) => {
     console.error("[boot-scrub-logs] startup scrub failed (non-fatal):", err);
   });
 }).on("error", (err) => {