@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/dist/{cli-v3yr2gbg.js → cli-5kzk3472.js}

@@ -9,6 +9,7 @@ import {
   gitlabContextKey,
   azureDevOpsContextKey,
   azureDevOpsWorkItemContextKey,
+  bitbucketContextKey,
   linearContextKey,
   buildJiraContextKey,
   scheduleContextKey,
@@ -72,6 +73,7 @@ import {
   hasNonTerminalRerouteDecisionChild2,
   getAgentCurrentTask2,
   findTaskByVcs2,
+  findActiveTasksByVcs2,
   readableSessionCondition,
   getAllTasks2,
   getPendingChatRelayTasks2,
@@ -155,6 +157,8 @@ import {
   computeScore,
   rerank,
   init_reranker,
+  searchMemoryCandidates,
+  init_search_candidates,
   rowToCandidate,
   init_sqlite_store,
   getEmbeddingProvider2,
@@ -332,19 +336,19 @@ import {
   recordInlineScriptRun2,
   exports_db,
   init_db3
-} from "./cli-p20r8w42.js";
+} from "./cli-fcc5qe3f.js";
 import {
   getUserGrant2,
   init_rbac_roles
-} from "./cli-4dg55wsk.js";
+} from "./cli-0z3vjrpm.js";
 import {
   ensurePricingSeeded2,
   ensureRbacSeeded2,
   ensureModelProfilesSeeded2
-} from "./cli-t7cyef5g.js";
+} from "./cli-36j4jnk3.js";
 import {
   loadModelsDevCache
-} from "./cli-amyhm3gj.js";
+} from "./cli-0y6f0ckq.js";
 import {
   buildCatalogEntries,
   listModelCatalog,
@@ -354,12 +358,12 @@ import {
   loadModelsCatalog,
   requestModelCatalogRefresh2,
   startPricingRefreshLoop2
-} from "./cli-xc27fwzg.js";
+} from "./cli-y9jvxfhk.js";
 import {
   ampPinProviderError,
   ampPinCatalogError,
   ampModelError
-} from "./cli-2zqpkvtt.js";
+} from "./cli-jpxsrxcb.js";
 import {
   notifyAutomationPreflightFailure,
   isNeedsSetupFailure,
@@ -368,50 +372,50 @@ import {
   getAutomationSetupStates,
   schedulePreflightInput,
   recordSchedulePreflightFailure,
+  BaseExecutor,
+  postApprovalCancellationUpdates,
+  createApprovalFollowUpTask,
+  HumanInTheLoopExecutor,
+  resolveWorkflowLlmConfig,
+  SYSTEM_ONE_PROVIDER_IDS,
+  SystemOneExtractionExecutor,
+  SYSTEM_ONE_DECISION_NODE_TYPE,
+  SystemOneDecisionConfigSchema,
+  SystemOneDecisionExecutor,
   checkpointStep,
   checkpointStepFailure,
   checkpointStepWaiting,
-  FOREACH_TERMINAL_STEP_STATUSES,
-  parseSyntheticNodeId,
-  buildForeachAggregate,
+  FAILED_TASK_OUTPUT_PREFIX,
+  FOREACH_ITEMS_WAIT_FOR,
   loadCompletedStepRouting,
   resolveInputValue,
   getSecretInputKeys,
   validateJsonSchema,
   findJsonSchemaShapeErrors,
-  getMaxWorkflowStepsPerRun,
   workflowSaveWarnings,
   withSaveWarnings,
   runStepValidation,
-  shapeApprovalResolution,
-  FAILED_TASK_OUTPUT_PREFIX,
-  SubWorkflowExecutor,
-  WaitExecutor,
-  failStepAndRunIfWaiting,
-  checkpointPortStepAndResolveSuccessors,
-  scheduleTaskStepRetry,
-  completeTaskStepAndResolveSuccessors,
-  setupWorkflowResumeListener2,
-  finalizeOrWait2,
-  retryFailedRun2,
-  cancelWorkflowRunRows2,
-  cancelWorkflowRun2,
-  resumeWaitState2,
-  recoverResolvedWaitState2,
-  resumeFromChildRun2,
-  initWaitBusSubscriptions2,
   TriggerSchemaError,
   startWorkflowExecution2,
   failRunOnUnreadableReplay,
   isWorkflowRunActive,
   holdWorkflowRun,
   walkGraph,
-  rehydrateCompletedStepOutputs,
   findReadyNodes,
-  buildNodeInterpolationCtx,
-  interpolateNodeConfig,
-  scriptBodyInterpolationError
-} from "./cli-51y09c6p.js";
+  scriptBodyInterpolationError,
+  ForeachExecutor,
+  rebuildNodeExecutionInput,
+  isForeachChildOwned,
+  parkAndDriveForeach,
+  runForeachDrive,
+  stepFailureMode,
+  generateEdges,
+  resolveValidationPort,
+  getSuccessors,
+  definitionNodeIds,
+  validateDefinition,
+  applyDefinitionPatch
+} from "./cli-92mqenkc.js";
 import {
   require_dist2,
   publicEndpointSsrfOptions,
@@ -471,14 +475,14 @@ import {
   deleteApp,
   typecheckScript,
   parseSkillContent
-} from "./cli-2y91wnbh.js";
+} from "./cli-we0ra057.js";
 import {
   buildAuthorizationUrl,
   onAuthorizationRefreshed,
   ensureAuthorizationTokenOrThrow,
   ensureToken,
   ensureTokenOrThrow
-} from "./cli-esxerzg7.js";
+} from "./cli-s4sntwt4.js";
 import {
   detachedProcessGroup,
   registerProcessGroup,
@@ -508,36 +512,36 @@ import {
   getSlackApp2,
   startSlackApp2,
   stopSlackApp2
-} from "./cli-qkhc5aqy.js";
+} from "./cli-fy1jyyym.js";
 import {
   slackCode,
   slackMissingScopeMessage,
   withAutoJoin,
   externalChannelToolError2,
   getChannelBlockReason2
-} from "./cli-1d70crsy.js";
-import {
-  BaseExecutor,
-  postApprovalCancellationUpdates,
-  createApprovalFollowUpTask,
-  HumanInTheLoopExecutor,
-  resolveWorkflowLlmConfig,
-  SYSTEM_ONE_PROVIDER_IDS,
-  SystemOneExtractionExecutor,
-  SYSTEM_ONE_DECISION_NODE_TYPE,
-  SystemOneDecisionConfigSchema,
-  SystemOneDecisionExecutor,
-  generateEdges,
-  resolveValidationPort,
-  getSuccessors,
-  definitionNodeIds,
-  validateDefinition,
-  applyDefinitionPatch
-} from "./cli-q6r7t299.js";
+} from "./cli-ftmq4nvk.js";
 import {
   workflowEventBus2,
   init_event_bus
-} from "./cli-wt645v7q.js";
+} from "./cli-dabehxhp.js";
+import {
+  shapeApprovalResolution,
+  SubWorkflowExecutor,
+  WaitExecutor,
+  failStepAndRunIfWaiting,
+  checkpointPortStepAndResolveSuccessors,
+  scheduleTaskStepRetry,
+  completeTaskStepAndResolveSuccessors,
+  setupWorkflowResumeListener2,
+  finalizeOrWait2,
+  retryFailedRun2,
+  cancelWorkflowRunRows2,
+  cancelWorkflowRun2,
+  resumeWaitState2,
+  recoverResolvedWaitState2,
+  resumeFromChildRun2,
+  initWaitBusSubscriptions2
+} from "./cli-3zwye9sn.js";
 import {
   duplicateGuardedQueryKey,
   parseQueryParams,
@@ -564,19 +568,21 @@ import {
   isPublicRoute,
   findRoute,
   route
-} from "./cli-cynvc9fj.js";
+} from "./cli-9ce2xw98.js";
 import {
   isMultiRuntimeEnabled
 } from "./cli-e8xyjvfc.js";
 import {
+  FilesError,
   providerPath,
+  normalizeStoredKey,
   AgentFsProvider,
   getFileStorageProvider2
-} from "./cli-qje9k2nh.js";
+} from "./cli-g9ypd5en.js";
 import {
   getRuntimePool2,
   init_db
-} from "./cli-w6nadkh4.js";
+} from "./cli-5rvg1ddk.js";
 import {
   getMemoryRaterNames,
   REFERENCES_SOURCE_MAX_LENGTH,
@@ -587,7 +593,7 @@ import {
   COMPOSIO_HTTP_METHODS,
   executeComposioRequest,
   composioArgsFromParts
-} from "./cli-smvcw9z5.js";
+} from "./cli-pasyvjmm.js";
 import {
   require_fast_deep_equal
 } from "./cli-bhp11egn.js";
@@ -601,7 +607,7 @@ import {
 import {
   canProvisionKind,
   init_runtime_providers
-} from "./cli-625tb7aq.js";
+} from "./cli-p859hcc8.js";
 import {
   findUserById,
   findUserByExternalId,
@@ -617,7 +623,7 @@ import {
   resolveSessionToken,
   fingerprintApiKey,
   init_users
-} from "./cli-9fhkkpj5.js";
+} from "./cli-xt768r5m.js";
 import {
   isRbacEnabled,
   decideAdmission,
@@ -686,7 +692,7 @@ import {
   KvNamespaceSchema,
   KvKeySchema,
   init_types
-} from "./cli-nc35pxb7.js";
+} from "./cli-rh5smt8t.js";
 import {
   generateDefaultClaudeMd2,
   generateDefaultSoulMd2,
@@ -695,7 +701,7 @@ import {
   taskAttachmentFetchCommand,
   taskAttachmentDisplayUrl,
   init_task_attachment_links
-} from "./cli-74c1wpm0.js";
+} from "./cli-gpv60278.js";
 import {
   getSlackConfiguration,
   init_config
@@ -707,7 +713,6 @@ import {
 import {
   findInterpolationTokens,
   interpolate,
-  deepInterpolate,
   init_template,
   registerTemplate,
   getTemplateDefinition,
@@ -733,7 +738,6 @@ import {
   _null,
   any,
   unknown,
-  never,
   array2,
   object2,
   looseObject,
@@ -757,7 +761,7 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-pccfmtb5.js";
+} from "./cli-179xcyky.js";
 import {
   realtimeBus,
   init_bus
@@ -786,11 +790,12 @@ import {
 import {
   scrubSecrets,
   scrubObject,
+  createValueScrubber,
   refreshSecretScrubberCache,
   registerVolatileSecret,
   registerSensitiveKeyName,
   init_secret_scrubber
-} from "./cli-xf234ws8.js";
+} from "./cli-n4c8e3s5.js";
 import {
   isAlias,
   parseAlias,
@@ -16809,6 +16814,9 @@ class Protocol {
       this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
         const handleTaskResult = async () => {
           const taskId = request.params.taskId;
+          if (!await this._taskStore.getTask(taskId, extra.sessionId)) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
           if (this._taskMessageQueue) {
             let queuedMessage;
             while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
@@ -16839,12 +16847,12 @@ class Protocol {
             throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
           }
           if (!isTerminal(task.status)) {
-            await this._waitForTaskUpdate(taskId, extra.signal);
+            await this._waitForTaskUpdate(taskId, extra.signal, extra.sessionId);
             return await handleTaskResult();
           }
           if (isTerminal(task.status)) {
             const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-            this._clearTaskQueue(taskId);
+            this._clearTaskQueue(taskId, extra.sessionId);
             return {
               ...result,
               _meta: {
@@ -16881,7 +16889,7 @@ class Protocol {
             throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
           }
           await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-          this._clearTaskQueue(request.params.taskId);
+          this._clearTaskQueue(request.params.taskId, extra.sessionId);
           const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
           if (!cancelledTask) {
             throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
@@ -17004,6 +17012,19 @@ class Protocol {
     const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
     const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    const sessionId = capturedTransport?.sessionId;
+    const store = this._taskStore;
+    let relatedTaskFound = true;
+    let relatedTaskLookup;
+    if (relatedTaskId && store && this._taskMessageQueue && sessionId !== undefined) {
+      relatedTaskFound = false;
+      relatedTaskLookup = (async () => {
+        if (!await store.getTask(relatedTaskId, sessionId)) {
+          throw new McpError(ErrorCode.InvalidParams, `Task not found: ${relatedTaskId}`);
+        }
+        relatedTaskFound = true;
+      })();
+    }
     if (handler === undefined) {
       const errorResponse = {
         jsonrpc: "2.0",
@@ -17013,7 +17034,10 @@ class Protocol {
           message: "Method not found"
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && relatedTaskLookup) {
+        const queuedError = { type: "error", message: errorResponse, timestamp: Date.now() };
+        relatedTaskLookup.then(() => this._enqueueTaskMessage(relatedTaskId, queuedError, sessionId), () => capturedTransport?.send(errorResponse)).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+      } else if (relatedTaskId && this._taskMessageQueue) {
         this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -17064,7 +17088,10 @@ class Protocol {
       closeSSEStream: extra?.closeSSEStream,
       closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => {
+    (relatedTaskLookup ?? Promise.resolve()).then(() => {
+      if (relatedTaskLookup && abortController.signal.aborted) {
+        throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
+      }
       if (taskCreationParams) {
         this.assertTaskHandlerCapability(request.method);
       }
@@ -17099,7 +17126,7 @@ class Protocol {
           ...error["data"] !== undefined && { data: error["data"] }
         }
       };
-      if (relatedTaskId && this._taskMessageQueue) {
+      if (relatedTaskId && this._taskMessageQueue && relatedTaskFound) {
         await this._enqueueTaskMessage(relatedTaskId, {
           type: "error",
           message: errorResponse,
@@ -17487,7 +17514,7 @@ class Protocol {
       throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
     }
     const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId ?? this._transport?.sessionId, maxQueueSize);
   }
   async _clearTaskQueue(taskId, sessionId) {
     if (this._taskMessageQueue) {
@@ -17506,10 +17533,10 @@ class Protocol {
       }
     }
   }
-  async _waitForTaskUpdate(taskId, signal) {
+  async _waitForTaskUpdate(taskId, signal, sessionId) {
     let interval = this._options?.defaultTaskPollInterval ?? 1000;
     try {
-      const task = await this._taskStore?.getTask(taskId);
+      const task = await this._taskStore?.getTask(taskId, sessionId);
       if (task?.pollInterval) {
         interval = task.pollInterval;
       }
@@ -18178,6 +18205,42 @@ class ExperimentalMcpServerTasks {
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
 init_zod();
+function toolInputElementCount(value, max) {
+  let count = 0;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node === null || typeof node !== "object")
+      continue;
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        if (++count > max)
+          return count;
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    } else {
+      for (const key in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, key))
+          continue;
+        if (++count > max)
+          return count;
+        const child = node[key];
+        if (child !== null && typeof child === "object")
+          stack.push(child);
+      }
+    }
+  }
+  return count;
+}
+function resolveMaxToolInputElements(value) {
+  if (value === undefined || value === Infinity)
+    return;
+  if (typeof value !== "number" || Number.isNaN(value) || value < 1) {
+    throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+  }
+  return value;
+}
 
 class McpServer {
   constructor(serverInfo, options) {
@@ -18190,6 +18253,7 @@ class McpServer {
     this._resourceHandlersInitialized = false;
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
+    this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
   }
   get experimental() {
     if (!this._experimental) {
@@ -18296,12 +18360,15 @@ class McpServer {
     };
   }
   async validateToolInput(tool, args, toolName) {
+    if (this._maxToolInputElements !== undefined && toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) {
+      throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
+    }
     if (!tool.inputSchema) {
       return;
     }
     const inputObj = normalizeObjectSchema(tool.inputSchema);
     const schemaToParse = inputObj ?? tool.inputSchema;
-    const parseResult = await safeParseAsync2(schemaToParse, args);
+    const parseResult = await safeParseAsync2(schemaToParse, args ?? {});
     if (!parseResult.success) {
       const error = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error);
@@ -18526,7 +18593,7 @@ class McpServer {
       }
       if (prompt.argsSchema) {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
-        const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
+        const parseResult = await safeParseAsync2(argsObj, request.params.arguments ?? {});
         if (!parseResult.success) {
           const error = "error" in parseResult ? parseResult.error : "Unknown error";
           const errorMessage = getParseErrorMessage(error);
@@ -20070,6 +20137,7 @@ async function recoverIncompleteRuns(registry) {
       console.error(`[workflows] Failed to resume sub-workflow step ${parentStepId}:`, err);
     }
   }
+  recovered += await recoverForeachFanouts(registry);
   if (recovered > 0) {
     console.log(`[workflows] Recovered ${recovered} incomplete run(s)`);
   }
@@ -20163,10 +20231,10 @@ async function recoverWaitingRuns(registry) {
         if (retry !== "not-eligible")
           continue;
       }
-      if (!taskCompleted && (workflow.definition.onNodeFailure ?? "fail") === "fail") {
+      if (!taskCompleted && stepFailureMode(workflow.definition, stuck.nodeId) === "fail") {
         const reason = stuck.taskStatus === "failed" ? "Task failed (recovered)" : "Task cancelled (recovered)";
-        const claimed = await failStepAndRunIfWaiting(stuck.stepId, stuck.runId, reason, stuck.taskId);
-        if (!claimed)
+        const failed = await failStepAndRunIfWaiting(workflow.definition, stuck.stepId, stuck.runId, reason, stuck.taskId, { registry });
+        if (!failed.claimed)
           continue;
         recovered++;
         continue;
@@ -20180,7 +20248,7 @@ async function recoverWaitingRuns(registry) {
       const step = await getWorkflowRunStep2(stuck.stepId);
       if (!step)
         continue;
-      const routing = await completeTaskStepAndResolveSuccessors(workflow.definition, stuck.runId, step, stepOutput, ctx, taskCompleted ? undefined : reason, stuck.taskId);
+      const routing = await completeTaskStepAndResolveSuccessors(workflow.definition, stuck.runId, step, stepOutput, ctx, taskCompleted ? undefined : reason, stuck.taskId, registry);
       if (!routing.claimed)
         continue;
       if (routing.foreachChild && !routing.joined) {
@@ -20235,7 +20303,7 @@ async function recoverApprovalWaitingRuns(registry) {
           status: approvalStatus,
           responses: approval?.responses ?? null
         });
-        return await checkpointPortStepAndResolveSuccessors(workflow.definition, stuck.runId, stuck.stepId, stuck.nodeId, stepOutput, nextPort, ctx);
+        return await checkpointPortStepAndResolveSuccessors(workflow.definition, stuck.runId, stuck.stepId, stuck.nodeId, stepOutput, nextPort, ctx, registry);
       });
       if (!routing?.claimed)
         continue;
@@ -20274,6 +20342,42 @@ async function recoverWaitStates(registry) {
   }
   return recovered;
 }
+async function recoverForeachFanouts(registry) {
+  const rows = await getDbClient2().query(`SELECT s.runId AS runId, r.workflowId AS workflowId, s.id AS stepId, s.nodeId AS nodeId, s.status AS status
+       FROM workflow_run_steps s
+       JOIN workflow_runs r ON r.id = s.runId
+      WHERE r.status IN ('running', 'waiting')
+        AND s.status IN ('pending', 'running')
+        AND instr(s.nodeId, '#') > 1`);
+  const fanouts = new Map;
+  for (const row of rows) {
+    if (row.status === "running" && isForeachChildOwned(row.stepId))
+      continue;
+    const parentNodeId = row.nodeId.slice(0, row.nodeId.indexOf("#"));
+    fanouts.set(`${row.runId}\x00${parentNodeId}`, {
+      runId: row.runId,
+      workflowId: row.workflowId,
+      parentNodeId
+    });
+  }
+  let recovered = 0;
+  for (const fanout of fanouts.values()) {
+    try {
+      const workflow = await getWorkflow2(fanout.workflowId);
+      const parent = workflow?.definition.nodes.find((node) => node.id === fanout.parentNodeId);
+      if (parent?.type !== "foreach")
+        continue;
+      const drive = await runForeachDrive(fanout.runId, fanout.parentNodeId, registry);
+      if (drive.claimed > 0)
+        recovered++;
+    } catch (err) {
+      if (await failRunOnUnreadableReplay(fanout.runId, err))
+        continue;
+      console.error(`[workflows] Failed to re-drive foreach ${fanout.parentNodeId} of run ${fanout.runId}:`, err);
+    }
+  }
+  return recovered;
+}
 async function getRunIdsByStatus(status) {
   const rows = await getDbClient2().query("SELECT id FROM workflow_runs WHERE status = ?", [status]);
   return rows.map((r) => r.id);
@@ -20303,17 +20407,16 @@ function startRetryPoller(registry, intervalMs = 5000) {
           release = holdWorkflowRun(run.id);
           if (!await claimRetry(run.id, step.id))
             continue;
-          const ctx = run.context ?? {};
-          if (!("run" in ctx))
-            ctx.run = { id: run.id };
-          await rehydrateCompletedStepOutputs(workflow.definition, run.id, ctx, registry);
-          const inputCtx = buildNodeInterpolationCtx(node, ctx);
-          const { value: interpolatedValue, scriptBodyUnresolved } = interpolateNodeConfig(node, inputCtx);
+          const {
+            ctx,
+            inputCtx,
+            config: interpolatedConfig,
+            scriptBodyUnresolved
+          } = await rebuildNodeExecutionInput(workflow.definition, run, node, registry);
           if (scriptBodyUnresolved && scriptBodyUnresolved.length > 0) {
             await checkpointStepFailure(run.id, step.id, scriptBodyInterpolationError(node.id, scriptBodyUnresolved), step.retryCount);
             continue;
           }
-          const interpolatedConfig = interpolatedValue;
           const executor = registry.get(node.type);
           const meta = {
             runId: run.id,
@@ -20333,6 +20436,21 @@ function startRetryPoller(registry, intervalMs = 5000) {
             if (result.status === "failed") {
               const retryPolicy = node.retry || executor.retryPolicy;
               await checkpointStepFailure(run.id, step.id, result.error || "Retry failed", step.retryCount, retryPolicy);
+            } else if ("async" in result && result.async && result.waitFor === FOREACH_ITEMS_WAIT_FOR) {
+              const drive = await parkAndDriveForeach({
+                runId: run.id,
+                stepId: step.id,
+                parentNodeId: node.id,
+                ctx,
+                registry
+              });
+              if (!drive.joined)
+                continue;
+              if (drive.successors.length > 0) {
+                await walkGraph(workflow.definition, run.id, ctx, drive.successors, registry, workflow.id);
+              } else {
+                await completeRunIfSettled(run.id, ctx);
+              }
             } else if ("async" in result && result.async) {
               const waiting = await checkpointStepWaiting(run.id, step.id, ctx);
               if (!waiting)
@@ -20958,154 +21076,6 @@ class CodeMatchExecutor extends BaseExecutor {
   }
 }
 
-// src/workflows/executors/foreach.ts
-init_zod();
-init_template();
-var ForeachBodySchema = object2({
-  type: literal2("agent-task"),
-  config: record2(string2(), unknown())
-});
-var ForeachConfigSchema = object2({
-  over: array2(record2(string2(), unknown())),
-  itemKey: string2().min(1),
-  body: ForeachBodySchema,
-  concurrency: never().optional()
-});
-var ForeachResultSchema = object2({
-  itemKey: string2(),
-  status: _enum2(["completed", "failed", "cancelled", "skipped"]),
-  output: unknown().optional()
-});
-var ForeachOutputSchema = object2({
-  results: array2(ForeachResultSchema),
-  okCount: number2().int().nonnegative(),
-  failedCount: number2().int().nonnegative()
-});
-
-class ForeachExecutor extends BaseExecutor {
-  type = "foreach";
-  mode = "async";
-  configSchema = ForeachConfigSchema;
-  outputSchema = ForeachOutputSchema;
-  async execute(config, context, meta) {
-    if (config.over.length === 0) {
-      return {
-        status: "success",
-        output: { results: [], okCount: 0, failedCount: 0 }
-      };
-    }
-    const items = config.over.map((item, index) => {
-      const rawItemKey = item[config.itemKey];
-      if (typeof rawItemKey !== "string" || rawItemKey.length === 0) {
-        throw new Error(`foreach item at index ${index} is missing non-empty string itemKey property "${config.itemKey}"`);
-      }
-      return { item, index, itemKey: rawItemKey };
-    });
-    const seenItemKeys = new Set;
-    for (const { itemKey } of items) {
-      if (seenItemKeys.has(itemKey)) {
-        throw new Error(`foreach itemKey "${itemKey}" is duplicated`);
-      }
-      seenItemKeys.add(itemKey);
-    }
-    const agentTaskExecutor = new AgentTaskExecutor(this.deps);
-    const runSteps = await this.deps.db.getWorkflowRunStepsByRunId(meta.runId);
-    const childStepsByNodeId = new Map(runSteps.filter((step) => parseSyntheticNodeId(step.nodeId)?.parentNodeId === meta.nodeId).map((step) => [step.nodeId, step]));
-    const childCountToCreate = items.filter(({ itemKey }) => !childStepsByNodeId.has(`${meta.nodeId}#${itemKey}`)).length;
-    const maxSteps = getMaxWorkflowStepsPerRun();
-    const workflow = await this.deps.db.getWorkflow(meta.workflowId);
-    const hasSuccessors = workflow ? getSuccessors(workflow.definition, meta.nodeId).length > 0 : true;
-    const totalSteps = runSteps.length + childCountToCreate;
-    const capBreached = hasSuccessors ? totalSteps >= maxSteps : totalSteps > maxSteps;
-    if (childCountToCreate > 0 && capBreached) {
-      return {
-        status: "failed",
-        error: `foreach would reach ${maxSteps} total steps (WORKFLOW_MAX_STEPS_PER_RUN): ${runSteps.length} existing + ${childCountToCreate} children${hasSuccessors ? " leaves no room for the post-join walk" : " exceeds the per-run cap"}`
-      };
-    }
-    for (const { index, itemKey } of items) {
-      const childNodeId = `${meta.nodeId}#${itemKey}`;
-      if (childStepsByNodeId.has(childNodeId))
-        continue;
-      const childStepId = crypto.randomUUID();
-      const childStep = await this.deps.db.createWorkflowRunStep({
-        id: childStepId,
-        runId: meta.runId,
-        nodeId: childNodeId,
-        nodeType: "agent-task",
-        input: { itemKey, index }
-      });
-      await this.deps.db.updateWorkflowRunStep(childStepId, {
-        idempotencyKey: `${meta.runId}:${childNodeId}:0`
-      });
-      childStepsByNodeId.set(childNodeId, childStep);
-    }
-    for (const { item, index, itemKey } of items) {
-      const childNodeId = `${meta.nodeId}#${itemKey}`;
-      const childStep = childStepsByNodeId.get(childNodeId);
-      if (FOREACH_TERMINAL_STEP_STATUSES.has(childStep.status))
-        continue;
-      const bodyCtx = { ...meta.inputCtx ?? context, item, index };
-      const childInterpolation = deepInterpolate(config.body.config, bodyCtx);
-      if (childInterpolation.unresolved.length > 0) {
-        console.warn(`[workflow] Step ${childNodeId}: unresolved interpolation tokens: ${childInterpolation.unresolved.join(", ")}`);
-        await this.deps.db.updateWorkflowRunStep(childStep.id, {
-          diagnostics: JSON.stringify({ unresolvedTokens: childInterpolation.unresolved })
-        });
-      }
-      const linkedTask = await this.deps.db.getTaskByWorkflowRunStepId(childStep.id);
-      if (linkedTask?.status === "failed" || linkedTask?.status === "cancelled") {
-        await this.deps.db.detachTaskFromWorkflowRunStep(linkedTask.id);
-      }
-      const childResult = await agentTaskExecutor.run({
-        config: childInterpolation.value,
-        context,
-        meta: {
-          ...meta,
-          stepId: childStep.id,
-          nodeId: childNodeId
-        }
-      });
-      if (childResult.status !== "success") {
-        throw new Error(childResult.error ?? `foreach child "${itemKey}" failed to start`);
-      }
-      if ("async" in childResult) {
-        await this.deps.db.updateWorkflowRunStep(childStep.id, { status: "waiting" });
-      } else {
-        await this.deps.db.updateWorkflowRunStep(childStep.id, {
-          status: "completed",
-          output: normalizeExistingTaskOutput(childResult.output),
-          finishedAt: new Date().toISOString()
-        });
-      }
-    }
-    const childSteps = (await this.deps.db.getWorkflowRunStepsByRunId(meta.runId)).filter((step) => parseSyntheticNodeId(step.nodeId)?.parentNodeId === meta.nodeId);
-    if (childSteps.every((step) => FOREACH_TERMINAL_STEP_STATUSES.has(step.status))) {
-      return { status: "success", output: buildForeachAggregate(childSteps) };
-    }
-    return {
-      status: "success",
-      async: true,
-      waitFor: "task.completed",
-      correlationId: meta.stepId
-    };
-  }
-}
-function normalizeExistingTaskOutput(output) {
-  if (typeof output !== "object" || output === null)
-    return output;
-  const record = output;
-  if (typeof record.taskOutput !== "string")
-    return output;
-  try {
-    const parsed = JSON.parse(record.taskOutput);
-    if (typeof parsed === "object" && parsed !== null) {
-      return { ...record, taskOutput: parsed };
-    }
-  } catch {}
-  return output;
-}
-
 // src/workflows/executors/notify.ts
 init_zod();
 init_secret_scrubber();
@@ -21149,7 +21119,7 @@ class NotifyExecutor extends BaseExecutor {
         }
       }
       case "slack": {
-        const { getSlackApp } = await import("./app-rb7vc02s.js");
+        const { getSlackApp } = await import("./app-0qp0a2gk.js");
         const app = getSlackApp();
         if (!app) {
           return {
@@ -24512,7 +24482,7 @@ function setPreloadedTools(server, names) {
 async function applyPreToolCall(name, args, requestInfo, inputSchema) {
   if (requestInfo.callOrigin !== "mcp")
     return { args };
-  const dispatcher = await import("./dispatcher-x0jfw2c9.js");
+  const dispatcher = await import("./dispatcher-64bdyhps.js");
   const result = await dispatcher.dispatchPre("pre.tool.call", { tool: name, args, requestInfo }, inputSchema ? {
     validateModify: async (data) => {
       const schema = normalizeObjectSchema(inputSchema) ?? inputSchema;
@@ -25722,7 +25692,8 @@ var onChatMessageSent = chatMessageBridge("chat.message.sent", "outbound");
 var VCS_PROVIDERS = new Set([
   "github",
   "gitlab",
-  "azure-devops"
+  "azure-devops",
+  "bitbucket"
 ]);
 var VCS_KINDS = new Set([
   "pull_request",
@@ -28013,7 +27984,7 @@ async function handlePullRequestCommented(event) {
     return { created: false };
   }
   const requestedByUserId = await resolveAzureDevOpsSender(comment.author, "pull_request_comment", comment.content);
-  const existingTask = await findTaskByVcs2(repo, pr.pullRequestId);
+  const existingTask = await findTaskByVcs2(repo, pr.pullRequestId, "azure-devops");
   const existingTaskNote = existingTask ? `
 
 _Note: There's an active task (${existingTask.id}) for this PR #${pr.pullRequestId}._` : "";
@@ -29127,6 +29098,456 @@ async function syncTelemetryEnabled(via) {
   track({ event: "telemetry.enabled", properties: { via } });
   return true;
 }
+
+// src/bitbucket/api.ts
+init_secret_scrubber();
+
+// src/bitbucket/auth.ts
+init_env_flag();
+var initialized4 = false;
+var webhookSecret4 = null;
+var apiToken2 = null;
+function isBitbucketEnabled() {
+  return !!process.env.BITBUCKET_WEBHOOK_SECRET && !isEnvFlagEnabled("BITBUCKET_DISABLE", false);
+}
+function initBitbucket() {
+  if (initialized4)
+    return;
+  if (!isBitbucketEnabled()) {
+    console.log("[Bitbucket] Integration disabled (BITBUCKET_WEBHOOK_SECRET not set)");
+    return;
+  }
+  webhookSecret4 = process.env.BITBUCKET_WEBHOOK_SECRET;
+  apiToken2 = process.env.BITBUCKET_TOKEN ?? null;
+  initialized4 = true;
+  console.log(`[Bitbucket] Integration initialized (API token: ${apiToken2 ? "set" : "not set"})`);
+}
+function verifyBitbucketWebhook(rawBody, signatureHeader) {
+  if (!webhookSecret4)
+    return false;
+  if (!signatureHeader?.startsWith("sha256="))
+    return false;
+  return verifyHmacSignature(webhookSecret4, rawBody, signatureHeader);
+}
+function getBitbucketToken() {
+  return apiToken2;
+}
+function getBitbucketBotName() {
+  return process.env.BITBUCKET_BOT_NAME || "agent-swarm-bot";
+}
+function resetBitbucket() {
+  initialized4 = false;
+  webhookSecret4 = null;
+  apiToken2 = null;
+}
+
+// src/bitbucket/api.ts
+var BITBUCKET_API = "https://api.bitbucket.org/2.0";
+function headers3() {
+  const token = getBitbucketToken();
+  if (!token)
+    throw new Error("[Bitbucket] No API token configured");
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+}
+var cachedBotAccountId = null;
+async function resolveBitbucketBotAccountId() {
+  const fromEnv = process.env.BITBUCKET_BOT_ACCOUNT_ID?.trim();
+  if (fromEnv)
+    return fromEnv;
+  if (cachedBotAccountId)
+    return cachedBotAccountId;
+  if (!getBitbucketToken())
+    return null;
+  try {
+    const resp = await fetch(`${BITBUCKET_API}/user`, { headers: headers3(), redirect: "error" });
+    if (!resp.ok) {
+      console.error(`[Bitbucket] GET /user returned ${resp.status}`);
+      return null;
+    }
+    const data = await resp.json();
+    cachedBotAccountId = data.account_id?.trim() || null;
+    return cachedBotAccountId;
+  } catch (err) {
+    console.error(`[Bitbucket] Failed to resolve bot identity: ${scrubSecrets(String(err))}`);
+    return null;
+  }
+}
+function resetBitbucketBotCache() {
+  cachedBotAccountId = null;
+}
+// src/bitbucket/handlers.ts
+init_db3();
+init_users();
+init_resolver();
+init_context_key();
+
+// src/bitbucket/templates.ts
+init_registry();
+registerTemplate({
+  eventType: "common.delegation_instruction.bitbucket",
+  header: "",
+  defaultBody: "\n\n**Delegation instruction:** As the lead agent, analyze this and decide whether to handle it yourself or delegate to a worker agent. Use `send-task` to delegate with clear instructions.",
+  variables: [],
+  category: "common"
+});
+registerTemplate({
+  eventType: "common.command_suggestions.bitbucket_pr",
+  header: "",
+  defaultBody: 'Workers have `git` authenticated for bitbucket.org and `BITBUCKET_TOKEN` in env; there is no Bitbucket CLI, so use curl against `https://api.bitbucket.org/2.0/repositories/{{repo}}` with `-H "Authorization: Bearer $BITBUCKET_TOKEN"`. Inspect the PR with `GET .../pullrequests/{{pr_id}}` and its diff with `GET .../pullrequests/{{pr_id}}/diff`. Reply with `POST .../pullrequests/{{pr_id}}/comments` and JSON body `{"content":{"raw":"<reply>"}}`. Find a PR by branch with `GET .../pullrequests?q=source.branch.name="<branch>"`. Open a PR with `POST .../pullrequests` and JSON body `{"title":"<title>","source":{"branch":{"name":"<branch>"}},"destination":{"branch":{"name":"<base>"}}}`.',
+  variables: [
+    { name: "repo", description: "Repository full name (<workspace>/<repo_slug>)" },
+    { name: "pr_id", description: "Pull request ID" }
+  ],
+  category: "common"
+});
+var SHARED_VARIABLES2 = [
+  { name: "pr_id", description: "Pull request ID" },
+  { name: "pr_title", description: "Pull request title" },
+  { name: "repo", description: "Repository full name (<workspace>/<repo_slug>)" },
+  { name: "pr_url", description: "Pull request web URL" }
+];
+var PR_BRANCH_VARIABLES = [
+  { name: "source_branch", description: "Source branch name" },
+  { name: "target_branch", description: "Target branch name" },
+  { name: "context_section", description: "Context section with description or empty string" }
+];
+registerTemplate({
+  eventType: "bitbucket.pull_request.opened",
+  header: "[Bitbucket PR #{{pr_id}}] {{pr_title}}",
+  defaultBody: `Repo: {{repo}}
+Author: {{username}}
+Branch: {{source_branch}} → {{target_branch}}
+URL: {{pr_url}}
+
+{{context_section}}{{@template[common.command_suggestions.bitbucket_pr]}}{{@template[common.delegation_instruction.bitbucket]}}`,
+  variables: [
+    ...SHARED_VARIABLES2,
+    {
+      name: "username",
+      description: "Author identity — resolved canonical name (e.g. 'Luis (bitbucket:557058:…)') or the UNKNOWN sentinel"
+    },
+    ...PR_BRANCH_VARIABLES
+  ],
+  category: "event"
+});
+registerTemplate({
+  eventType: "bitbucket.pull_request.review_requested",
+  header: "[Bitbucket PR #{{pr_id}}] Review requested: {{pr_title}}",
+  defaultBody: `Repo: {{repo}}
+Author: {{username}}
+Branch: {{source_branch}} → {{target_branch}}
+URL: {{pr_url}}
+
+You were added as a reviewer on this pull request.
+
+{{context_section}}{{@template[common.command_suggestions.bitbucket_pr]}}{{@template[common.delegation_instruction.bitbucket]}}`,
+  variables: [
+    ...SHARED_VARIABLES2,
+    {
+      name: "username",
+      description: "Author identity — resolved canonical name (e.g. 'Luis (bitbucket:557058:…)') or the UNKNOWN sentinel"
+    },
+    ...PR_BRANCH_VARIABLES
+  ],
+  category: "event"
+});
+registerTemplate({
+  eventType: "bitbucket.comment.mentioned",
+  header: "[Bitbucket Comment on PR #{{pr_id}}] {{username}} mentioned bot",
+  defaultBody: `Repo: {{repo}}
+PR: {{pr_title}}
+URL: {{pr_url}}
+{{location_section}}
+Comment:
+{{context}}{{existing_task_note}}
+
+{{@template[common.command_suggestions.bitbucket_pr]}}{{@template[common.delegation_instruction.bitbucket]}}`,
+  variables: [
+    ...SHARED_VARIABLES2,
+    {
+      name: "username",
+      description: "Comment author identity — resolved canonical name (e.g. 'Luis (bitbucket:557058:…)') or the UNKNOWN sentinel"
+    },
+    {
+      name: "location_section",
+      description: "`File: <path>:<line>` line for inline comments, or empty string"
+    },
+    { name: "context", description: "Extracted mention context from comment" },
+    {
+      name: "existing_task_note",
+      description: "Note about existing active task, or empty string"
+    }
+  ],
+  category: "event"
+});
+
+// src/bitbucket/handlers.ts
+var DEDUP_TTL_MS2 = 60000;
+var processedEvents3 = new Map;
+var processedDeliveries = new Map;
+function sweep(cache, now) {
+  for (const [k, ts] of cache) {
+    if (now - ts > DEDUP_TTL_MS2)
+      cache.delete(k);
+  }
+}
+function isDuplicate3(key) {
+  const now = Date.now();
+  sweep(processedEvents3, now);
+  if (processedEvents3.has(key))
+    return true;
+  processedEvents3.set(key, now);
+  return false;
+}
+async function withDedupReservation(key, fn) {
+  if (isDuplicate3(key))
+    return null;
+  try {
+    return await fn();
+  } catch (err) {
+    processedEvents3.delete(key);
+    throw err;
+  }
+}
+function isDuplicateDelivery(requestUuid) {
+  if (!requestUuid)
+    return false;
+  sweep(processedDeliveries, Date.now());
+  return processedDeliveries.has(requestUuid);
+}
+function markDeliveryProcessed(requestUuid) {
+  if (requestUuid)
+    processedDeliveries.set(requestUuid, Date.now());
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function mentionPatterns2(botAccountId) {
+  const patterns = [new RegExp(`@${escapeRegExp2(getBitbucketBotName())}(?![\\w-])`, "gi")];
+  if (botAccountId)
+    patterns.push(new RegExp(`@\\{${escapeRegExp2(botAccountId)}\\}`, "gi"));
+  return patterns;
+}
+function detectMention2(text, botAccountId) {
+  if (!text)
+    return false;
+  return mentionPatterns2(botAccountId).some((re) => {
+    re.lastIndex = 0;
+    return re.test(text);
+  });
+}
+function extractMentionContext2(text, botAccountId) {
+  return mentionPatterns2(botAccountId).reduce((acc, re) => acc.replace(re, ""), text).trim();
+}
+function isBot2(account, botAccountId) {
+  return !!botAccountId && account?.account_id === botAccountId;
+}
+function pullRequestWebUrl2(repo, pr) {
+  return pr.links?.html?.href ?? `https://bitbucket.org/${repo}/pull-requests/${pr.id}`;
+}
+function contextKeyOf(event) {
+  return bitbucketContextKey({
+    repoUuid: event.repository.uuid,
+    pullRequestId: event.pullrequest.id
+  });
+}
+function pullRequestEventOf(body) {
+  const event = body;
+  const pr = event?.pullrequest;
+  const repo = event?.repository;
+  if (typeof pr?.id !== "number" || typeof pr.title !== "string" || typeof repo?.uuid !== "string" || typeof repo.full_name !== "string" || !event?.actor) {
+    return null;
+  }
+  return event;
+}
+function pullRequestCommentEventOf(body) {
+  const event = pullRequestEventOf(body);
+  const comment = event?.comment;
+  if (!event || typeof comment?.id !== "number" || typeof comment.content?.raw !== "string") {
+    return null;
+  }
+  return event;
+}
+function warnMalformed2(eventKey) {
+  console.warn(`[Bitbucket] Ignoring ${eventKey} event: required payload fields are missing`);
+}
+async function findLeadAgent3() {
+  const agents = await getAllAgents2();
+  return agents.find((a) => a.role === "lead" && a.status === "idle") ?? agents.find((a) => a.role === "lead") ?? null;
+}
+var UNMAPPED_NAMESPACE2 = "integration:unmapped:bitbucket";
+var UNMAPPED_TTL_MS2 = 30 * 24 * 60 * 60 * 1000;
+function externalIdOf2(account) {
+  return account?.account_id?.trim() || account?.uuid?.trim() || null;
+}
+async function resolveBitbucketSender(account, sampleEventType, sampleContext) {
+  const externalId = externalIdOf2(account);
+  if (!externalId)
+    return;
+  const existing = await findUserByExternalId("bitbucket", externalId);
+  if (existing)
+    return existing.id;
+  await upsertKv2({
+    namespace: UNMAPPED_NAMESPACE2,
+    key: `${externalId}:meta`,
+    value: {
+      lastSeenAt: new Date().toISOString(),
+      displayName: account?.display_name,
+      sampleEventType,
+      sampleContext: sampleContext.slice(0, 100)
+    },
+    valueType: "json",
+    expiresAt: Date.now() + UNMAPPED_TTL_MS2
+  });
+  await incrKv2(UNMAPPED_NAMESPACE2, `${externalId}:count`, 1);
+  return;
+}
+async function renderBitbucketIdentity(account) {
+  return renderIdentity(await resolveIdentity("bitbucket", externalIdOf2(account) ?? ""));
+}
+async function createBitbucketTask(text, event, fields) {
+  const { pullrequest: pr, repository } = event;
+  const lead = await findLeadAgent3();
+  const task = await createTaskWithSiblingAwareness(text, {
+    agentId: lead?.id ?? null,
+    routingReason: lead ? "skill" : undefined,
+    routingSource: lead ? "engine_default" : undefined,
+    source: "bitbucket",
+    vcsProvider: "bitbucket",
+    taskType: fields.taskType,
+    vcsRepo: repository.full_name,
+    vcsEventType: fields.vcsEventType,
+    vcsNumber: pr.id,
+    vcsCommentId: fields.vcsCommentId,
+    vcsAuthor: externalIdOf2(fields.author) ?? undefined,
+    requestedByUserId: fields.requestedByUserId,
+    vcsUrl: pullRequestWebUrl2(repository.full_name, pr),
+    parentTaskId: fields.parentTaskId,
+    contextKey: contextKeyOf(event)
+  }, { origin: "webhook" });
+  return { created: true, taskId: task.id };
+}
+async function handlePullRequestCreated2(body) {
+  const event = pullRequestEventOf(body);
+  if (!event) {
+    warnMalformed2("pullrequest:created");
+    return { created: false };
+  }
+  const { pullrequest: pr, repository } = event;
+  const repo = repository.full_name;
+  const author = pr.author ?? event.actor;
+  console.log(`[Bitbucket] PR #${pr.id} created by ${author.display_name} in ${repo}`);
+  const botAccountId = await resolveBitbucketBotAccountId();
+  if (isBot2(author, botAccountId)) {
+    console.log(`[Bitbucket] PR opened by the bot itself, skipping`);
+    return { created: false };
+  }
+  const mentioned = detectMention2(pr.description, botAccountId);
+  const reviewRequested = !!botAccountId && (pr.reviewers ?? []).some((r) => r.account_id === botAccountId);
+  if (!mentioned && !reviewRequested) {
+    console.log(`[Bitbucket] PR opened without bot mention or review request, skipping`);
+    return { created: false };
+  }
+  const dedupKey = `bitbucket-pr-${repository.uuid}-${pr.id}-created`;
+  const outcome = await withDedupReservation(dedupKey, async () => {
+    const requestedByUserId = await resolveBitbucketSender(author, "pull_request", `PR #${pr.id}: ${pr.title}`);
+    const context = pr.description ? extractMentionContext2(pr.description, botAccountId) : "";
+    const templateId = mentioned ? "bitbucket.pull_request.opened" : "bitbucket.pull_request.review_requested";
+    const result = resolveTemplate(templateId, {
+      pr_id: pr.id,
+      pr_title: pr.title,
+      repo,
+      username: await renderBitbucketIdentity(author),
+      source_branch: pr.source?.branch?.name ?? "",
+      target_branch: pr.destination?.branch?.name ?? "",
+      pr_url: pullRequestWebUrl2(repo, pr),
+      context_section: context ? `Context: ${context}
+
+` : ""
+    });
+    if (result.skipped) {
+      return { created: false };
+    }
+    return createBitbucketTask(result.text, event, {
+      taskType: "bitbucket-pr",
+      vcsEventType: "pull_request",
+      author,
+      requestedByUserId
+    });
+  });
+  if (!outcome)
+    console.log(`[Bitbucket] Skipping duplicate PR event`);
+  return outcome ?? { created: false };
+}
+async function handlePullRequestCommentCreated(body) {
+  const event = pullRequestCommentEventOf(body);
+  if (!event) {
+    warnMalformed2("pullrequest:comment_created");
+    return { created: false };
+  }
+  const { pullrequest: pr, repository, comment } = event;
+  const repo = repository.full_name;
+  const author = comment.user ?? event.actor;
+  const botAccountId = await resolveBitbucketBotAccountId();
+  if (isBot2(author, botAccountId)) {
+    return { created: false };
+  }
+  if (!detectMention2(comment.content.raw, botAccountId)) {
+    return { created: false };
+  }
+  console.log(`[Bitbucket] Comment by ${author.display_name} on PR #${pr.id} in ${repo}`);
+  const dedupKey = `bitbucket-comment-${repository.uuid}-${pr.id}-${comment.id}`;
+  const outcome = await withDedupReservation(dedupKey, async () => {
+    const requestedByUserId = await resolveBitbucketSender(author, "pull_request_comment", comment.content.raw);
+    const existingTask = await findTaskByVcs2(repo, pr.id, "bitbucket");
+    const existingTaskNote = existingTask ? `
+
+_Note: There's an active task (${existingTask.id}) for this PR #${pr.id}._` : "";
+    const line = comment.inline?.to ?? comment.inline?.from;
+    const locationSection = comment.inline ? `File: ${comment.inline.path}${line != null ? `:${line}` : ""}
+` : "";
+    const result = resolveTemplate("bitbucket.comment.mentioned", {
+      pr_id: pr.id,
+      pr_title: pr.title,
+      username: await renderBitbucketIdentity(author),
+      repo,
+      pr_url: comment.links?.html?.href ?? pullRequestWebUrl2(repo, pr),
+      location_section: locationSection,
+      context: extractMentionContext2(comment.content.raw, botAccountId),
+      existing_task_note: existingTaskNote
+    });
+    if (result.skipped) {
+      return { created: false };
+    }
+    return createBitbucketTask(result.text, event, {
+      taskType: "bitbucket-comment",
+      vcsEventType: "pull_request_comment",
+      author,
+      requestedByUserId,
+      vcsCommentId: comment.id,
+      parentTaskId: existingTask?.id
+    });
+  });
+  return outcome ?? { created: false };
+}
+async function handlePullRequestClosed(body, outcome) {
+  const event = pullRequestEventOf(body);
+  if (!event) {
+    warnMalformed2(outcome === "merged" ? "pullrequest:fulfilled" : "pullrequest:rejected");
+    return { created: false };
+  }
+  const { pullrequest: pr, repository } = event;
+  const reason = outcome === "merged" ? "PR was merged" : "PR was declined";
+  for (const task of await findActiveTasksByVcs2(repository.full_name, pr.id, "bitbucket")) {
+    console.log(`[Bitbucket] Cancelling task ${task.id} — ${reason}`);
+    await failTask2(task.id, reason);
+  }
+  return { created: false };
+}
 // src/github/handlers.ts
 init_db3();
 init_users();
@@ -29151,12 +29572,12 @@ function computeMentionPattern(names) {
 }
 var BOT_NAMES = computeBotNames();
 var MENTION_PATTERN = computeMentionPattern(BOT_NAMES);
-function detectMention2(text) {
+function detectMention3(text) {
   if (!text)
     return false;
   return MENTION_PATTERN.test(text);
 }
-function extractMentionContext2(text) {
+function extractMentionContext3(text) {
   if (!text)
     return "";
   return text.replace(MENTION_PATTERN, "").trim();
@@ -29599,7 +30020,7 @@ Related task: {{related_task_id}}
 });
 
 // src/github/handlers.ts
-var processedEvents3 = new Map;
+var processedEvents4 = new Map;
 var EVENT_TTL2 = 60000;
 function buildGithubContextKey(fullName, kind, number) {
   const [owner, repo] = fullName.split("/");
@@ -29643,34 +30064,34 @@ function getCommandSuggestions(taskType, targetType) {
       return "";
   }
 }
-function isDuplicate3(eventKey) {
+function isDuplicate4(eventKey) {
   const now = Date.now();
-  for (const [key, timestamp] of processedEvents3) {
+  for (const [key, timestamp] of processedEvents4) {
     if (now - timestamp > EVENT_TTL2) {
-      processedEvents3.delete(key);
+      processedEvents4.delete(key);
     }
   }
-  if (processedEvents3.has(eventKey)) {
+  if (processedEvents4.has(eventKey)) {
     return true;
   }
-  processedEvents3.set(eventKey, now);
+  processedEvents4.set(eventKey, now);
   return false;
 }
-async function findLeadAgent3() {
+async function findLeadAgent4() {
   const agents = await getAllAgents2();
   const onlineLead = agents.find((a) => a.isLead && a.status !== "offline");
   if (onlineLead)
     return onlineLead;
   return agents.find((a) => a.isLead) ?? null;
 }
-var UNMAPPED_NAMESPACE2 = "integration:unmapped:github";
-var UNMAPPED_TTL_MS2 = 30 * 24 * 60 * 60 * 1000;
+var UNMAPPED_NAMESPACE3 = "integration:unmapped:github";
+var UNMAPPED_TTL_MS3 = 30 * 24 * 60 * 60 * 1000;
 async function resolveGitHubSender(login, sampleEventType, sampleContext) {
   const existing = await findUserByExternalId("github", login);
   if (existing)
     return existing.id;
   await upsertKv2({
-    namespace: UNMAPPED_NAMESPACE2,
+    namespace: UNMAPPED_NAMESPACE3,
     key: `${login}:meta`,
     value: {
       lastSeenAt: new Date().toISOString(),
@@ -29678,9 +30099,9 @@ async function resolveGitHubSender(login, sampleEventType, sampleContext) {
       sampleContext: sampleContext.slice(0, 100)
     },
     valueType: "json",
-    expiresAt: Date.now() + UNMAPPED_TTL_MS2
+    expiresAt: Date.now() + UNMAPPED_TTL_MS3
   });
-  await incrKv2(UNMAPPED_NAMESPACE2, `${login}:count`, 1);
+  await incrKv2(UNMAPPED_NAMESPACE3, `${login}:count`, 1);
   return;
 }
 async function handlePullRequest(event) {
@@ -29699,10 +30120,10 @@ async function handlePullRequest(event) {
       return { created: false };
     }
     const eventKey = `pr-assigned:${repository.full_name}:${pr.number}`;
-    if (isDuplicate3(eventKey)) {
+    if (isDuplicate4(eventKey)) {
       return { created: false };
     }
-    const lead = await findLeadAgent3();
+    const lead = await findLeadAgent4();
     const result = resolveTemplate("github.pull_request.assigned", {
       pr_number: pr.number,
       pr_title: pr.title,
@@ -29749,7 +30170,7 @@ async function handlePullRequest(event) {
       console.log(`[GitHub] unassign cancel disabled by config — leaving task untouched (PR #${pr.number})`);
       return { created: false };
     }
-    const task = await findTaskByVcs2(repository.full_name, pr.number);
+    const task = await findTaskByVcs2(repository.full_name, pr.number, "github");
     if (!task) {
       console.log(`[GitHub] No active task found for PR #${pr.number} to cancel`);
       return { created: false };
@@ -29766,15 +30187,15 @@ async function handlePullRequest(event) {
       return { created: false };
     }
     const eventKey = `pr-review-requested:${repository.full_name}:${pr.number}`;
-    if (isDuplicate3(eventKey)) {
+    if (isDuplicate4(eventKey)) {
       return { created: false };
     }
-    const existingTask = await findTaskByVcs2(repository.full_name, pr.number);
+    const existingTask = await findTaskByVcs2(repository.full_name, pr.number, "github");
     if (existingTask) {
       console.log(`[GitHub] Skipping review task for PR #${pr.number} — active task ${existingTask.id} already exists`);
       return { created: false };
     }
-    const lead = await findLeadAgent3();
+    const lead = await findLeadAgent4();
     const result = resolveTemplate("github.pull_request.review_requested", {
       pr_number: pr.number,
       pr_title: pr.title,
@@ -29821,7 +30242,7 @@ async function handlePullRequest(event) {
       console.log(`[GitHub] review-request-removed cancel disabled by config — leaving task untouched (PR #${pr.number})`);
       return { created: false };
     }
-    const task = await findTaskByVcs2(repository.full_name, pr.number);
+    const task = await findTaskByVcs2(repository.full_name, pr.number, "github");
     if (!task) {
       console.log(`[GitHub] No active task found for PR #${pr.number} to cancel`);
       return { created: false };
@@ -29839,10 +30260,10 @@ async function handlePullRequest(event) {
       return { created: false };
     }
     const eventKey = `pr-labeled:${repository.full_name}:${pr.number}:${labelName}`;
-    if (isDuplicate3(eventKey)) {
+    if (isDuplicate4(eventKey)) {
       return { created: false };
     }
-    const lead = await findLeadAgent3();
+    const lead = await findLeadAgent4();
     const result = resolveTemplate("github.pull_request.labeled", {
       pr_number: pr.number,
       pr_title: pr.title,
@@ -29892,16 +30313,16 @@ async function handlePullRequest(event) {
   if (action !== "opened" && action !== "edited") {
     return { created: false };
   }
-  const hasMention = detectMention2(pr.title) || detectMention2(pr.body);
+  const hasMention = detectMention3(pr.title) || detectMention3(pr.body);
   if (!hasMention) {
     return { created: false };
   }
   const eventKey = `pr:${repository.full_name}:${pr.number}:${action}`;
-  if (isDuplicate3(eventKey)) {
+  if (isDuplicate4(eventKey)) {
     return { created: false };
   }
-  const lead = await findLeadAgent3();
-  const context = extractMentionContext2(pr.body) || pr.title;
+  const lead = await findLeadAgent4();
+  const context = extractMentionContext3(pr.body) || pr.title;
   const result = resolveTemplate("github.pull_request.mentioned", {
     pr_number: pr.number,
     pr_title: pr.title,
@@ -29947,10 +30368,10 @@ async function handleIssue(event) {
       return { created: false };
     }
     const eventKey = `issue-assigned:${repository.full_name}:${issue.number}`;
-    if (isDuplicate3(eventKey)) {
+    if (isDuplicate4(eventKey)) {
       return { created: false };
     }
-    const lead = await findLeadAgent3();
+    const lead = await findLeadAgent4();
     const result = resolveTemplate("github.issue.assigned", {
       issue_number: issue.number,
       issue_title: issue.title,
@@ -29995,7 +30416,7 @@ async function handleIssue(event) {
       console.log(`[GitHub] unassign cancel disabled by config — leaving task untouched (issue #${issue.number})`);
       return { created: false };
     }
-    const task = await findTaskByVcs2(repository.full_name, issue.number);
+    const task = await findTaskByVcs2(repository.full_name, issue.number, "github");
     if (!task) {
       console.log(`[GitHub] No active task found for issue #${issue.number} to cancel`);
       return { created: false };
@@ -30013,10 +30434,10 @@ async function handleIssue(event) {
       return { created: false };
     }
     const eventKey = `issue-labeled:${repository.full_name}:${issue.number}:${labelName}`;
-    if (isDuplicate3(eventKey)) {
+    if (isDuplicate4(eventKey)) {
       return { created: false };
     }
-    const lead = await findLeadAgent3();
+    const lead = await findLeadAgent4();
     const result = resolveTemplate("github.issue.labeled", {
       issue_number: issue.number,
       issue_title: issue.title,
@@ -30056,16 +30477,16 @@ async function handleIssue(event) {
   if (action !== "opened" && action !== "edited") {
     return { created: false };
   }
-  const hasMention = detectMention2(issue.title) || detectMention2(issue.body);
+  const hasMention = detectMention3(issue.title) || detectMention3(issue.body);
   if (!hasMention) {
     return { created: false };
   }
   const eventKey = `issue:${repository.full_name}:${issue.number}:${action}`;
-  if (isDuplicate3(eventKey)) {
+  if (isDuplicate4(eventKey)) {
     return { created: false };
   }
-  const lead = await findLeadAgent3();
-  const context = extractMentionContext2(issue.body) || issue.title;
+  const lead = await findLeadAgent4();
+  const context = extractMentionContext3(issue.body) || issue.title;
   const result = resolveTemplate("github.issue.mentioned", {
     issue_number: issue.number,
     issue_title: issue.title,
@@ -30111,21 +30532,21 @@ async function handleComment(event, eventType) {
   if (action !== "created") {
     return skip("action is not created");
   }
-  if (!detectMention2(comment.body)) {
+  if (!detectMention3(comment.body)) {
     return skip("no bot mention");
   }
   const eventKey = `comment:${repository.full_name}:${comment.id}`;
-  if (isDuplicate3(eventKey)) {
+  if (isDuplicate4(eventKey)) {
     return skip("duplicate delivery");
   }
-  const lead = await findLeadAgent3();
+  const lead = await findLeadAgent4();
   const target = pull_request || issue;
   const targetType = pull_request ? "PR" : "Issue";
   const targetNumber = target?.number ?? 0;
   const targetTitle = target?.title ?? "Unknown";
   const targetUrl = target?.html_url ?? comment.html_url;
-  const existingTask = targetNumber ? await findTaskByVcs2(repository.full_name, targetNumber) : null;
-  const context = extractMentionContext2(comment.body);
+  const existingTask = targetNumber ? await findTaskByVcs2(repository.full_name, targetNumber, "github") : null;
+  const context = extractMentionContext3(comment.body);
   const suggestions = getCommandSuggestions("github-comment", targetType);
   const relatedTaskSection = existingTask ? `Related task: ${existingTask.id}
 \uD83D\uDD00 Consider routing to the same agent working on the related task.
@@ -30359,7 +30780,7 @@ async function handlePullRequestReview(event) {
     return { created: false };
   }
   const eventKey = `pr-review:${repository.full_name}:${pr.number}:${review.id}`;
-  if (isDuplicate3(eventKey)) {
+  if (isDuplicate4(eventKey)) {
     return { created: false };
   }
   const { comments: inlineComments, degraded } = await fetchReviewComments(repository.full_name, pr.number, review.id, installation?.id);
@@ -30374,12 +30795,12 @@ async function handlePullRequestReview(event) {
       return { created: false };
     }
   }
-  const existingTask = await findTaskByVcs2(repository.full_name, pr.number);
+  const existingTask = await findTaskByVcs2(repository.full_name, pr.number, "github");
   const isBotCreator = isBotAssignee(pr.user.login);
   if (!isBotCreator && !existingTask) {
     return { created: false };
   }
-  const lead = await findLeadAgent3();
+  const lead = await findLeadAgent4();
   const { emoji, label } = getReviewStateInfo(review.state);
   const reviewBodySection = review.body ? `
 
@@ -30456,46 +30877,46 @@ async function handleWorkflowRun(event) {
 }
 // src/gitlab/auth.ts
 init_env_flag();
-var initialized4 = false;
-var webhookSecret4 = null;
-var apiToken2 = null;
+var initialized5 = false;
+var webhookSecret5 = null;
+var apiToken3 = null;
 var gitlabUrl = "https://gitlab.com";
 function isGitLabEnabled() {
   return !!process.env.GITLAB_WEBHOOK_SECRET && !isEnvFlagEnabled("GITLAB_DISABLE", false);
 }
 function initGitLab() {
-  if (initialized4)
+  if (initialized5)
     return;
   if (!isGitLabEnabled()) {
     console.log("[GitLab] Integration disabled (GITLAB_WEBHOOK_SECRET not set)");
     return;
   }
-  webhookSecret4 = process.env.GITLAB_WEBHOOK_SECRET;
-  apiToken2 = process.env.GITLAB_TOKEN ?? null;
+  webhookSecret5 = process.env.GITLAB_WEBHOOK_SECRET;
+  apiToken3 = process.env.GITLAB_TOKEN ?? null;
   gitlabUrl = process.env.GITLAB_URL ?? "https://gitlab.com";
-  initialized4 = true;
+  initialized5 = true;
   console.log(`[GitLab] Integration initialized (url: ${gitlabUrl})`);
 }
 function verifyGitLabWebhook(tokenHeader) {
-  if (!webhookSecret4)
+  if (!webhookSecret5)
     return false;
   if (!tokenHeader)
     return false;
-  if (tokenHeader.length !== webhookSecret4.length)
+  if (tokenHeader.length !== webhookSecret5.length)
     return false;
-  return crypto.timingSafeEqual(Buffer.from(tokenHeader), Buffer.from(webhookSecret4));
+  return crypto.timingSafeEqual(Buffer.from(tokenHeader), Buffer.from(webhookSecret5));
 }
 function getGitLabToken() {
-  return apiToken2;
+  return apiToken3;
 }
 function getGitLabUrl() {
   return gitlabUrl;
 }
 var GITLAB_BOT_NAME = process.env.GITLAB_BOT_NAME ?? "agent-swarm-bot";
 function resetGitLab() {
-  initialized4 = false;
-  webhookSecret4 = null;
-  apiToken2 = null;
+  initialized5 = false;
+  webhookSecret5 = null;
+  apiToken3 = null;
   gitlabUrl = "https://gitlab.com";
 }
 // src/gitlab/handlers.ts
@@ -30505,7 +30926,7 @@ init_resolver();
 init_context_key();
 
 // src/gitlab/reactions.ts
-function headers3() {
+function headers4() {
   const token = getGitLabToken();
   if (!token)
     throw new Error("[GitLab] No API token configured");
@@ -30526,7 +30947,7 @@ async function addGitLabReaction(project, entityType, iid, emojiName) {
   try {
     const resp = await fetch(url, {
       method: "POST",
-      headers: headers3(),
+      headers: headers4(),
       body: JSON.stringify({ name: emojiName })
     });
     if (!resp.ok) {
@@ -30542,7 +30963,7 @@ async function addGitLabNoteReaction(project, entityType, iid, noteId, emojiName
   try {
     const resp = await fetch(url, {
       method: "POST",
-      headers: headers3(),
+      headers: headers4(),
       body: JSON.stringify({ name: emojiName })
     });
     if (!resp.ok) {
@@ -30666,33 +31087,33 @@ The CI pipeline has failed. Please investigate and fix the issues.{{@template[co
 });
 
 // src/gitlab/handlers.ts
-var processedEvents4 = new Map;
-var DEDUP_TTL_MS2 = 60000;
-function isDuplicate4(key) {
+var processedEvents5 = new Map;
+var DEDUP_TTL_MS3 = 60000;
+function isDuplicate5(key) {
   const now = Date.now();
-  for (const [k, ts] of processedEvents4) {
-    if (now - ts > DEDUP_TTL_MS2)
-      processedEvents4.delete(k);
+  for (const [k, ts] of processedEvents5) {
+    if (now - ts > DEDUP_TTL_MS3)
+      processedEvents5.delete(k);
   }
-  if (processedEvents4.has(key))
+  if (processedEvents5.has(key))
     return true;
-  processedEvents4.set(key, now);
+  processedEvents5.set(key, now);
   return false;
 }
-function detectMention3(text) {
+function detectMention4(text) {
   if (!text)
     return false;
   return new RegExp(`@${GITLAB_BOT_NAME}\\b`, "i").test(text);
 }
-function extractMentionContext3(text) {
+function extractMentionContext4(text) {
   return text.replace(new RegExp(`@${GITLAB_BOT_NAME}\\b`, "gi"), "").trim();
 }
-async function findLeadAgent4() {
+async function findLeadAgent5() {
   const agents = await getAllAgents2();
   return agents.find((a) => a.role === "lead" && a.status === "idle") ?? agents.find((a) => a.role === "lead") ?? null;
 }
-var UNMAPPED_NAMESPACE3 = "integration:unmapped:gitlab";
-var UNMAPPED_TTL_MS3 = 30 * 24 * 60 * 60 * 1000;
+var UNMAPPED_NAMESPACE4 = "integration:unmapped:gitlab";
+var UNMAPPED_TTL_MS4 = 30 * 24 * 60 * 60 * 1000;
 var GITLAB_WEBHOOK_ACTOR = { kind: "system", id: "webhook:gitlab" };
 async function resolveGitLabSender(user, sampleEventType, sampleContext) {
   const existing = await findUserByExternalId("gitlab", user.username);
@@ -30705,7 +31126,7 @@ async function resolveGitLabSender(user, sampleEventType, sampleContext) {
     return linked.id;
   }
   await upsertKv2({
-    namespace: UNMAPPED_NAMESPACE3,
+    namespace: UNMAPPED_NAMESPACE4,
     key: `${user.username}:meta`,
     value: {
       lastSeenAt: new Date().toISOString(),
@@ -30713,9 +31134,9 @@ async function resolveGitLabSender(user, sampleEventType, sampleContext) {
       sampleContext: sampleContext.slice(0, 100)
     },
     valueType: "json",
-    expiresAt: Date.now() + UNMAPPED_TTL_MS3
+    expiresAt: Date.now() + UNMAPPED_TTL_MS4
   });
-  await incrKv2(UNMAPPED_NAMESPACE3, `${user.username}:count`, 1);
+  await incrKv2(UNMAPPED_NAMESPACE4, `${user.username}:count`, 1);
   return;
 }
 async function renderGitLabIdentity(username) {
@@ -30728,19 +31149,19 @@ async function handleMergeRequest(event) {
   const requestedByUserId = await resolveGitLabSender(user, "merge_request", `MR !${mr.iid}: ${mr.title}`);
   console.log(`[GitLab] MR #${mr.iid} ${action} by ${user.username} in ${repo}`);
   const dedupKey = `gitlab-mr-${repo}-${mr.iid}-${action}-${user.username}`;
-  if (isDuplicate4(dedupKey)) {
+  if (isDuplicate5(dedupKey)) {
     console.log(`[GitLab] Skipping duplicate MR event`);
     return { created: false };
   }
-  const lead = await findLeadAgent4();
+  const lead = await findLeadAgent5();
   switch (action) {
     case "open": {
-      const hasMention = detectMention3(mr.description);
+      const hasMention = detectMention4(mr.description);
       if (!hasMention) {
         console.log(`[GitLab] MR opened without bot mention, skipping`);
         return { created: false };
       }
-      const context = mr.description ? extractMentionContext3(mr.description) : "";
+      const context = mr.description ? extractMentionContext4(mr.description) : "";
       const contextSection = context ? `Context: ${context}
 
 ` : "";
@@ -30784,7 +31205,7 @@ async function handleMergeRequest(event) {
     }
     case "close":
     case "merge": {
-      const existingTask = await findTaskByVcs2(repo, mr.iid);
+      const existingTask = await findTaskByVcs2(repo, mr.iid, "gitlab");
       if (existingTask) {
         const reason = action === "merge" ? "MR was merged" : "MR was closed";
         console.log(`[GitLab] Cancelling task ${existingTask.id} — ${reason}`);
@@ -30793,7 +31214,7 @@ async function handleMergeRequest(event) {
       return { created: false };
     }
     case "update": {
-      const task = await findTaskByVcs2(repo, mr.iid);
+      const task = await findTaskByVcs2(repo, mr.iid, "gitlab");
       if (task) {
         console.log(`[GitLab] MR #${mr.iid} updated, active task exists: ${task.id}`);
         return { created: false };
@@ -30812,13 +31233,13 @@ async function handleIssue2(event) {
   const requestedByUserId = await resolveGitLabSender(user, "issue", `Issue #${issue.iid}: ${issue.title}`);
   console.log(`[GitLab] Issue #${issue.iid} ${action} by ${user.username} in ${repo}`);
   const dedupKey = `gitlab-issue-${repo}-${issue.iid}-${action}-${user.username}`;
-  if (isDuplicate4(dedupKey)) {
+  if (isDuplicate5(dedupKey)) {
     return { created: false };
   }
-  const lead = await findLeadAgent4();
+  const lead = await findLeadAgent5();
   switch (action) {
     case "open": {
-      const hasMention = detectMention3(issue.description);
+      const hasMention = detectMention4(issue.description);
       if (!hasMention) {
         const isBotAssigned = event.assignees?.some((a) => a.username.toLowerCase() === GITLAB_BOT_NAME.toLowerCase());
         if (!isBotAssigned) {
@@ -30826,7 +31247,7 @@ async function handleIssue2(event) {
           return { created: false };
         }
       }
-      const context = issue.description ? extractMentionContext3(issue.description) : "";
+      const context = issue.description ? extractMentionContext4(issue.description) : "";
       const contextSection = context ? `Context: ${context}
 
 ` : "";
@@ -30867,7 +31288,7 @@ async function handleIssue2(event) {
       return { created: true, taskId: task.id };
     }
     case "close": {
-      const existingTask = await findTaskByVcs2(repo, issue.iid);
+      const existingTask = await findTaskByVcs2(repo, issue.iid, "gitlab");
       if (existingTask) {
         console.log(`[GitLab] Cancelling task ${existingTask.id} — issue closed`);
         await failTask2(existingTask.id, "Issue was closed");
@@ -30882,16 +31303,16 @@ async function handleNote(event) {
   const { user, project, object_attributes: note } = event;
   const repo = project.path_with_namespace;
   const requestedByUserId = await resolveGitLabSender(user, "note", note.note);
-  if (!detectMention3(note.note)) {
+  if (!detectMention4(note.note)) {
     return { created: false };
   }
   console.log(`[GitLab] Note by ${user.username} in ${repo} (${note.noteable_type})`);
   const dedupKey = `gitlab-note-${note.id}`;
-  if (isDuplicate4(dedupKey)) {
+  if (isDuplicate5(dedupKey)) {
     return { created: false };
   }
-  const lead = await findLeadAgent4();
-  const context = extractMentionContext3(note.note);
+  const lead = await findLeadAgent5();
+  const context = extractMentionContext4(note.note);
   let targetNumber;
   let targetUrl;
   let eventType;
@@ -30910,7 +31331,7 @@ async function handleNote(event) {
     console.log(`[GitLab] Ignoring note on ${note.noteable_type}`);
     return { created: false };
   }
-  const existingTask = targetNumber ? await findTaskByVcs2(repo, targetNumber) : null;
+  const existingTask = targetNumber ? await findTaskByVcs2(repo, targetNumber, "gitlab") : null;
   const existingTaskNote = existingTask ? `
 
 _Note: There's an active task (${existingTask.id}) for this ${entityLabel}._` : "";
@@ -30965,14 +31386,14 @@ async function handlePipeline(event) {
   }
   const mrIid = event.merge_request.iid;
   const dedupKey = `gitlab-pipeline-${pipeline.id}`;
-  if (isDuplicate4(dedupKey)) {
+  if (isDuplicate5(dedupKey)) {
     return { created: false };
   }
-  const existingTask = await findTaskByVcs2(repo, mrIid);
+  const existingTask = await findTaskByVcs2(repo, mrIid, "gitlab");
   if (!existingTask) {
     return { created: false };
   }
-  const lead = await findLeadAgent4();
+  const lead = await findLeadAgent5();
   const pipelineResult = resolveTemplate("gitlab.pipeline.failed", {
     pipeline_id: pipeline.id,
     mr_iid: mrIid,
@@ -31176,6 +31597,71 @@ function readApiUrlOverrides() {
   }
 }
 
+// src/integrations/chat-sdk/facts.ts
+var SNIPPET_MAX = 80;
+function snippet2(text) {
+  const flat = text?.replace(/\s+/g, " ").trim();
+  if (!flat)
+    return;
+  return flat.length > SNIPPET_MAX ? `${flat.slice(0, SNIPPET_MAX)}...` : flat;
+}
+function personLabel(name, username, fallback) {
+  if (name && username && name !== username)
+    return `${name} (@${username})`;
+  if (username)
+    return `@${username}`;
+  return name || fallback;
+}
+function replyIsTopicRoot(raw) {
+  const reply = raw.reply_to_message;
+  return reply !== undefined && (reply.forum_topic_created !== undefined || raw.is_topic_message === true && reply.message_id === raw.message_thread_id);
+}
+function isTelegramReplyToBot(raw, botUserId) {
+  const fromId = raw.reply_to_message?.from?.id;
+  return !replyIsTopicRoot(raw) && fromId !== undefined && botUserId !== undefined && String(fromId) === botUserId;
+}
+function telegramFacts(raw, message, botUserId) {
+  const reply = raw.reply_to_message;
+  const topicRoot = replyIsTopicRoot(raw);
+  const realReply = reply && !topicRoot ? reply : undefined;
+  const topicName = topicRoot ? reply?.forum_topic_created?.name : undefined;
+  const name = [raw.from?.first_name, raw.from?.last_name].filter(Boolean).join(" ").trim();
+  return {
+    chatType: raw.chat?.type,
+    isForum: raw.chat?.is_forum === true ? true : undefined,
+    title: raw.chat?.title,
+    topic: raw.is_topic_message === true && raw.message_thread_id !== undefined ? topicName ? `"${topicName}"` : `#${raw.message_thread_id}` : undefined,
+    from: personLabel(name || undefined, raw.from?.username, message.author.userId),
+    replyToBot: isTelegramReplyToBot(raw, botUserId),
+    replyToSnippet: snippet2(realReply?.text ?? realReply?.caption)
+  };
+}
+function readChatMessageFacts(thread, message) {
+  const raw = message.raw;
+  if (thread.adapter.name === "telegram" && raw && typeof raw === "object") {
+    return telegramFacts(raw, message, thread.adapter.botUserId);
+  }
+  const { fullName, userName, userId } = message.author;
+  return {
+    chatType: thread.isDM ? "dm" : undefined,
+    from: personLabel(fullName || undefined, userName || undefined, userId),
+    replyToBot: message.replyTo?.author.isMe === true,
+    replyToSnippet: snippet2(message.replyTo?.text)
+  };
+}
+function formatChatHeaderFacts(adapter, facts, addressed) {
+  const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+  const parts = [adapter];
+  if (facts.chatType)
+    parts.push(facts.title ? `${facts.chatType} "${oneLine(facts.title)}"` : facts.chatType);
+  if (facts.isForum)
+    parts.push(facts.topic ? `forum topic ${oneLine(facts.topic)}` : "forum");
+  parts.push(`from: ${oneLine(facts.from)}`, `addressed: ${addressed}`);
+  if (facts.replyToSnippet)
+    parts.push(`reply-to: "${facts.replyToSnippet}"`);
+  return parts.join(" · ");
+}
+
 // src/integrations/chat-sdk/logger.ts
 init_secret_scrubber();
 var MAX_ISSUE_CHARS = 300;
@@ -31267,8 +31753,18 @@ async function loadAdapter(name, config, logger) {
   const base = { ...config, apiUrl, logger };
   switch (name) {
     case "telegram": {
-      const { createTelegramAdapter } = await import("./index-g216q6jr.js");
-      return createTelegramAdapter({ ...base, allowUnverifiedWebhooks: false });
+      const { TelegramAdapter } = await import("./index-zsyx51ap.js");
+
+      class SwarmTelegramAdapter extends TelegramAdapter {
+        isBotMentioned(message, text) {
+          return super.isBotMentioned(message, text) || String(message.from?.id) !== this.botUserId && isTelegramReplyToBot(message, this.botUserId);
+        }
+      }
+      return new SwarmTelegramAdapter({
+        ...base,
+        allowUnverifiedWebhooks: false,
+        mentionOnReply: true
+      });
     }
     case "slack": {
       const { createSlackAdapter } = await import("./index-zgvqzjsw.js");
@@ -31870,6 +32366,43 @@ function resetDiscordGatewayHealth() {
 // src/integrations/chat-sdk/inbound.ts
 init_zod();
 init_db3();
+
+// src/be/unmapped-identities.ts
+init_db3();
+var TTL_MS = 30 * 24 * 60 * 60 * 1000;
+function namespace(kind) {
+  return `integration:unmapped:${kind}`;
+}
+async function recordUnmappedIdentity(kind, externalId, meta) {
+  const ns = namespace(kind);
+  const now = new Date().toISOString();
+  const expiresAt = Date.now() + TTL_MS;
+  const countKey = `${externalId}:count`;
+  const countBefore = await getKv2(ns, countKey);
+  await upsertKv2({
+    namespace: ns,
+    key: `${externalId}:meta`,
+    value: {
+      lastSeenAt: now,
+      sampleEventType: meta.sampleEventType,
+      sampleContext: meta.sampleContext.slice(0, 100)
+    },
+    valueType: "json",
+    expiresAt
+  });
+  const incremented = await incrKv2(ns, countKey, 1);
+  if (countBefore === null) {
+    await upsertKv2({
+      namespace: ns,
+      key: countKey,
+      value: Number(incremented.value),
+      valueType: "integer",
+      expiresAt
+    });
+  }
+}
+
+// src/integrations/chat-sdk/inbound.ts
 init_resolver();
 init_context_key();
 init_secret_scrubber();
@@ -31918,10 +32451,191 @@ async function recordTaskAttachmentUpload(input) {
     throw error;
   }
 }
+function scopeFromAttachment(attachment) {
+  const storedKey = attachment.providerKey ?? attachment.path ?? "";
+  return {
+    taskId: attachment.taskId,
+    name: attachment.name,
+    key: storedKey.trim() ? storedKey : undefined,
+    orgId: attachment.orgId,
+    driveId: attachment.driveId
+  };
+}
+function backingProviderId(attachment) {
+  if (attachment.kind === "agent-fs")
+    return attachment.providerId ?? "agent-fs";
+  if (attachment.providerId === "local-fs")
+    return "local-fs";
+  return null;
+}
+
+// src/utils/transcription.ts
+init_secret_scrubber();
+var TRANSCRIPTION_TIMEOUT_MS = 60000;
+var TRANSCRIPTION_API_KEY_ENV = "TRANSCRIPTION_API_KEY";
+var openAIShape = {
+  path: "/audio/transcriptions",
+  modelField: "model",
+  authHeaders: (apiKey) => ({ authorization: `Bearer ${apiKey}` })
+};
+var PROVIDERS = {
+  openai: {
+    keyEnv: "OPENAI_API_KEY",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    defaultModel: "whisper-1",
+    ...openAIShape
+  },
+  groq: {
+    keyEnv: "GROQ_API_KEY",
+    defaultBaseUrl: "https://api.groq.com/openai/v1",
+    defaultModel: "whisper-large-v3-turbo",
+    ...openAIShape
+  },
+  elevenlabs: {
+    keyEnv: "ELEVENLABS_API_KEY",
+    defaultBaseUrl: "https://api.elevenlabs.io/v1",
+    defaultModel: "scribe_v2",
+    path: "/speech-to-text",
+    modelField: "model_id",
+    authHeaders: (apiKey) => ({ "xi-api-key": apiKey })
+  }
+};
+var AUTO_DETECT_ORDER = ["elevenlabs", "openai", "groq"];
+var TRANSCRIPTION_ENV_KEYS = [
+  TRANSCRIPTION_API_KEY_ENV,
+  "TRANSCRIPTION_PROVIDER",
+  "TRANSCRIPTION_BASE_URL",
+  "TRANSCRIPTION_MODEL",
+  ...AUTO_DETECT_ORDER.map((name) => PROVIDERS[name].keyEnv)
+];
+
+class TranscriptionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TranscriptionError";
+  }
+}
+function envValue(key) {
+  return process.env[key]?.trim() || undefined;
+}
+function resolveTranscriptionConfig() {
+  const pinned = envValue("TRANSCRIPTION_PROVIDER")?.toLowerCase();
+  const explicitKey = envValue(TRANSCRIPTION_API_KEY_ENV);
+  if (explicitKey) {
+    return {
+      provider: pinned ?? "openai",
+      apiKey: explicitKey,
+      keyEnv: TRANSCRIPTION_API_KEY_ENV,
+      source: "explicit"
+    };
+  }
+  const candidates = pinned ? AUTO_DETECT_ORDER.filter((name) => name === pinned) : AUTO_DETECT_ORDER;
+  for (const name of candidates) {
+    const { keyEnv } = PROVIDERS[name];
+    const apiKey = envValue(keyEnv);
+    if (apiKey)
+      return { provider: name, apiKey, keyEnv, source: "auto" };
+  }
+  return null;
+}
+function isTranscriptionConfigured() {
+  return resolveTranscriptionConfig() !== null;
+}
+function providerSpec(name) {
+  if (!Object.hasOwn(PROVIDERS, name)) {
+    throw new TranscriptionError(`TRANSCRIPTION_PROVIDER "${name}" is not supported (use ${Object.keys(PROVIDERS).join(", ")})`);
+  }
+  return PROVIDERS[name];
+}
+function errorDetail(payload, status) {
+  const error = payload?.error;
+  if (typeof error?.message === "string")
+    return error.message;
+  const detail = payload?.detail;
+  if (typeof detail === "string")
+    return detail;
+  if (typeof detail?.message === "string")
+    return detail.message;
+  return `HTTP ${status}`;
+}
+async function transcribeAudio(input) {
+  const config = resolveTranscriptionConfig();
+  if (!config)
+    throw new TranscriptionError("no transcription provider key is set");
+  const { apiKey } = config;
+  const provider = providerSpec(config.provider);
+  const baseUrlOverride = config.source === "explicit" ? process.env.TRANSCRIPTION_BASE_URL?.trim() : undefined;
+  const baseUrl = (baseUrlOverride || provider.defaultBaseUrl).replace(/\/+$/, "");
+  const keyScrubber = createValueScrubber([{ value: apiKey, name: config.keyEnv }]);
+  const scrub = (text) => scrubSecrets(keyScrubber.text(text));
+  const form = new FormData;
+  const type = input.mimeType ?? input.data.type;
+  form.append("file", type ? new Blob([input.data], { type }) : input.data, input.filename);
+  form.append(provider.modelField, process.env.TRANSCRIPTION_MODEL?.trim() || provider.defaultModel);
+  let response;
+  try {
+    response = await fetch(`${baseUrl}${provider.path}`, {
+      method: "POST",
+      headers: provider.authHeaders(apiKey),
+      body: form,
+      signal: AbortSignal.timeout(TRANSCRIPTION_TIMEOUT_MS)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw new TranscriptionError(`no answer within ${TRANSCRIPTION_TIMEOUT_MS / 1000} s`);
+    }
+    throw new TranscriptionError(scrub(error instanceof Error ? error.message : String(error)));
+  }
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || typeof payload?.text !== "string") {
+    throw new TranscriptionError(scrub(errorDetail(payload, response.status)));
+  }
+  return payload.text.trim();
+}
+var NOT_TRANSCRIBED_NOTE = `(not transcribed: no transcription provider configured, set ${TRANSCRIPTION_API_KEY_ENV} or one of ${AUTO_DETECT_ORDER.map((name) => PROVIDERS[name].keyEnv).join(", ")})`;
+var AUDIO_EXTENSIONS = {
+  "audio/ogg": "ogg",
+  "audio/opus": "ogg",
+  "audio/mpeg": "mp3",
+  "audio/mp4": "m4a",
+  "audio/x-m4a": "m4a",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/webm": "webm"
+};
+async function transcribeAudioNotes(files, logPrefix) {
+  const notes = new Map;
+  if (files.length === 0)
+    return notes;
+  if (!isTranscriptionConfigured()) {
+    for (const file of files)
+      notes.set(file.key, NOT_TRANSCRIBED_NOTE);
+    return notes;
+  }
+  for (const file of files) {
+    const extension = AUDIO_EXTENSIONS[file.mimeType ?? ""] ?? "ogg";
+    const filename = /\.\w+$/.test(file.name) ? file.name : `${file.name}.${extension}`;
+    try {
+      const text = await transcribeAudio({ data: file.data, filename, mimeType: file.mimeType });
+      notes.set(file.key, `[Transcript of ${file.name}]
+${text || "(no speech recognized)"}`);
+    } catch (error) {
+      const reason = scrubSecrets(error instanceof Error ? error.message : String(error));
+      console.warn(`${logPrefix} could not transcribe file ${file.key}: ${reason}`);
+      notes.set(file.key, `(transcription failed: ${reason})`);
+    }
+  }
+  return notes;
+}
 
 // src/integrations/chat-sdk/attachments.ts
 var DRAFT_LEASE_REFRESH_MS = 60000;
 var SHARED_FILE_INTENT = "user-upload";
+var MB = 1024 * 1024;
+var CHAT_INBOUND_FILE_LIMITS = { telegram: 20 * MB };
+function chatInboundFileLimit(adapter) {
+  return Math.min(CHAT_INBOUND_FILE_LIMITS[adapter] ?? MAX_TASK_ATTACHMENT_BYTES, MAX_TASK_ATTACHMENT_BYTES);
+}
 function formatFileSize(bytes) {
   if (bytes < 1024)
     return `${bytes} B`;
@@ -31942,16 +32656,42 @@ function toChatFiles(adapter, messageId, attachments) {
     attachment
   }));
 }
-function buildChatAttachmentText(files, failed = []) {
+function buildChatAttachmentText(files, failed = [], notes = new Map) {
   const reasons = new Map(failed.map((f) => [f.file.id, f.reason]));
   return files.map((f) => {
     const size = typeof f.size === "number" ? formatFileSize(f.size) : "unknown size";
     const line = `[File: ${f.name} (${f.mimeType ?? "unknown type"}, ${size}) id=${f.id}]`;
     const reason = reasons.get(f.id);
-    return reason ? `${line} (not attached: ${reason})` : line;
+    const note = notes.get(f.id);
+    return [reason ? `${line} (not attached: ${reason})` : line, note].filter(Boolean).join(`
+`);
   }).join(`
 `);
 }
+function markdownLiteral(value) {
+  const text = value.replace(/[\r\n]+/g, " ");
+  const longestRun = Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length));
+  const fence = "`".repeat(longestRun + 1);
+  const pad = /^[` ]|[` ]$/.test(text) ? " " : "";
+  return `${fence}${pad}${text}${pad}${fence}`;
+}
+function formatTooLargeReply(failed) {
+  const lines = failed.map((f) => `- ${markdownLiteral(f.file.name)}: ${f.reason}`);
+  return [
+    `Too large to read, so the swarm did not get ${failed.length === 1 ? "this file" : "these files"}:`,
+    ...lines,
+    "Send a smaller file or a link."
+  ].join(`
+`);
+}
+async function transcribeChatAudio(fetched) {
+  return transcribeAudioNotes(fetched.filter(({ file }) => file.attachment.type === "audio").map(({ file, path }) => ({
+    key: file.id,
+    name: file.name,
+    data: Bun.file(path),
+    mimeType: file.mimeType
+  })), "[chat-sdk]");
+}
 async function readAttachment(attachment) {
   if (attachment.data instanceof Blob)
     return new Uint8Array(await attachment.data.arrayBuffer());
@@ -31975,17 +32715,25 @@ async function fetchChatFiles(files) {
   };
   if (files.length === 0)
     return result;
-  const limit = `larger than the ${MAX_TASK_ATTACHMENT_BYTES / (1024 * 1024)} MB limit`;
+  const tooLarge = (file, size) => {
+    const limit = chatInboundFileLimit(file.adapter);
+    const platform = file.adapter.charAt(0).toUpperCase() + file.adapter.slice(1);
+    return {
+      file,
+      reason: `too large (${formatFileSize(size)}, the limit for files sent to the ${platform} bot is ${formatFileSize(limit)})`,
+      tooLarge: true
+    };
+  };
   dir = await mkdtemp(join(tmpdir2(), "chat-files-"));
   for (const [index, file] of files.entries()) {
-    if (typeof file.size === "number" && file.size > MAX_TASK_ATTACHMENT_BYTES) {
-      result.failed.push({ file, reason: limit });
+    if (typeof file.size === "number" && file.size > chatInboundFileLimit(file.adapter)) {
+      result.failed.push(tooLarge(file, file.size));
       continue;
     }
     try {
       const bytes = await readAttachment(file.attachment);
-      if (bytes.byteLength > MAX_TASK_ATTACHMENT_BYTES) {
-        result.failed.push({ file, reason: limit });
+      if (bytes.byteLength > chatInboundFileLimit(file.adapter)) {
+        result.failed.push(tooLarge(file, bytes.byteLength));
         continue;
       }
       const path = join(dir, String(index));
@@ -32075,6 +32823,17 @@ var FALLBACK_LIMIT = 2000;
 function chatMessageLimit(adapter) {
   return CHAT_MESSAGE_LIMITS[adapter] ?? FALLBACK_LIMIT;
 }
+var MB2 = 1024 * 1024;
+var CHAT_UPLOAD_LIMITS = {
+  telegram: 50 * MB2,
+  discord: 10 * MB2
+};
+var FALLBACK_UPLOAD_LIMIT = 50 * MB2;
+var TELEGRAM_PHOTO_LIMIT = 10 * MB2;
+function chatUploadLimit(adapter) {
+  return CHAT_UPLOAD_LIMITS[adapter] ?? FALLBACK_UPLOAD_LIMIT;
+}
+var CHAT_FILES_PER_MESSAGE = 10;
 function splitChatMessage(text, limit) {
   if (limit <= 0)
     throw new Error("splitChatMessage: limit must be positive");
@@ -32115,16 +32874,165 @@ function adapterOfChatId(id) {
   const index = id.indexOf(":");
   return index === -1 ? id : id.slice(0, index);
 }
+
+class ChatFileTooLargeError extends Error {
+  sizeBytes;
+  constructor(sizeBytes) {
+    super(`file is ${formatFileSize(sizeBytes)}`);
+    this.sizeBytes = sizeBytes;
+    this.name = "ChatFileTooLargeError";
+  }
+}
+var FENCE_LINE = /^ {0,3}(`{3,}|~{3,})/;
+var NON_HEADING_HASH = /^( {0,3}(?:>[ \t]?)*[ \t]*(?:(?:[-*+]|\d{1,9}[.)])[ \t]+(?:\[[ xX]\][ \t]+)?)?)(#{7,}|#{1,6}(?=[^\s#]))/;
+function escapeTelegramHashLines(markdown) {
+  let fence;
+  return markdown.split(`
+`).map((line) => {
+    const marker = FENCE_LINE.exec(line)?.[1];
+    if (fence) {
+      if (marker && marker[0] === fence[0] && marker.length >= fence.length)
+        fence = undefined;
+      return line;
+    }
+    if (marker) {
+      fence = marker;
+      return line;
+    }
+    return line.replace(NON_HEADING_HASH, "$1\\$2");
+  }).join(`
+`);
+}
 async function postChunks(adapter, target, text) {
   const messageIds = [];
   let threadId;
   for (const chunk of splitChatMessage(text, chatMessageLimit(adapter))) {
-    const sent = await target.post({ markdown: chunk });
+    const markdown = adapter === "telegram" ? escapeTelegramHashLines(chunk) : chunk;
+    const sent = await target.post({ markdown });
     messageIds.push(sent.id);
     threadId ??= sent.threadId;
   }
   return { messageIds, threadId };
 }
+function resolveMimeType(name, ...candidates) {
+  for (const candidate of candidates) {
+    const type = candidate?.split(";")[0]?.trim().toLowerCase();
+    if (type && type !== "application/octet-stream")
+      return type;
+  }
+  return Bun.file(name).type.split(";")[0] ?? "application/octet-stream";
+}
+function telegramAttachmentType(mimeType, sizeBytes) {
+  if ((mimeType === "image/jpeg" || mimeType === "image/png") && sizeBytes <= TELEGRAM_PHOTO_LIMIT) {
+    return "image";
+  }
+  if (mimeType === "video/mp4")
+    return "video";
+  if (mimeType === "audio/mpeg" || mimeType === "audio/mp4" || mimeType === "audio/x-m4a") {
+    return "audio";
+  }
+  return "file";
+}
+function fileGroupKey(adapter, file) {
+  if (adapter !== "telegram")
+    return "files";
+  const type = telegramAttachmentType(file.mimeType, file.data.byteLength);
+  return type === "image" || type === "video" ? "visual" : type;
+}
+function fileMessage(adapter, files) {
+  if (adapter === "telegram") {
+    return {
+      markdown: "",
+      attachments: files.map((file) => ({
+        type: telegramAttachmentType(file.mimeType, file.data.byteLength),
+        name: file.name,
+        mimeType: file.mimeType,
+        size: file.data.byteLength,
+        data: file.data
+      }))
+    };
+  }
+  return {
+    markdown: "",
+    files: files.map((file) => ({ data: file.data, filename: file.name, mimeType: file.mimeType }))
+  };
+}
+function platformName(adapter) {
+  return adapter.charAt(0).toUpperCase() + adapter.slice(1);
+}
+async function postFiles(adapter, target, files) {
+  const limit = chatUploadLimit(adapter);
+  const tooLarge = (size) => `${formatFileSize(size)}, over the ${formatFileSize(limit)} upload limit of ${platformName(adapter)}`;
+  const messageIds = [];
+  const unsent = [];
+  const groups = new Map;
+  const send = async (group) => {
+    try {
+      const sent = await target.post(fileMessage(adapter, group));
+      messageIds.push(sent.id);
+    } catch (error) {
+      const reason = `refused by ${platformName(adapter)} (${scrubSecrets(errorMessage(error))})`;
+      for (const file of group)
+        unsent.push({ name: file.name, reason });
+    }
+  };
+  for (const file of files) {
+    if (file.sizeBytes !== undefined && file.sizeBytes > limit) {
+      unsent.push({ name: file.name, reason: tooLarge(file.sizeBytes) });
+      continue;
+    }
+    let loaded;
+    try {
+      const { data, mimeType } = await file.load(limit);
+      if (data.byteLength > limit)
+        throw new ChatFileTooLargeError(data.byteLength);
+      loaded = {
+        name: file.name,
+        mimeType: resolveMimeType(file.name, file.mimeType, mimeType),
+        data: Buffer.from(data.buffer, data.byteOffset, data.byteLength)
+      };
+    } catch (error) {
+      unsent.push({
+        name: file.name,
+        reason: error instanceof ChatFileTooLargeError ? tooLarge(error.sizeBytes) : `could not be read (${scrubSecrets(errorMessage(error))})`
+      });
+      continue;
+    }
+    const key = fileGroupKey(adapter, loaded);
+    const group = [...groups.get(key) ?? [], loaded];
+    if (group.length === CHAT_FILES_PER_MESSAGE) {
+      groups.delete(key);
+      await send(group);
+    } else {
+      groups.set(key, group);
+    }
+  }
+  for (const group of groups.values())
+    await send(group);
+  return { messageIds, unsent };
+}
+function unsentFilesSummary(unsent) {
+  return unsent.length === 0 ? "" : ` ${formatUnsentFilesNote(unsent)}`;
+}
+function singleLine(text) {
+  return text.replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, " ").trim();
+}
+function breakMentions(text) {
+  return text.replace(/@/g, "@​").replace(/<!/g, "<​!");
+}
+function codeSpan(text) {
+  const value = breakMentions(singleLine(text)) || "(unnamed)";
+  const longestRun = Math.max(0, ...(value.match(/`+/g) ?? []).map((run) => run.length));
+  const fence = "`".repeat(longestRun + 1);
+  const pad = value.startsWith("`") || value.endsWith("`") ? " " : "";
+  return `${fence}${pad}${value}${pad}${fence}`;
+}
+function formatUnsentFilesNote(unsent) {
+  const lines = unsent.map((file) => `- ${codeSpan(file.name)}: ${breakMentions(singleLine(file.reason))}`);
+  const count = unsent.length === 1 ? "1 file" : `${unsent.length} files`;
+  return [`Could not send ${count}:`, ...lines].join(`
+`);
+}
 async function postChatMessage(args) {
   assertTrustedChatTarget(args.threadId ?? args.channelId ?? "");
   const chat = getChatInstance(args.adapter);
@@ -32132,27 +33040,42 @@ async function postChatMessage(args) {
     throw new ChatAdapterUnavailableError(args.adapter);
   const text = scrubSecrets(args.text);
   let result;
+  let target;
   if (args.threadId) {
     const thread = chat.thread(args.threadId);
+    target = thread;
     const sent = await postChunks(args.adapter, thread, text);
     result = {
       adapter: args.adapter,
       threadId: thread.id,
       channelId: thread.channelId,
-      messageIds: sent.messageIds
+      messageIds: sent.messageIds,
+      unsentFiles: []
     };
   } else if (args.channelId) {
     const channel = chat.channel(args.channelId);
+    target = channel;
     const sent = await postChunks(args.adapter, channel, text);
     result = {
       adapter: args.adapter,
       threadId: sent.threadId ?? channel.id,
       channelId: channel.id,
-      messageIds: sent.messageIds
+      messageIds: sent.messageIds,
+      unsentFiles: []
     };
   } else {
     throw new Error("postChatMessage needs a threadId or a channelId");
   }
+  if (args.files?.length) {
+    const sent = await postFiles(args.adapter, target, args.files);
+    result.messageIds.push(...sent.messageIds);
+    result.unsentFiles = sent.unsent;
+    if (sent.unsent.length > 0) {
+      const note = formatUnsentFilesNote(sent.unsent);
+      const noted = await postChunks(args.adapter, target, scrubSecrets(note));
+      result.messageIds.push(...noted.messageIds);
+    }
+  }
   emitChatMessageSent({
     adapter: result.adapter,
     channelId: result.channelId,
@@ -32218,9 +33141,19 @@ async function putChatChannelMapping(adapter, channelId, mapping) {
 async function deleteChatChannelMapping(adapter, channelId) {
   return deleteKv2(CHAT_CHANNELS_NAMESPACE, chatChannelKey(adapter, channelId));
 }
+function hasRoutingToken(text) {
+  return /swarm#(?:[a-f0-9-]{36}|all)/i.test(text);
+}
 function stripRoutingTokens(text) {
   return text.replace(/swarm#[a-f0-9-]{36}/gi, "").replace(/swarm#all/gi, "").trim();
 }
+var DEFAULT_OWNER_WINDOW_MINUTES = 15;
+function chatOwnerWindowStart(now = Date.now()) {
+  const raw = process.env.CHAT_SDK_OWNER_WINDOW_MIN?.trim();
+  const value = raw ? Number(raw) : Number.NaN;
+  const minutes = Number.isFinite(value) && value >= 0 ? value : DEFAULT_OWNER_WINDOW_MINUTES;
+  return new Date(now - minutes * 60000).toISOString();
+}
 async function leadMatch(reachable, matchedText) {
   const lead = reachable.find((agent) => agent.isLead) ?? await getLeadAgent2();
   return { agent: lead, reason: "skill", matchedText };
@@ -32262,7 +33195,7 @@ async function routeChatMessage(text, ctx) {
     }
     console.warn(scrubSecrets(`[chat-sdk] Channel mapping for ${ctx.channelId} names unknown agent ${mapping.agentId}; using the default route`));
   }
-  const owner = await getAgentWorkingOnContextKey2(chatSdkContextKey(ctx.threadId), "chat");
+  const owner = await getAgentWorkingOnContextKey2(chatSdkContextKey(ctx.threadId), "chat", ctx.adapter === "telegram" && !ctx.isDirectMessage ? chatOwnerWindowStart() : undefined);
   if (owner && await isAgentReachable(owner)) {
     return {
       kind: "agents",
@@ -32292,6 +33225,9 @@ async function requestChatThreadSteering(args) {
   const task = await getLatestLeadTaskByContextKey2(args.contextKey, "chat");
   if (!task || task.status !== "in_progress")
     return null;
+  const senderUserId = await args.resolveSender();
+  if (senderUserId !== task.requestedByUserId)
+    return null;
   try {
     const result = await requestSteering({
       taskId: task.id,
@@ -32299,7 +33235,8 @@ async function requestChatThreadSteering(args) {
       mode: "queue",
       onUnsupported: "degrade",
       source: "chat",
-      createdByKind: "user"
+      createdByKind: "user",
+      createdByUserId: senderUserId
     });
     return { task, result };
   } catch (error) {
@@ -32393,6 +33330,18 @@ registerTemplate({
   ],
   category: "system"
 });
+registerTemplate({
+  eventType: "chat.message.header",
+  header: "",
+  defaultBody: "[chat] {{chat_facts}}",
+  variables: [
+    {
+      name: "chat_facts",
+      description: "Adapter, chat type and title, forum topic, sender, why the message was taken (addressed) and the replied-to snippet, joined with ' · '"
+    }
+  ],
+  category: "system"
+});
 
 // src/integrations/chat-sdk/inbound.ts
 var ChatRouteModifySchema = object2({
@@ -32437,10 +33386,24 @@ async function handleChatInbound(thread, message, kind) {
   if (immediate)
     text = text.replace(/^!now\s*/i, "").trim();
   const attachments = message.attachments ?? [];
+  const facts = readChatMessageFacts(thread, message);
+  const isDirectMessage = kind === "dm" || thread.isDM;
+  const mentioned = kind === "mention" || message.isMention === true;
+  let addressed = isDirectMessage ? "dm" : facts.replyToBot ? "reply-to-bot" : mentioned ? "mention" : "none";
+  if (addressed === "none" && (facts.chatType === "group" || facts.chatType === "supergroup")) {
+    const unaddressed = await classifyUnaddressedGroupMessage(thread, message.author.userId, text);
+    if (unaddressed === "chatter") {
+      console.log(`[chat-sdk] ${thread.id}: unaddressed group message from a non-requester, ignored`);
+      return;
+    }
+    if (unaddressed === "requester-follow-up")
+      addressed = unaddressed;
+  }
   if (!immediate && attachments.length === 0 && text && !isChatThreadBuffered(thread.id)) {
     const steering = await requestChatThreadSteering({
       contextKey: chatSdkContextKey(thread.id),
-      message: text
+      message: text,
+      resolveSender: () => resolveChatSender(adapter, message.author.userId)
     });
     if (steering) {
       console.log(`[chat-sdk] ${adapter} message steered task ${steering.task.id} (${steering.result.outcome})`);
@@ -32469,8 +33432,10 @@ async function handleChatInbound(thread, message, kind) {
       text,
       userId: message.author.userId,
       userName: message.author.userName || undefined,
-      botMentioned: kind === "mention" || message.isMention === true,
-      isDirectMessage: kind === "dm" || thread.isDM,
+      botMentioned: mentioned || facts.replyToBot,
+      isDirectMessage,
+      addressed,
+      facts,
       attachments
     });
     if (kind !== "subscribed")
@@ -32479,6 +33444,47 @@ async function handleChatInbound(thread, message, kind) {
   if (immediate)
     await instantFlushChat(thread.id);
 }
+var REQUESTER_KEY_PREFIX = "swarm:requester:";
+var REQUESTER_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+async function rememberChatThreadRequester(threadId, userId) {
+  try {
+    await new SqliteChatState().set(`${REQUESTER_KEY_PREFIX}${threadId}`, userId, REQUESTER_TTL_MS);
+  } catch (error) {
+    console.warn(`[chat-sdk] Could not store the thread requester: ${errorMessage(error)}`);
+  }
+}
+async function classifyUnaddressedGroupMessage(thread, senderId, text) {
+  if (hasRoutingToken(text))
+    return "routable";
+  if ((await getChatChannelMapping(thread.adapter.name, thread.channelId))?.agentId) {
+    return "routable";
+  }
+  const owner = await getAgentWorkingOnContextKey2(chatSdkContextKey(thread.id), "chat", chatOwnerWindowStart());
+  if (!owner)
+    return "chatter";
+  const requester = await new SqliteChatState().get(`${REQUESTER_KEY_PREFIX}${thread.id}`);
+  return requester === senderId ? "requester-follow-up" : "chatter";
+}
+async function resolveChatRequester(adapter, item) {
+  return resolveChatSender(adapter, item.userId, {
+    sampleEventType: "chat.message",
+    sampleContext: `${item.facts.from}: ${item.text}`
+  });
+}
+async function resolveChatSender(adapter, userId, sample) {
+  if (!userId || userId.startsWith("chat:"))
+    return;
+  try {
+    const resolution = await resolveIdentity(adapter, userId);
+    if (resolution.status === "resolved")
+      return resolution.userId;
+    if (sample)
+      await recordUnmappedIdentity(adapter, userId, sample);
+  } catch (error) {
+    console.warn(`[chat-sdk] Could not resolve the requester: ${errorMessage(error)}`);
+  }
+  return;
+}
 async function getChatThreadContext(thread, exclude, since) {
   try {
     await thread.refresh();
@@ -32549,6 +33555,8 @@ async function flushChatThread(threadId, items, immediate) {
 `);
     const botMentioned = items.some((item) => item.botMentioned);
     const isDirectMessage = items.some((item) => item.isDirectMessage);
+    const requester = items.find((item) => item.addressed !== "none") ?? first;
+    const otherSenders = new Set(items.map((item) => item.userId)).size - 1;
     const resetAt = await getChatThreadResetAt(threadId);
     const previousTask = await getLatestTaskByContextKey2(contextKey);
     const mostRecentTask = previousTask && resetAt && new Date(previousTask.createdAt).getTime() <= resetAt.getTime() ? null : previousTask;
@@ -32561,6 +33569,9 @@ async function flushChatThread(threadId, items, immediate) {
       text: rawText,
       botMentioned,
       isDirectMessage,
+      ...first.facts.chatType ? { chatType: first.facts.chatType } : {},
+      ...first.facts.isForum ? { isForum: true } : {},
+      replyToBot: items.some((item) => item.facts.replyToBot),
       ...mostRecentTask ? { threadContext: { adapter, threadId } } : {}
     }, {
       validateModify: (data) => {
@@ -32611,7 +33622,16 @@ async function flushChatThread(threadId, items, immediate) {
     const body = stripRoutingTokens(rawText);
     const files = items.flatMap((item) => toChatFiles(adapter, item.messageId, item.attachments));
     const inbound = __using(__stack, await fetchChatFiles(files), 1);
-    const fileText = buildChatAttachmentText(inbound.files, inbound.failed);
+    const tooLarge = inbound.failed.filter((failure) => failure.tooLarge);
+    if (tooLarge.length > 0) {
+      try {
+        await postChatMessage({ adapter, threadId, text: formatTooLargeReply(tooLarge) });
+      } catch (error) {
+        console.warn(`[chat-sdk] ${threadId}: could not post the too-large reply: ${errorMessage(error)}`);
+      }
+    }
+    const notes = await transcribeChatAudio(inbound.fetched);
+    const fileText = buildChatAttachmentText(inbound.files, inbound.failed, notes);
     const combined = [body, fileText].filter(Boolean).join(`
 
 `);
@@ -32619,9 +33639,17 @@ async function flushChatThread(threadId, items, immediate) {
 
 ${combined}` : combined;
     const threadContext = mostRecentTask && thread ? await getChatThreadContext(thread, new Set(items.map((item) => item.messageId)), resetAt) : "";
-    const description = threadContext ? `${resolveTemplate("chat.message.thread_context", { thread_messages: threadContext }).text}
+    const header = resolveTemplate("chat.message.header", {
+      chat_facts: formatChatHeaderFacts(adapter, otherSenders > 0 ? { ...requester.facts, from: `${requester.facts.from} +${otherSenders} more` } : requester.facts, requester.addressed)
+    }).text;
+    const description = [
+      header,
+      threadContext ? resolveTemplate("chat.message.thread_context", { thread_messages: threadContext }).text : "",
+      marked
+    ].filter(Boolean).join(`
 
-${marked}` : marked;
+`);
+    const requestedByUserId = otherSenders > 0 ? undefined : await resolveChatRequester(adapter, requester);
     const latestActive = await getLatestActiveTaskByContextKey2(contextKey, "chat");
     const dependsOn = !immediate && latestActive ? [latestActive.id] : undefined;
     let created = 0;
@@ -32636,7 +33664,9 @@ ${marked}` : marked;
         priority: 70,
         contextKey,
         dependsOn,
+        requestedByUserId,
         parentTaskId: mostRecentTask?.id,
+        inheritParentRequester: false,
         inheritParentOutputSchema: false
       };
       try {
@@ -32652,6 +33682,7 @@ ${marked}` : marked;
       }
     }
     if (created > 0) {
+      await rememberChatThreadRequester(threadId, requester.userId);
       await subscribe(thread);
       startTypingKeepalive(adapter, threadId);
     } else {
@@ -32697,6 +33728,127 @@ init_db3();
 init_context_key();
 init_secret_scrubber();
 init_event_bus();
+
+// src/integrations/chat-sdk/outbound-files.ts
+init_db3();
+init_secret_scrubber();
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function download(scope, maxBytes, provider = getFileStorageProvider2()) {
+  const response = await provider.download(scope);
+  const length = Number(response.headers.get("content-length"));
+  if (Number.isFinite(length) && length > maxBytes) {
+    await response.body?.cancel();
+    throw new ChatFileTooLargeError(length);
+  }
+  const data = new Uint8Array(await response.arrayBuffer());
+  if (data.byteLength > maxBytes)
+    throw new ChatFileTooLargeError(data.byteLength);
+  return { data, mimeType: response.headers.get("content-type") ?? undefined };
+}
+function chatFileOfTaskAttachment(attachment) {
+  if (backingProviderId(attachment) !== getFileStorageProvider2().id)
+    return;
+  return {
+    name: attachment.name,
+    mimeType: attachment.mimeType,
+    sizeBytes: attachment.sizeBytes,
+    load: (maxBytes) => download(scopeFromAttachment(attachment), maxBytes)
+  };
+}
+function pathSegments(path) {
+  return normalizeStoredKey(path).split("/").map((segment) => {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {}
+    if (!decoded || decoded === "." || decoded === ".." || /[/\\\0]/.test(decoded)) {
+      throw new FilesError("Provider", "Path must not contain empty, `.` or `..` segments, or encoded separators");
+    }
+    return decoded;
+  });
+}
+async function callerAgentFs(agentId) {
+  if (!agentId)
+    return;
+  const configs = await getResolvedConfig2(agentId);
+  const value = (key) => configs.find((c) => c.key === key)?.value?.trim();
+  const apiUrl = value("AGENT_FS_API_URL") || process.env.AGENT_FS_API_URL?.trim();
+  const apiKey = value("AGENT_FS_API_KEY");
+  const orgId = value("AGENT_FS_DEFAULT_ORG_ID");
+  const driveId = value("AGENT_FS_DEFAULT_DRIVE_ID");
+  return apiUrl && apiKey && orgId && driveId ? { apiUrl, apiKey, orgId, driveId } : undefined;
+}
+function chatFileOfPath(path, access) {
+  const segments = pathSegments(path);
+  const name = segments.at(-1);
+  const key = segments.map(encodeURIComponent).join("/");
+  const keyScrubber = createValueScrubber([{ value: access.apiKey, name: "AGENT_FS_API_KEY" }]);
+  return {
+    name,
+    load: async (maxBytes) => {
+      try {
+        return await download({ taskId: "chat", name, key, orgId: access.orgId, driveId: access.driveId }, maxBytes, new AgentFsProvider(access));
+      } catch (error) {
+        if (error instanceof ChatFileTooLargeError)
+          throw error;
+        if (error instanceof FilesError && error.code === "Unauthorized") {
+          throw new Error("your agent-fs credential cannot read this path");
+        }
+        throw new Error(keyScrubber.text(error instanceof Error ? error.message : String(error)));
+      }
+    }
+  };
+}
+async function resolveChatAttachmentRefs(refs, taskId, agentId) {
+  let taskAttachments;
+  let access = null;
+  const files = [];
+  for (const ref of refs) {
+    if (UUID_PATTERN.test(ref)) {
+      if (!taskId)
+        return { error: `Attachment ${ref}: no current task to look it up in.` };
+      taskAttachments ??= await getTaskAttachments2(taskId);
+      const attachment = taskAttachments.find((a) => a.id === ref);
+      if (!attachment)
+        return { error: `Attachment ${ref} is not an attachment of task ${taskId}.` };
+      const file = chatFileOfTaskAttachment(attachment);
+      if (!file) {
+        return {
+          error: `Attachment ${ref} (${attachment.kind}) is not stored in the swarm file provider, so it cannot be sent as a file. Post its link instead.`
+        };
+      }
+      files.push(file);
+      continue;
+    }
+    if (access === null)
+      access = await callerAgentFs(agentId);
+    if (!access) {
+      return {
+        error: `Path ${ref}: you have no agent-fs credential and drive to read it with. Attach the file to your task and send its attachment id.`
+      };
+    }
+    try {
+      files.push(chatFileOfPath(ref, access));
+    } catch (error) {
+      return { error: `Path ${ref}: ${errorMessage(error)}` };
+    }
+  }
+  return { files };
+}
+var FETCHED_SLACK_FILE_INTENT = "slack-file";
+async function taskOutputChatFiles(taskId) {
+  return (await getTaskAttachments2(taskId)).flatMap((attachment) => {
+    if (attachment.agentId === null)
+      return [];
+    if (attachment.intent === SHARED_FILE_INTENT || attachment.intent === FETCHED_SLACK_FILE_INTENT) {
+      return [];
+    }
+    const file = chatFileOfTaskAttachment(attachment);
+    return file ? [file] : [];
+  });
+}
+
+// src/integrations/chat-sdk/relay.ts
 var RELAY_GIVE_UP_AFTER_MS = 24 * 60 * 60 * 1000;
 var SWEEP_EVERY_N_TICKS = 20;
 var EARLY_TICK_DEBOUNCE_MS = 250;
@@ -32746,7 +33898,8 @@ async function processPendingChatRelays(now = Date.now(), signal) {
         adapter: target.adapter,
         threadId: target.threadId,
         text: formatChatRelayText(task),
-        taskId: task.id
+        taskId: task.id,
+        files: await taskOutputChatFiles(task.id)
       });
       stopTypingKeepalive(target.threadId);
       await markChatRelayDelivered2(task.id, now);
@@ -33404,43 +34557,6 @@ Original issue: {{issue_key}} — {{issue_summary}}`,
 // src/jira/sync.ts
 init_db3();
 init_oauth();
-
-// src/be/unmapped-identities.ts
-init_db3();
-var TTL_MS = 30 * 24 * 60 * 60 * 1000;
-function namespace(kind) {
-  return `integration:unmapped:${kind}`;
-}
-async function recordUnmappedIdentity(kind, externalId, meta) {
-  const ns = namespace(kind);
-  const now = new Date().toISOString();
-  const expiresAt = Date.now() + TTL_MS;
-  const countKey = `${externalId}:count`;
-  const countBefore = await getKv2(ns, countKey);
-  await upsertKv2({
-    namespace: ns,
-    key: `${externalId}:meta`,
-    value: {
-      lastSeenAt: now,
-      sampleEventType: meta.sampleEventType,
-      sampleContext: meta.sampleContext.slice(0, 100)
-    },
-    valueType: "json",
-    expiresAt
-  });
-  const incremented = await incrKv2(ns, countKey, 1);
-  if (countBefore === null) {
-    await upsertKv2({
-      namespace: ns,
-      key: countKey,
-      value: Number(incremented.value),
-      valueType: "integer",
-      expiresAt
-    });
-  }
-}
-
-// src/jira/sync.ts
 init_users();
 init_resolver();
 init_context_key();
@@ -33524,7 +34640,7 @@ async function resolveBotAccountId() {
 function resetBotAccountIdCache() {
   setCachedBotAccountId(null);
 }
-async function findLeadAgent5() {
+async function findLeadAgent6() {
   const agents = await getAllAgents2();
   const onlineLead = agents.find((a) => a.isLead && a.status !== "offline");
   if (onlineLead)
@@ -33728,7 +34844,7 @@ async function handleIssueDeleteEvent(event) {
   }
 }
 async function createInitialJiraTask(input) {
-  const lead = await findLeadAgent5();
+  const lead = await findLeadAgent6();
   const descriptionSection = input.descriptionText ? `
 Description:
 ${input.descriptionText}
@@ -33766,7 +34882,7 @@ ${input.descriptionText}
   console.log(`[Jira Sync] Created ${action} task ${task.id} for ${input.issueKey} -> ${lead?.name ?? "unassigned"}`);
 }
 async function createCommentMentionTask(input) {
-  const lead = await findLeadAgent5();
+  const lead = await findLeadAgent6();
   const descriptionSection = input.descriptionText ? `
 Description:
 ${input.descriptionText}
@@ -33826,7 +34942,7 @@ async function notifySlack(text) {
     return;
   }
   try {
-    const { getSlackApp } = await import("./app-rb7vc02s.js");
+    const { getSlackApp } = await import("./app-0qp0a2gk.js");
     const app = getSlackApp();
     if (!app) {
       console.warn("[Jira webhook keepalive] Slack not available, cannot send notification");
@@ -33897,7 +35013,7 @@ async function deleteJiraWebhook(webhookId) {
   console.log(`[Jira webhook keepalive] Deleted webhook id=${webhookId}`);
 }
 async function overwriteWebhookIds(next) {
-  const { getDbClient } = await import("./db-xsjg9jqq.js");
+  const { getDbClient } = await import("./db-7gbc53fd.js");
   await getDbClient().transaction(async (tx) => {
     const row = await tx.get("SELECT metadata FROM oauth_apps WHERE provider = 'jira'");
     if (!row) {
@@ -34004,7 +35120,7 @@ function stopJiraWebhookKeepalive() {
 }
 
 // src/jira/app.ts
-var initialized5 = false;
+var initialized6 = false;
 function isJiraEnabled() {
   if (isEnvFlagEnabled("JIRA_DISABLE", false))
     return false;
@@ -34016,12 +35132,12 @@ function resetJira() {
   resetBotAccountIdCache();
   teardownJiraOutboundSync();
   stopJiraWebhookKeepalive();
-  initialized5 = false;
+  initialized6 = false;
 }
 async function initJira() {
-  if (initialized5)
+  if (initialized6)
     return isJiraEnabled();
-  initialized5 = true;
+  initialized6 = true;
   if (!isJiraEnabled()) {
     console.log("[Jira] Integration disabled or JIRA_CLIENT_ID not set");
     return false;
@@ -34078,7 +35194,7 @@ function synthesizeDeliveryId(body, rawBody) {
   const hash = createHash2("sha256").update(rawBody).digest("hex").slice(0, 16);
   return `${event}:${ts}:${entityId}:${hash}`;
 }
-async function isDuplicateDelivery(deliveryId) {
+async function isDuplicateDelivery2(deliveryId) {
   return await hasTrackerDelivery("jira", deliveryId);
 }
 async function markDelivery(externalId, deliveryId) {
@@ -34101,7 +35217,7 @@ async function handleJiraWebhook(pathToken, rawBody) {
     return { status: 200, body: { status: "ignored", reason: "invalid-json" } };
   }
   const deliveryId = synthesizeDeliveryId(parsed, rawBody);
-  if (await isDuplicateDelivery(deliveryId)) {
+  if (await isDuplicateDelivery2(deliveryId)) {
     return { status: 200, body: { status: "duplicate" } };
   }
   const event = String(parsed.webhookEvent ?? "");
@@ -105920,15 +107036,15 @@ async function _fetchIssueGatingInfo(issueId) {
   const labelNames = (json.data?.issue?.labels?.nodes ?? []).map((n) => n?.name ?? "").filter((n) => n.length > 0);
   return { stateType, labelNames };
 }
-async function findLeadAgent6() {
+async function findLeadAgent7() {
   const agents = await getAllAgents2();
   const onlineLead = agents.find((a) => a.isLead && a.status !== "offline");
   if (onlineLead)
     return onlineLead;
   return agents.find((a) => a.isLead) ?? null;
 }
-var UNMAPPED_NAMESPACE4 = "integration:unmapped:linear";
-var UNMAPPED_TTL_MS4 = 30 * 24 * 60 * 60 * 1000;
+var UNMAPPED_NAMESPACE5 = "integration:unmapped:linear";
+var UNMAPPED_TTL_MS5 = 30 * 24 * 60 * 60 * 1000;
 var LINEAR_WEBHOOK_ACTOR = { kind: "system", id: "webhook:linear" };
 var APP_USER_ID_NAMESPACE = "integration:linear:bot-app-user-id";
 async function getStoredAppUserId(workspaceId) {
@@ -105959,7 +107075,7 @@ async function resolveLinearActor(linearUserId, email, name, workspaceId, sample
     return linked.id;
   }
   await upsertKv2({
-    namespace: UNMAPPED_NAMESPACE4,
+    namespace: UNMAPPED_NAMESPACE5,
     key: `${linearUserId}:meta`,
     value: {
       lastSeenAt: new Date().toISOString(),
@@ -105967,9 +107083,9 @@ async function resolveLinearActor(linearUserId, email, name, workspaceId, sample
       sampleContext: sampleContext ? sampleContext.slice(0, 100) : null
     },
     valueType: "json",
-    expiresAt: Date.now() + UNMAPPED_TTL_MS4
+    expiresAt: Date.now() + UNMAPPED_TTL_MS5
   });
-  await incrKv2(UNMAPPED_NAMESPACE4, `${linearUserId}:count`, 1);
+  await incrKv2(UNMAPPED_NAMESPACE5, `${linearUserId}:count`, 1);
   return;
 }
 var REQUEST_SECTION_LABEL = "Request (comment that opened this session)";
@@ -106081,7 +107197,7 @@ async function handleAgentSessionEvent(event) {
     }
     return;
   }
-  const lead = await findLeadAgent6();
+  const lead = await findLeadAgent7();
   const sessionSection = sessionUrl ? `
 Session: ${sessionUrl}` : "";
   const requestSection = buildSessionRequestSection(event, actorName);
@@ -106285,7 +107401,7 @@ async function handleAgentSessionPrompted(event) {
       return;
     }
   }
-  const lead = await findLeadAgent6();
+  const lead = await findLeadAgent7();
   const activity = event.agentActivity;
   const promptUser = activity?.user;
   const promptedActorLinearId = promptUser ? String(promptUser.id ?? "") : "";
@@ -106567,7 +107683,7 @@ function shouldSkipForLoopPrevention2(sync) {
 }
 
 // src/linear/app.ts
-var initialized6 = false;
+var initialized7 = false;
 var unsubscribeRefresh = null;
 function isLinearEnabled() {
   if (isEnvFlagEnabled("LINEAR_DISABLE", false))
@@ -106582,12 +107698,12 @@ function resetLinear() {
     unsubscribeRefresh();
     unsubscribeRefresh = null;
   }
-  initialized6 = false;
+  initialized7 = false;
 }
 async function initLinear() {
-  if (initialized6)
+  if (initialized7)
     return isLinearEnabled();
-  initialized6 = true;
+  initialized7 = true;
   if (!isLinearEnabled()) {
     console.log("[Linear] Integration disabled or LINEAR_CLIENT_ID not set");
     return false;
@@ -106997,11 +108113,34 @@ function parseCookieHeader(cookieHeader, name) {
   const match = header.match(re);
   return match ? match[1] : undefined;
 }
-async function extractAndVerifyCookie(req) {
-  const token = parseCookieHeader(req.headers.cookie, "page_session");
-  if (!token)
+var LEGACY_PAGE_SESSION_COOKIE = "page_session";
+var COOKIE_SAFE_PAGE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+function isCookieSafePageId(pageId) {
+  return COOKIE_SAFE_PAGE_ID.test(pageId);
+}
+function pageSessionCookieName(pageId) {
+  return `${LEGACY_PAGE_SESSION_COOKIE}_${pageId}`;
+}
+async function verifyNamedCookie(req, name) {
+  const token = parseCookieHeader(req.headers.cookie, name);
+  const payload = await verifyPageSession(token);
+  return payload && token ? { token, payload } : null;
+}
+async function extractPageSession(req, pageId) {
+  if (!isCookieSafePageId(pageId))
     return null;
-  return verifyPageSession(token);
+  for (const name of [pageSessionCookieName(pageId), LEGACY_PAGE_SESSION_COOKIE]) {
+    const session = await verifyNamedCookie(req, name);
+    if (session?.payload.pageId === pageId)
+      return session;
+  }
+  return null;
+}
+async function extractLegacyPageSession(req) {
+  return verifyNamedCookie(req, LEGACY_PAGE_SESSION_COOKIE);
+}
+async function extractAndVerifyCookie(req, pageId) {
+  return (await extractPageSession(req, pageId))?.payload ?? null;
 }
 var PAGE_SESSION_TTL_SECONDS = 3600;
 async function issuePageSessionCookie(pageId, opts) {
@@ -107013,13 +108152,11 @@ async function issuePageSessionCookie(pageId, opts) {
     ...opts.name ? { name: opts.name } : {},
     ...opts.op ? { op: true } : {}
   });
-  const attrs = [
-    `page_session=${token}`,
-    "HttpOnly",
-    "Path=/",
-    `Max-Age=${PAGE_SESSION_TTL_SECONDS}`
-  ];
-  if (opts.dev) {
+  return buildCookie(pageSessionCookieName(pageId), token, PAGE_SESSION_TTL_SECONDS, opts.dev);
+}
+function buildCookie(name, value, maxAge, dev) {
+  const attrs = [`${name}=${value}`, "HttpOnly", "Path=/", `Max-Age=${maxAge}`];
+  if (dev) {
     attrs.push("SameSite=Lax");
   } else {
     attrs.push("SameSite=None");
@@ -107027,6 +108164,30 @@ async function issuePageSessionCookie(pageId, opts) {
   }
   return attrs.join("; ");
 }
+var MAX_PAGE_SESSION_COOKIES = 20;
+var PAGE_SESSION_COOKIE_RE = new RegExp(`(?:^|;\\s*)(${LEGACY_PAGE_SESSION_COOKIE}_[A-Za-z0-9_-]{1,64})=([^;]*)`, "g");
+async function pageSessionSetCookies(req, pageId, opts) {
+  const issued = await issuePageSessionCookie(pageId, opts);
+  const header = Array.isArray(req.headers.cookie) ? req.headers.cookie.join("; ") : req.headers.cookie ?? "";
+  const keep = [];
+  const evict = new Set;
+  const seen = new Set([pageSessionCookieName(pageId)]);
+  for (const [, name, token] of header.matchAll(PAGE_SESSION_COOKIE_RE)) {
+    if (!name || seen.has(name))
+      continue;
+    seen.add(name);
+    const payload = await verifyPageSession(token);
+    if (payload && name === pageSessionCookieName(payload.pageId)) {
+      keep.push({ name, exp: payload.exp, order: keep.length });
+    } else {
+      evict.add(name);
+    }
+  }
+  keep.sort((a, b) => b.exp - a.exp || b.order - a.order);
+  for (const { name } of keep.slice(MAX_PAGE_SESSION_COOKIES - 1))
+    evict.add(name);
+  return [issued, ...[...evict].map((name) => buildCookie(name, "", 0, opts.dev))];
+}
 
 // src/http/auth.ts
 function extractBearer(req) {
@@ -107247,14 +108408,14 @@ async function reloadGlobalConfigsAndIntegrations() {
   return runWithoutRequestAuth(() => reloadGlobalConfigsAndIntegrationsInner());
 }
 async function reloadGlobalConfigsAndIntegrationsInner() {
-  const { getEmbeddingProvider, resetEmbeddingProvider } = await import("./index-ww2vznkp.js");
+  const { getEmbeddingProvider, resetEmbeddingProvider } = await import("./index-sepja052.js");
   const wasEmbeddingsConfigured = getEmbeddingProvider().isConfigured();
   const updated = await loadGlobalConfigsIntoEnv(true);
   await syncTelemetryEnabled("settings").catch((err) => {
     console.error("[config-reload] telemetry re-init failed (non-fatal):", err);
   });
   await stopSlackApp2();
-  const { resetFileStorageProvider } = await import("./registry-rxw10xzg.js");
+  const { resetFileStorageProvider } = await import("./registry-ajhexe44.js");
   resetFileStorageProvider();
   resetEmbeddingProvider();
   const isEmbeddingsConfigured = getEmbeddingProvider().isConfigured();
@@ -107263,10 +108424,10 @@ async function reloadGlobalConfigsAndIntegrationsInner() {
     integrations.push("embeddings");
   }
   if (!wasEmbeddingsConfigured && isEmbeddingsConfigured) {
-    import("./boot-reembed-srp6v6af.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
+    import("./boot-reembed-n4wq5dd2.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
       console.error("[config-reload] memory backfill failed (non-fatal):", err);
     });
-    import("./boot-reembed-xns7h5h9.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
+    import("./boot-reembed-4xwq5tg0.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
       console.error("[config-reload] script backfill failed (non-fatal):", err);
     });
   }
@@ -107288,6 +108449,11 @@ async function reloadGlobalConfigsAndIntegrationsInner() {
   teardownAzureDevOpsOutbound();
   if (isAzureDevOpsEnabled())
     initAzureDevOpsOutbound();
+  resetBitbucket();
+  resetBitbucketBotCache();
+  initBitbucket();
+  if (isBitbucketEnabled())
+    integrations.push("bitbucket");
   resetLinear();
   if (await initLinear())
     integrations.push("linear");
@@ -107678,6 +108844,10 @@ async function handleCore(req, res, myAgentId, apiKey) {
   return false;
 }
 
+// src/mcp-limits.ts
+var MCP_MAX_TOOL_INPUT_ELEMENTS = 25000;
+var MCP_MAX_REQUEST_BODY_BYTES = 4 * 1024 * 1024;
+
 // src/server.ts
 init_resolver();
 init_rbac();
@@ -112726,9 +113896,11 @@ var registerCancelTaskTool = (server) => {
 init_zod();
 
 // src/tools/chat-access.ts
+init_zod();
 init_db3();
 init_rbac();
 init_context_key();
+var chatAttachmentsSchema = array2(string2().min(1)).max(10).optional().describe("Files to send after the text, up to 10: attachment ids of your current task (from get-task-details) or file paths in your agent-fs drive, such as thoughts/<agent-id>/report.pdf, read with your own agent-fs credential. Telegram shows JPEG and PNG as photos, MP4 as video, MP3 and M4A as audio, and anything else as a document. A file over the platform upload limit (Telegram 50 MB, Discord 10 MB) is not sent, and the thread gets a note naming it.");
 async function callerChatThread(requestInfo) {
   if (!requestInfo.agentId)
     return null;
@@ -112809,16 +113981,18 @@ var registerChatPostTool = (server) => {
       adapter: _enum2(CHAT_SDK_ADAPTER_NAMES).describe("Chat SDK adapter name."),
       threadId: string2().min(1).optional().describe("Full SDK thread id, such as telegram:12345 or slack:C123:1700000000.000100."),
       channelId: string2().min(1).optional().describe("Full SDK channel id, such as slack:C123. Ignored when threadId is set."),
-      text: string2().min(1).max(20000).describe("Markdown text to post.")
+      text: string2().min(1).max(20000).describe("Markdown text to post."),
+      attachments: chatAttachmentsSchema
     }),
     outputSchema: swarmToolOutputSchema({
       yourAgentId: string2().optional(),
       messageId: string2().optional(),
       adapter: string2().optional(),
       threadId: string2().optional(),
-      channelId: string2().optional()
+      channelId: string2().optional(),
+      unsentFiles: array2(looseObject({ name: string2().optional(), reason: string2().optional() })).optional()
     })
-  }, async ({ adapter, threadId, channelId, text }, requestInfo) => {
+  }, async ({ adapter, threadId, channelId, text, attachments }, requestInfo) => {
     const data = { yourAgentId: requestInfo.agentId };
     const target = threadId ?? channelId;
     if (!target)
@@ -112829,20 +114003,25 @@ var registerChatPostTool = (server) => {
     if (!await canUseChatVerb(requestInfo, "integration.chat.post")) {
       return toolErr("Permission denied. Only the lead can post outside the thread of its task. Use chat-reply for the thread of your current task.", { data });
     }
+    const resolved = await resolveChatAttachmentRefs(attachments ?? [], requestInfo.sourceTaskId, requestInfo.agentId);
+    if ("error" in resolved)
+      return toolErr(resolved.error, { data });
     try {
       const sent = await postChatMessage({
         adapter,
         ...threadId ? { threadId } : { channelId },
         text,
-        taskId: requestInfo.sourceTaskId
+        taskId: requestInfo.sourceTaskId,
+        files: resolved.files
       });
-      return toolOk(`Posted to ${adapter} ${threadId ? "thread" : "channel"} ${target}.`, {
+      return toolOk(`Posted to ${adapter} ${threadId ? "thread" : "channel"} ${target}.${unsentFilesSummary(sent.unsentFiles)}`, {
         data: {
           ...data,
           messageId: sent.messageIds.at(-1),
           adapter: sent.adapter,
           threadId: sent.threadId,
-          channelId: sent.channelId
+          channelId: sent.channelId,
+          unsentFiles: sent.unsentFiles
         }
       });
     } catch (error) {
@@ -112923,18 +114102,20 @@ init_context_key();
 var registerChatReplyTool = (server) => {
   createToolRegistrar(server)("chat-reply", {
     title: "Reply in the chat thread of this task",
-    description: "Post a message to the Telegram, Slack, Discord or Teams thread your current task came from. Works only on a task whose contextKey starts with task:chat-sdk:. The task's final output is posted to the thread automatically when the task ends, so use this only for a question to the user or a short progress note on long work. Markdown is supported; long text is split into several messages.",
+    description: "Post a message to the Telegram, Slack, Discord or Teams thread your current task came from. Works only on a task whose contextKey starts with task:chat-sdk:. The task's final output is posted to the thread automatically when the task ends, so use this only for a question to the user, a short progress note on long work, or to send files (attachments). Markdown is supported; long text is split into several messages. When the final output of a task is posted, the files attached to that task go with it.",
     annotations: { openWorldHint: true },
     inputSchema: object2({
-      text: string2().min(1).max(20000).describe("Markdown text to post to the thread.")
+      text: string2().min(1).max(20000).describe("Markdown text to post to the thread."),
+      attachments: chatAttachmentsSchema
     }),
     outputSchema: swarmToolOutputSchema({
       yourAgentId: string2().optional(),
       messageId: string2().optional(),
       adapter: string2().optional(),
-      threadId: string2().optional()
+      threadId: string2().optional(),
+      unsentFiles: array2(looseObject({ name: string2().optional(), reason: string2().optional() })).optional()
     })
-  }, async ({ text }, requestInfo) => {
+  }, async ({ text, attachments }, requestInfo) => {
     if (!requestInfo.agentId)
       return toolErr("Agent ID not found.");
     const data = { yourAgentId: requestInfo.agentId };
@@ -112948,19 +114129,24 @@ var registerChatReplyTool = (server) => {
     if (!thread) {
       return toolErr(`Task ${task.id} did not come from a chat thread (no task:chat-sdk contextKey). Use the tool of the channel the task came from.`, { data });
     }
+    const resolved = await resolveChatAttachmentRefs(attachments ?? [], task.id, requestInfo.agentId);
+    if ("error" in resolved)
+      return toolErr(resolved.error, { data });
     try {
       const sent = await postChatMessage({
         adapter: thread.adapter,
         threadId: thread.threadId,
         text,
-        taskId: task.id
+        taskId: task.id,
+        files: resolved.files
       });
-      return toolOk(`Posted to ${thread.adapter} thread ${sent.threadId}.`, {
+      return toolOk(`Posted to ${thread.adapter} thread ${sent.threadId}.${unsentFilesSummary(sent.unsentFiles)}`, {
         data: {
           ...data,
           messageId: sent.messageIds.at(-1),
           adapter: sent.adapter,
-          threadId: sent.threadId
+          threadId: sent.threadId,
+          unsentFiles: sent.unsentFiles
         }
       });
     } catch (error) {
@@ -114448,8 +115634,523 @@ init_db3();
 
 // src/tasks/task-terminal-effects.ts
 init_db3();
+
+// src/be/chunking.ts
+var MAX_CHUNK_SIZE = 2000;
+var CHUNK_OVERLAP = 100;
+var MIN_CHUNK_SIZE = 50;
+function chunkContent(text) {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.length < MIN_CHUNK_SIZE) {
+    return [];
+  }
+  if (trimmed.length <= MAX_CHUNK_SIZE) {
+    return [{ content: trimmed, chunkIndex: 0, totalChunks: 1, headings: [] }];
+  }
+  const sections = splitByHeaders(trimmed);
+  const rawChunks = [];
+  for (const section of sections) {
+    if (section.content.length <= MAX_CHUNK_SIZE) {
+      rawChunks.push(section);
+    } else {
+      const subChunks = recursiveSplit(section.content);
+      for (const sub of subChunks) {
+        rawChunks.push({ content: sub, headings: section.headings });
+      }
+    }
+  }
+  const packed = packSmallSections(rawChunks);
+  return packed.map((c, i) => ({
+    content: c.content,
+    chunkIndex: i,
+    totalChunks: packed.length,
+    headings: c.headings
+  }));
+}
+function renderSection(section) {
+  return section.headings.length > 0 ? `${section.headings.join(" > ")}
+
+${section.content}` : section.content;
+}
+function packSmallSections(sections) {
+  const out = [];
+  let pending = null;
+  const flush = () => {
+    if (pending)
+      out.push({ content: pending.parts.join(`
+
+`), headings: pending.headings });
+    pending = null;
+  };
+  for (const section of sections) {
+    const rendered = renderSection(section);
+    if (section.content.trim().length >= MIN_CHUNK_SIZE) {
+      flush();
+      out.push({ content: rendered, headings: section.headings });
+      continue;
+    }
+    if (pending && pending.length + 2 + rendered.length > MAX_CHUNK_SIZE)
+      flush();
+    if (pending) {
+      pending.parts.push(rendered);
+      pending.length += 2 + rendered.length;
+    } else {
+      pending = { parts: [rendered], length: rendered.length, headings: section.headings };
+    }
+  }
+  flush();
+  return out;
+}
+function splitByHeaders(text) {
+  const lines = text.split(`
+`);
+  const sections = [];
+  let currentContent = [];
+  const headingStack = [];
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,3})\s+(.+)$/);
+    if (headingMatch) {
+      if (currentContent.length > 0) {
+        const content = currentContent.join(`
+`).trim();
+        if (content) {
+          sections.push({ content, headings: [...headingStack] });
+        }
+        currentContent = [];
+      }
+      const level = headingMatch[1].length;
+      const title = headingMatch[2].trim();
+      while (headingStack.length >= level) {
+        headingStack.pop();
+      }
+      headingStack.push(`${"#".repeat(level)} ${title}`);
+    } else {
+      currentContent.push(line);
+    }
+  }
+  if (currentContent.length > 0) {
+    const content = currentContent.join(`
+`).trim();
+    if (content) {
+      sections.push({ content, headings: [...headingStack] });
+    }
+  }
+  if (sections.length === 0) {
+    return [{ content: text, headings: [] }];
+  }
+  return sections;
+}
+var SEPARATORS = [`
+
+`, `
+`, ". ", " "];
+function recursiveSplit(text) {
+  return recursiveSplitWithSeparators(text, 0);
+}
+function recursiveSplitWithSeparators(text, separatorIndex) {
+  if (text.length <= MAX_CHUNK_SIZE) {
+    return [text.trim()].filter((s) => s.length > 0);
+  }
+  if (separatorIndex >= SEPARATORS.length) {
+    return hardSplit(text);
+  }
+  const separator = SEPARATORS[separatorIndex];
+  const parts = text.split(separator);
+  if (parts.length <= 1) {
+    return recursiveSplitWithSeparators(text, separatorIndex + 1);
+  }
+  const chunks = [];
+  let current = "";
+  for (const part of parts) {
+    const candidate = current ? current + separator + part : part;
+    if (candidate.length <= MAX_CHUNK_SIZE) {
+      current = candidate;
+    } else {
+      if (current) {
+        chunks.push(current.trim());
+      }
+      if (part.length > MAX_CHUNK_SIZE) {
+        chunks.push(...recursiveSplitWithSeparators(part, separatorIndex + 1));
+        current = "";
+      } else {
+        current = part;
+      }
+    }
+  }
+  if (current.trim()) {
+    chunks.push(current.trim());
+  }
+  return addOverlap(chunks, text);
+}
+function hardSplit(text) {
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const end = Math.min(start + MAX_CHUNK_SIZE, text.length);
+    chunks.push(text.slice(start, end).trim());
+    if (end === text.length)
+      break;
+    start = end - CHUNK_OVERLAP;
+  }
+  return chunks.filter((c) => c.length > 0);
+}
+function addOverlap(chunks, _originalText) {
+  if (chunks.length <= 1)
+    return chunks;
+  const result = [chunks[0]];
+  for (let i = 1;i < chunks.length; i++) {
+    const prevChunk = chunks[i - 1];
+    const chunk = chunks[i];
+    const overlapText = prevChunk.slice(-CHUNK_OVERLAP);
+    if (overlapText.length + chunk.length <= MAX_CHUNK_SIZE + CHUNK_OVERLAP) {
+      result.push(overlapText + chunk);
+    } else {
+      result.push(chunk);
+    }
+  }
+  return result;
+}
+
+// src/be/memory/index-content.ts
 init_memory();
 
+// src/be/memory/key-guard.ts
+init_rbac();
+init_key_paths();
+
+class MemoryKeyError extends Error {
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "MemoryKeyError";
+  }
+}
+var NO_AUTHORITY = {
+  principal: { kind: "agent", agentId: "", isLead: false },
+  source: "http"
+};
+function shapeError(key, origin) {
+  if (key.length <= MEMORY_KEY_MAX_LENGTH && MEMORY_KEY_PATTERN.test(key))
+    return null;
+  const subject = origin === "sourcePath" ? `sourcePath "${key}" starts with ${LONGTERM_ROOT}, so it is used as the key, but it is not a valid key.` : `Key "${key}" is not a valid key.`;
+  return `${subject} ${MEMORY_KEY_PATTERN_MESSAGE}`;
+}
+function assertKeyWritable(key, origin, writer) {
+  if (origin === "sourcePath" && !isLongtermKey(key))
+    return;
+  const shape = shapeError(key, origin);
+  if (shape)
+    throw new MemoryKeyError(shape, "invalid");
+  const pathError = longtermKeyError(key);
+  if (pathError)
+    throw new MemoryKeyError(pathError, "invalid");
+  if (!isConsolidatedKey(key))
+    return;
+  const { principal, source } = writer ?? NO_AUTHORITY;
+  const decision = can({
+    principal,
+    verb: "memory.write.consolidated",
+    resource: { kind: "none" },
+    source
+  });
+  if (!decision.allow)
+    throw new MemoryKeyError(consolidatedKeyMessage(key), "forbidden");
+}
+
+// src/be/memory/link-resolver.ts
+init_db3();
+init_constants2();
+var WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+var PR_HASH_RE = /(?:^|[\s(])#(\d{1,5})(?=[\s,.)!?]|$)/gm;
+var PR_PREFIX_RE = /\bPR\s*#(\d{1,5})\b/gi;
+var GITHUB_PR_URL_RE = /https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/g;
+var AGENT_FS_LIVE_HOSTS = String.raw`agent-fs|live\.agent-fs\.dev`;
+var AGENT_FS_FILE_ROUTE = String.raw`\/file\/~\/([a-f0-9-]+)\/([a-f0-9-]+)\/([\w/.%-]+)`;
+var AGENT_UI_PAGE_RE = /(?:app\.[^/]+|localhost:\d+)\/pages\/([a-f0-9-]+)/g;
+var AGENT_UI_TASK_RE = /(?:app\.[^/]+|localhost:\d+)\/tasks\/([a-f0-9-]+)/g;
+var wikilinkMatcher = (content) => {
+  const results = [];
+  for (const match of content.matchAll(WIKILINK_RE)) {
+    const name = match[1].trim();
+    if (!name)
+      continue;
+    results.push({
+      linkType: "wikilink",
+      targetKind: "memory",
+      targetId: name,
+      sourceText: match[0],
+      resolver: "wikilink"
+    });
+  }
+  return results;
+};
+var prMatcher = (content) => {
+  const results = [];
+  const seen = new Set;
+  for (const match of content.matchAll(GITHUB_PR_URL_RE)) {
+    const id = `github:${match[1]}/${match[2]}#${match[3]}`;
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: match[0],
+      resolver: "pr-url",
+      metadata: { owner: match[1], repo: match[2], number: Number(match[3]) }
+    });
+  }
+  for (const match of content.matchAll(PR_PREFIX_RE)) {
+    const id = `pr:${match[1]}`;
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: match[0].trim(),
+      resolver: "pr-prefix",
+      metadata: { number: Number(match[1]) }
+    });
+  }
+  for (const match of content.matchAll(PR_HASH_RE)) {
+    const id = `pr:${match[1]}`;
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: `#${match[1]}`,
+      resolver: "pr-hash",
+      metadata: { number: Number(match[1]) }
+    });
+  }
+  return results;
+};
+function escapeRegExp3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+function agentFsPathRegex() {
+  const appHosts = getConfiguredAppUrls().flatMap((value) => {
+    try {
+      const url = new URL(value);
+      return [escapeRegExp3(`${url.host}${url.pathname.replace(/\/+$/, "")}`)];
+    } catch {
+      return [];
+    }
+  });
+  const hosts = [AGENT_FS_LIVE_HOSTS, ...appHosts, String.raw`localhost:\d+`].join("|");
+  return new RegExp(`(?<![\\w.-])(?:${hosts})${AGENT_FS_FILE_ROUTE}`, "gi");
+}
+var agentFsMatcher = (content) => {
+  const results = [];
+  for (const match of content.matchAll(agentFsPathRegex())) {
+    const orgId = match[1];
+    const driveId = match[2];
+    const path = match[3];
+    results.push({
+      linkType: "agent-fs-file",
+      targetKind: "agent-fs-file",
+      targetId: `${orgId}/${driveId}/${path}`,
+      sourceText: match[0],
+      resolver: "agent-fs-path",
+      metadata: { orgId, driveId, path }
+    });
+  }
+  return results;
+};
+var agentUiMatcher = (content) => {
+  const results = [];
+  for (const match of content.matchAll(AGENT_UI_PAGE_RE)) {
+    results.push({
+      linkType: "agent-ui",
+      targetKind: "agent-ui",
+      targetId: `page:${match[1]}`,
+      sourceText: match[0],
+      resolver: "agent-ui-page"
+    });
+  }
+  for (const match of content.matchAll(AGENT_UI_TASK_RE)) {
+    results.push({
+      linkType: "agent-ui",
+      targetKind: "agent-ui",
+      targetId: `task:${match[1]}`,
+      sourceText: match[0],
+      resolver: "agent-ui-task"
+    });
+  }
+  return results;
+};
+var MATCHERS = [wikilinkMatcher, prMatcher, agentFsMatcher, agentUiMatcher];
+function resolveLinks(content) {
+  const results = [];
+  for (const matcher of MATCHERS) {
+    for (const link of matcher(content)) {
+      results.push({ ...link, strength: 1 });
+    }
+  }
+  return results;
+}
+async function resolveWikilinksToMemoryIds(agentId, links) {
+  const db = getDbClient2();
+  const resolved = [];
+  for (const link of links) {
+    if (link.linkType !== "wikilink") {
+      resolved.push(link);
+      continue;
+    }
+    const row = await db.get("SELECT id FROM agent_memory WHERE name = ? AND (agentId = ? OR scope = 'swarm') LIMIT 1", [link.targetId, agentId]);
+    resolved.push(row ? { ...link, targetId: row.id } : link);
+  }
+  return resolved;
+}
+var INSERT_LINK_SQL = `INSERT OR IGNORE INTO memory_link
+   (id, from_memory_id, linkType, targetKind, targetId, strength, resolver, sourceText, metadata, createdAt, updatedAt)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+function insertLinkArgs(memoryId, link, now) {
+  return [
+    crypto.randomUUID(),
+    memoryId,
+    link.linkType,
+    link.targetKind,
+    link.targetId,
+    link.strength,
+    link.resolver,
+    link.sourceText,
+    link.metadata ? JSON.stringify(link.metadata) : null,
+    now,
+    now
+  ];
+}
+async function storeLinks(memoryId, agentId, content) {
+  const links = resolveLinks(content);
+  if (links.length === 0)
+    return;
+  const resolved = await resolveWikilinksToMemoryIds(agentId, links);
+  const now = new Date().toISOString();
+  await getDbClient2().transaction(async (tx) => {
+    for (const link of resolved) {
+      await tx.run(INSERT_LINK_SQL, insertLinkArgs(memoryId, link, now));
+    }
+  });
+}
+function linkIdentity2(link) {
+  return JSON.stringify([link.linkType, link.targetKind, link.targetId, link.sourceText ?? null]);
+}
+async function refreshLinks(memoryId, agentId, content) {
+  const resolved = await resolveWikilinksToMemoryIds(agentId, resolveLinks(content));
+  const nextIdentities = new Set(resolved.map((link) => linkIdentity2(link)));
+  const now = new Date().toISOString();
+  await getDbClient2().transaction(async (tx) => {
+    const existing = await tx.query(`SELECT id, linkType, targetKind, targetId, sourceText
+       FROM memory_link
+      WHERE from_memory_id = ? AND linkType != 'sequel'`, [memoryId]);
+    for (const row of existing) {
+      if (!nextIdentities.has(linkIdentity2(row))) {
+        await tx.run("DELETE FROM memory_link WHERE id = ?", [row.id]);
+      }
+    }
+    for (const link of resolved) {
+      await tx.run(INSERT_LINK_SQL, insertLinkArgs(memoryId, link, now));
+    }
+  });
+}
+
+// src/be/memory/index-content.ts
+init_secret_scrubber();
+function taskCompletionMemoryKey(taskId) {
+  return `/task-completions/${taskId.toLowerCase().replace(/[^a-z0-9._-]/g, "-")}`;
+}
+async function indexMemoryContent(params) {
+  const { agentId, content, name, scope, source, sourceTaskId, sourcePath, tags } = params;
+  const rowKey = params.key ?? (sourcePath || null);
+  if (rowKey)
+    assertKeyWritable(rowKey, params.key != null ? "key" : "sourcePath", params.writer);
+  const contentChunks = chunkContent(content);
+  if (contentChunks.length === 0) {
+    contentChunks.push({
+      content: content.trim(),
+      chunkIndex: 0,
+      totalChunks: 1,
+      headings: []
+    });
+  }
+  const store = getMemoryStore2();
+  const provider = getEmbeddingProvider2();
+  if (sourcePath && agentId && contentChunks.length === 1) {
+    const existing = (await store.list(agentId, {
+      scope,
+      limit: 2,
+      ownerAgentId: agentId,
+      sourcePath
+    })).filter((memory) => memory.sourcePath === sourcePath);
+    if (existing.length === 1 && existing[0]?.totalChunks === 1) {
+      const result = await store.edit({
+        id: existing[0].id,
+        mode: "replace",
+        content: contentChunks[0].content,
+        intent: "re-index memory source path",
+        changedByAgentId: agentId
+      });
+      const embedding = await provider.embed(result.memory.content);
+      if (embedding)
+        await store.updateEmbedding(result.memory.id, embedding, provider.name);
+      try {
+        await refreshLinks(result.memory.id, agentId, result.memory.content);
+      } catch (err) {
+        console.error(`[memory] Link resolution failed for ${result.memory.id}:`, err.message);
+      }
+      return { queued: false, memoryIds: [result.memory.id], edited: result.changed, chunks: 1 };
+    }
+  }
+  if (sourcePath && agentId) {
+    await store.deleteBySourcePath(sourcePath, agentId);
+  }
+  const inputs = contentChunks.map((chunk) => ({
+    agentId: agentId || null,
+    content: chunk.content,
+    name,
+    scope,
+    source,
+    sourcePath: sourcePath || null,
+    sourceTaskId: sourceTaskId || null,
+    chunkIndex: chunk.chunkIndex,
+    totalChunks: chunk.totalChunks,
+    tags: tags || [],
+    contextKey: params.contextKey ?? null,
+    intent: params.intent ?? "index memory content",
+    key: rowKey
+  }));
+  const memories = params.replaceExisting && params.key ? await store.replaceDocument({ key: params.key, scope, agentId: agentId || null, source }, inputs) : await store.storeBatch(inputs);
+  if (agentId) {
+    for (const memory of memories) {
+      try {
+        await storeLinks(memory.id, agentId, memory.content);
+      } catch (err) {
+        console.error(`[memory] Link resolution failed for ${memory.id}:`, err.message);
+      }
+    }
+  }
+  (async () => {
+    try {
+      const embeddings = await provider.embedBatch(memories.map((m) => m.content));
+      for (let i = 0;i < embeddings.length; i++) {
+        if (embeddings[i]) {
+          await store.updateEmbedding(memories[i].id, embeddings[i], provider.name);
+        }
+      }
+    } catch (err) {
+      console.error("[memory] Batch embedding failed:", err.message);
+    }
+  })().catch((err) => console.error("[memory] batch embed failed:", scrubSecrets(err instanceof Error ? err.message : String(err))));
+  return { queued: true, memoryIds: memories.map((m) => m.id), chunks: contentChunks.length };
+}
+
 // src/be/memory/raters/retrieval.ts
 init_db3();
 function dedupeMemoryDocumentIds(memories) {
@@ -115205,40 +116906,39 @@ ${safeFailureReason || "No reason provided"}
 This task failed. Learn from this to avoid repeating the mistake.`;
         if (taskContent.length < 30)
           return;
-        const store = getMemoryStore2();
-        const provider = getEmbeddingProvider2();
-        const memory = await store.store({
+        const key = taskCompletionMemoryKey(taskId);
+        await indexMemoryContent({
           agentId: agentId ?? null,
           content: taskContent,
           name: `Task: ${safeTask.slice(0, 80)}`,
           scope: "agent",
           source: "task_completion",
-          sourceTaskId: taskId
+          sourceTaskId: taskId,
+          key,
+          intent: "task completion memory",
+          replaceExisting: true
         });
-        const embedding = await provider.embed(taskContent);
-        if (embedding) {
-          await store.updateEmbedding(memory.id, embedding, provider.name);
-        }
         const shouldShareWithSwarm = status === "completed" && (task.taskType === "research" || task.tags?.includes("knowledge") || task.tags?.includes("shared"));
         if (shouldShareWithSwarm) {
           try {
-            const swarmMemory = await store.store({
+            await indexMemoryContent({
               agentId: agentId ?? null,
-              scope: "swarm",
-              name: `Shared: ${safeTask.slice(0, 80)}`,
               content: `Task completed by agent ${agentId}:
 
 ${taskContent}`,
+              name: `Shared: ${safeTask.slice(0, 80)}`,
+              scope: "swarm",
               source: "task_completion",
-              sourceTaskId: taskId
+              sourceTaskId: taskId,
+              key,
+              intent: "task completion memory",
+              replaceExisting: true
             });
-            const swarmEmbedding = await provider.embed(taskContent);
-            if (swarmEmbedding) {
-              await store.updateEmbedding(swarmMemory.id, swarmEmbedding, provider.name);
-            }
           } catch {}
         }
-      } catch {}
+      } catch (err) {
+        console.error("[task-terminal-effects] task completion memory write failed:", scrubSecrets(err instanceof Error ? err.message : String(err)));
+      }
     })().catch((err) => console.error("[task-terminal-effects] task completion memory write failed:", scrubSecrets(err instanceof Error ? err.message : String(err))));
   }
   (async () => {
@@ -117929,258 +119629,7 @@ var registerMemoryDeleteTool = (server) => {
 init_zod();
 init_db3();
 init_memory();
-
-// src/be/memory/key-guard.ts
-init_rbac();
 init_key_paths();
-
-class MemoryKeyError extends Error {
-  reason;
-  constructor(message, reason) {
-    super(message);
-    this.reason = reason;
-    this.name = "MemoryKeyError";
-  }
-}
-var NO_AUTHORITY = {
-  principal: { kind: "agent", agentId: "", isLead: false },
-  source: "http"
-};
-function shapeError(key, origin) {
-  if (key.length <= MEMORY_KEY_MAX_LENGTH && MEMORY_KEY_PATTERN.test(key))
-    return null;
-  const subject = origin === "sourcePath" ? `sourcePath "${key}" starts with ${LONGTERM_ROOT}, so it is used as the key, but it is not a valid key.` : `Key "${key}" is not a valid key.`;
-  return `${subject} ${MEMORY_KEY_PATTERN_MESSAGE}`;
-}
-function assertKeyWritable(key, origin, writer) {
-  if (origin === "sourcePath" && !isLongtermKey(key))
-    return;
-  const shape = shapeError(key, origin);
-  if (shape)
-    throw new MemoryKeyError(shape, "invalid");
-  const pathError = longtermKeyError(key);
-  if (pathError)
-    throw new MemoryKeyError(pathError, "invalid");
-  if (!isConsolidatedKey(key))
-    return;
-  const { principal, source } = writer ?? NO_AUTHORITY;
-  const decision = can({
-    principal,
-    verb: "memory.write.consolidated",
-    resource: { kind: "none" },
-    source
-  });
-  if (!decision.allow)
-    throw new MemoryKeyError(consolidatedKeyMessage(key), "forbidden");
-}
-
-// src/tools/memory-edit.ts
-init_key_paths();
-
-// src/be/memory/link-resolver.ts
-init_db3();
-init_constants2();
-var WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
-var PR_HASH_RE = /(?:^|[\s(])#(\d{1,5})(?=[\s,.)!?]|$)/gm;
-var PR_PREFIX_RE = /\bPR\s*#(\d{1,5})\b/gi;
-var GITHUB_PR_URL_RE = /https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/g;
-var AGENT_FS_LIVE_HOSTS = String.raw`agent-fs|live\.agent-fs\.dev`;
-var AGENT_FS_FILE_ROUTE = String.raw`\/file\/~\/([a-f0-9-]+)\/([a-f0-9-]+)\/([\w/.%-]+)`;
-var AGENT_UI_PAGE_RE = /(?:app\.[^/]+|localhost:\d+)\/pages\/([a-f0-9-]+)/g;
-var AGENT_UI_TASK_RE = /(?:app\.[^/]+|localhost:\d+)\/tasks\/([a-f0-9-]+)/g;
-var wikilinkMatcher = (content) => {
-  const results = [];
-  for (const match of content.matchAll(WIKILINK_RE)) {
-    const name = match[1].trim();
-    if (!name)
-      continue;
-    results.push({
-      linkType: "wikilink",
-      targetKind: "memory",
-      targetId: name,
-      sourceText: match[0],
-      resolver: "wikilink"
-    });
-  }
-  return results;
-};
-var prMatcher = (content) => {
-  const results = [];
-  const seen = new Set;
-  for (const match of content.matchAll(GITHUB_PR_URL_RE)) {
-    const id = `github:${match[1]}/${match[2]}#${match[3]}`;
-    if (seen.has(id))
-      continue;
-    seen.add(id);
-    results.push({
-      linkType: "pr",
-      targetKind: "pr",
-      targetId: id,
-      sourceText: match[0],
-      resolver: "pr-url",
-      metadata: { owner: match[1], repo: match[2], number: Number(match[3]) }
-    });
-  }
-  for (const match of content.matchAll(PR_PREFIX_RE)) {
-    const id = `pr:${match[1]}`;
-    if (seen.has(id))
-      continue;
-    seen.add(id);
-    results.push({
-      linkType: "pr",
-      targetKind: "pr",
-      targetId: id,
-      sourceText: match[0].trim(),
-      resolver: "pr-prefix",
-      metadata: { number: Number(match[1]) }
-    });
-  }
-  for (const match of content.matchAll(PR_HASH_RE)) {
-    const id = `pr:${match[1]}`;
-    if (seen.has(id))
-      continue;
-    seen.add(id);
-    results.push({
-      linkType: "pr",
-      targetKind: "pr",
-      targetId: id,
-      sourceText: `#${match[1]}`,
-      resolver: "pr-hash",
-      metadata: { number: Number(match[1]) }
-    });
-  }
-  return results;
-};
-function escapeRegExp2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
-}
-function agentFsPathRegex() {
-  const appHosts = getConfiguredAppUrls().flatMap((value) => {
-    try {
-      const url = new URL(value);
-      return [escapeRegExp2(`${url.host}${url.pathname.replace(/\/+$/, "")}`)];
-    } catch {
-      return [];
-    }
-  });
-  const hosts = [AGENT_FS_LIVE_HOSTS, ...appHosts, String.raw`localhost:\d+`].join("|");
-  return new RegExp(`(?<![\\w.-])(?:${hosts})${AGENT_FS_FILE_ROUTE}`, "gi");
-}
-var agentFsMatcher = (content) => {
-  const results = [];
-  for (const match of content.matchAll(agentFsPathRegex())) {
-    const orgId = match[1];
-    const driveId = match[2];
-    const path = match[3];
-    results.push({
-      linkType: "agent-fs-file",
-      targetKind: "agent-fs-file",
-      targetId: `${orgId}/${driveId}/${path}`,
-      sourceText: match[0],
-      resolver: "agent-fs-path",
-      metadata: { orgId, driveId, path }
-    });
-  }
-  return results;
-};
-var agentUiMatcher = (content) => {
-  const results = [];
-  for (const match of content.matchAll(AGENT_UI_PAGE_RE)) {
-    results.push({
-      linkType: "agent-ui",
-      targetKind: "agent-ui",
-      targetId: `page:${match[1]}`,
-      sourceText: match[0],
-      resolver: "agent-ui-page"
-    });
-  }
-  for (const match of content.matchAll(AGENT_UI_TASK_RE)) {
-    results.push({
-      linkType: "agent-ui",
-      targetKind: "agent-ui",
-      targetId: `task:${match[1]}`,
-      sourceText: match[0],
-      resolver: "agent-ui-task"
-    });
-  }
-  return results;
-};
-var MATCHERS = [wikilinkMatcher, prMatcher, agentFsMatcher, agentUiMatcher];
-function resolveLinks(content) {
-  const results = [];
-  for (const matcher of MATCHERS) {
-    for (const link of matcher(content)) {
-      results.push({ ...link, strength: 1 });
-    }
-  }
-  return results;
-}
-async function resolveWikilinksToMemoryIds(agentId, links) {
-  const db = getDbClient2();
-  const resolved = [];
-  for (const link of links) {
-    if (link.linkType !== "wikilink") {
-      resolved.push(link);
-      continue;
-    }
-    const row = await db.get("SELECT id FROM agent_memory WHERE name = ? AND (agentId = ? OR scope = 'swarm') LIMIT 1", [link.targetId, agentId]);
-    resolved.push(row ? { ...link, targetId: row.id } : link);
-  }
-  return resolved;
-}
-var INSERT_LINK_SQL = `INSERT OR IGNORE INTO memory_link
-   (id, from_memory_id, linkType, targetKind, targetId, strength, resolver, sourceText, metadata, createdAt, updatedAt)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
-function insertLinkArgs(memoryId, link, now) {
-  return [
-    crypto.randomUUID(),
-    memoryId,
-    link.linkType,
-    link.targetKind,
-    link.targetId,
-    link.strength,
-    link.resolver,
-    link.sourceText,
-    link.metadata ? JSON.stringify(link.metadata) : null,
-    now,
-    now
-  ];
-}
-async function storeLinks(memoryId, agentId, content) {
-  const links = resolveLinks(content);
-  if (links.length === 0)
-    return;
-  const resolved = await resolveWikilinksToMemoryIds(agentId, links);
-  const now = new Date().toISOString();
-  await getDbClient2().transaction(async (tx) => {
-    for (const link of resolved) {
-      await tx.run(INSERT_LINK_SQL, insertLinkArgs(memoryId, link, now));
-    }
-  });
-}
-function linkIdentity2(link) {
-  return JSON.stringify([link.linkType, link.targetKind, link.targetId, link.sourceText ?? null]);
-}
-async function refreshLinks(memoryId, agentId, content) {
-  const resolved = await resolveWikilinksToMemoryIds(agentId, resolveLinks(content));
-  const nextIdentities = new Set(resolved.map((link) => linkIdentity2(link)));
-  const now = new Date().toISOString();
-  await getDbClient2().transaction(async (tx) => {
-    const existing = await tx.query(`SELECT id, linkType, targetKind, targetId, sourceText
-       FROM memory_link
-      WHERE from_memory_id = ? AND linkType != 'sequel'`, [memoryId]);
-    for (const row of existing) {
-      if (!nextIdentities.has(linkIdentity2(row))) {
-        await tx.run("DELETE FROM memory_link WHERE id = ?", [row.id]);
-      }
-    }
-    for (const link of resolved) {
-      await tx.run(INSERT_LINK_SQL, insertLinkArgs(memoryId, link, now));
-    }
-  });
-}
-
-// src/tools/memory-edit.ts
 init_rbac();
 init_types();
 var agentMemoryOutputSchema = looseObject({
@@ -118744,6 +120193,7 @@ async function expandCandidatesWithGraph(candidates, agentId, options = {}) {
 // src/tools/memory-search.ts
 init_key_paths();
 init_reranker();
+init_search_candidates();
 init_types();
 var NUDGE_ELIGIBLE_SOURCES2 = new Set(["manual", "file_index"]);
 function rateHintFor(memoryId) {
@@ -118799,7 +120249,7 @@ var registerMemorySearchTool = (server) => {
     const store = getMemoryStore2();
     const queryEmbedding = await provider.embed(query);
     const candidateLimit = limit * CANDIDATE_SET_MULTIPLIER;
-    const candidates = await store.search(queryEmbedding ?? new Float32Array(0), requestInfo.agentId, {
+    const candidates = await searchMemoryCandidates(store, queryEmbedding ?? new Float32Array(0), requestInfo.agentId, {
       scope,
       limit: candidateLimit,
       source,
@@ -118887,242 +120337,6 @@ var registerMemorySearchTool = (server) => {
 // src/tools/memory-store.ts
 init_zod();
 init_db3();
-
-// src/be/chunking.ts
-var MAX_CHUNK_SIZE = 2000;
-var CHUNK_OVERLAP = 100;
-var MIN_CHUNK_SIZE = 50;
-function chunkContent(text) {
-  const trimmed = text.trim();
-  if (!trimmed || trimmed.length < MIN_CHUNK_SIZE) {
-    return [];
-  }
-  if (trimmed.length <= MAX_CHUNK_SIZE) {
-    return [{ content: trimmed, chunkIndex: 0, totalChunks: 1, headings: [] }];
-  }
-  const sections = splitByHeaders(trimmed);
-  const rawChunks = [];
-  for (const section of sections) {
-    if (section.content.length <= MAX_CHUNK_SIZE) {
-      rawChunks.push(section);
-    } else {
-      const subChunks = recursiveSplit(section.content);
-      for (const sub of subChunks) {
-        rawChunks.push({ content: sub, headings: section.headings });
-      }
-    }
-  }
-  const filtered = rawChunks.filter((c) => c.content.trim().length >= MIN_CHUNK_SIZE);
-  if (filtered.length === 0) {
-    return [{ content: trimmed, chunkIndex: 0, totalChunks: 1, headings: [] }];
-  }
-  return filtered.map((c, i) => ({
-    content: c.headings.length > 0 ? `${c.headings.join(" > ")}
-
-${c.content}` : c.content,
-    chunkIndex: i,
-    totalChunks: filtered.length,
-    headings: c.headings
-  }));
-}
-function splitByHeaders(text) {
-  const lines = text.split(`
-`);
-  const sections = [];
-  let currentContent = [];
-  const headingStack = [];
-  for (const line of lines) {
-    const headingMatch = line.match(/^(#{1,3})\s+(.+)$/);
-    if (headingMatch) {
-      if (currentContent.length > 0) {
-        const content = currentContent.join(`
-`).trim();
-        if (content) {
-          sections.push({ content, headings: [...headingStack] });
-        }
-        currentContent = [];
-      }
-      const level = headingMatch[1].length;
-      const title = headingMatch[2].trim();
-      while (headingStack.length >= level) {
-        headingStack.pop();
-      }
-      headingStack.push(`${"#".repeat(level)} ${title}`);
-    } else {
-      currentContent.push(line);
-    }
-  }
-  if (currentContent.length > 0) {
-    const content = currentContent.join(`
-`).trim();
-    if (content) {
-      sections.push({ content, headings: [...headingStack] });
-    }
-  }
-  if (sections.length === 0) {
-    return [{ content: text, headings: [] }];
-  }
-  return sections;
-}
-var SEPARATORS = [`
-
-`, `
-`, ". ", " "];
-function recursiveSplit(text) {
-  return recursiveSplitWithSeparators(text, 0);
-}
-function recursiveSplitWithSeparators(text, separatorIndex) {
-  if (text.length <= MAX_CHUNK_SIZE) {
-    return [text.trim()].filter((s) => s.length > 0);
-  }
-  if (separatorIndex >= SEPARATORS.length) {
-    return hardSplit(text);
-  }
-  const separator = SEPARATORS[separatorIndex];
-  const parts = text.split(separator);
-  if (parts.length <= 1) {
-    return recursiveSplitWithSeparators(text, separatorIndex + 1);
-  }
-  const chunks = [];
-  let current = "";
-  for (const part of parts) {
-    const candidate = current ? current + separator + part : part;
-    if (candidate.length <= MAX_CHUNK_SIZE) {
-      current = candidate;
-    } else {
-      if (current) {
-        chunks.push(current.trim());
-      }
-      if (part.length > MAX_CHUNK_SIZE) {
-        chunks.push(...recursiveSplitWithSeparators(part, separatorIndex + 1));
-        current = "";
-      } else {
-        current = part;
-      }
-    }
-  }
-  if (current.trim()) {
-    chunks.push(current.trim());
-  }
-  return addOverlap(chunks, text);
-}
-function hardSplit(text) {
-  const chunks = [];
-  let start = 0;
-  while (start < text.length) {
-    const end = Math.min(start + MAX_CHUNK_SIZE, text.length);
-    chunks.push(text.slice(start, end).trim());
-    if (end === text.length)
-      break;
-    start = end - CHUNK_OVERLAP;
-  }
-  return chunks.filter((c) => c.length > 0);
-}
-function addOverlap(chunks, _originalText) {
-  if (chunks.length <= 1)
-    return chunks;
-  const result = [chunks[0]];
-  for (let i = 1;i < chunks.length; i++) {
-    const prevChunk = chunks[i - 1];
-    const chunk = chunks[i];
-    const overlapText = prevChunk.slice(-CHUNK_OVERLAP);
-    if (overlapText.length + chunk.length <= MAX_CHUNK_SIZE + CHUNK_OVERLAP) {
-      result.push(overlapText + chunk);
-    } else {
-      result.push(chunk);
-    }
-  }
-  return result;
-}
-
-// src/be/memory/index-content.ts
-init_memory();
-init_secret_scrubber();
-async function indexMemoryContent(params) {
-  const { agentId, content, name, scope, source, sourceTaskId, sourcePath, tags } = params;
-  const rowKey = params.key ?? (sourcePath || null);
-  if (rowKey)
-    assertKeyWritable(rowKey, params.key != null ? "key" : "sourcePath", params.writer);
-  const contentChunks = chunkContent(content);
-  if (contentChunks.length === 0) {
-    contentChunks.push({
-      content: content.trim(),
-      chunkIndex: 0,
-      totalChunks: 1,
-      headings: []
-    });
-  }
-  const store = getMemoryStore2();
-  const provider = getEmbeddingProvider2();
-  if (sourcePath && agentId && contentChunks.length === 1) {
-    const existing = (await store.list(agentId, {
-      scope,
-      limit: 2,
-      ownerAgentId: agentId,
-      sourcePath
-    })).filter((memory) => memory.sourcePath === sourcePath);
-    if (existing.length === 1 && existing[0]?.totalChunks === 1) {
-      const result = await store.edit({
-        id: existing[0].id,
-        mode: "replace",
-        content: contentChunks[0].content,
-        intent: "re-index memory source path",
-        changedByAgentId: agentId
-      });
-      const embedding = await provider.embed(result.memory.content);
-      if (embedding)
-        await store.updateEmbedding(result.memory.id, embedding, provider.name);
-      try {
-        await refreshLinks(result.memory.id, agentId, result.memory.content);
-      } catch (err) {
-        console.error(`[memory] Link resolution failed for ${result.memory.id}:`, err.message);
-      }
-      return { queued: false, memoryIds: [result.memory.id], edited: result.changed, chunks: 1 };
-    }
-  }
-  if (sourcePath && agentId) {
-    await store.deleteBySourcePath(sourcePath, agentId);
-  }
-  const memories = await store.storeBatch(contentChunks.map((chunk) => ({
-    agentId: agentId || null,
-    content: chunk.content,
-    name,
-    scope,
-    source,
-    sourcePath: sourcePath || null,
-    sourceTaskId: sourceTaskId || null,
-    chunkIndex: chunk.chunkIndex,
-    totalChunks: chunk.totalChunks,
-    tags: tags || [],
-    contextKey: params.contextKey ?? null,
-    intent: params.intent ?? "index memory content",
-    key: rowKey
-  })));
-  if (agentId) {
-    for (const memory of memories) {
-      try {
-        await storeLinks(memory.id, agentId, memory.content);
-      } catch (err) {
-        console.error(`[memory] Link resolution failed for ${memory.id}:`, err.message);
-      }
-    }
-  }
-  (async () => {
-    try {
-      const embeddings = await provider.embedBatch(memories.map((m) => m.content));
-      for (let i = 0;i < embeddings.length; i++) {
-        if (embeddings[i]) {
-          await store.updateEmbedding(memories[i].id, embeddings[i], provider.name);
-        }
-      }
-    } catch (err) {
-      console.error("[memory] Batch embedding failed:", err.message);
-    }
-  })().catch((err) => console.error("[memory] batch embed failed:", scrubSecrets(err instanceof Error ? err.message : String(err))));
-  return { queued: true, memoryIds: memories.map((m) => m.id), chunks: contentChunks.length };
-}
-
-// src/tools/memory-store.ts
 init_key_paths();
 init_types();
 var registerMemoryStoreTool = (server) => {
@@ -129545,7 +130759,7 @@ var registerScriptConnectionsTool = (server) => {
 };
 // src/tools/script-delete.ts
 init_zod();
-var SCRIPT_DELETE_DESCRIPTION = "Remove a swarm-shared script from the catalog. Versions table preserves history.";
+var SCRIPT_DELETE_DESCRIPTION = "Permanently remove a swarm-shared script and all its versions from the catalog. This cannot be undone.";
 var registerScriptDeleteTool = (server) => {
   createToolRegistrar(server)("script-delete", {
     title: "Script Delete",
@@ -131658,33 +132872,35 @@ function formatFileSize2(bytes) {
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
-function buildAttachmentText(files, failed = []) {
+function buildAttachmentText(files, failed = [], notes = new Map) {
   const reasons = new Map(failed.map((f) => [f.file.id, f.reason]));
   return files.map((f) => {
     const size = typeof f.size === "number" ? formatFileSize2(f.size) : "unknown size";
     const line = `[File: ${f.name ?? f.id} (${f.mimetype ?? "unknown type"}, ${size}) id=${f.id}]`;
     const reason = reasons.get(f.id);
-    return reason ? `${line} (not attached: ${reason})` : line;
+    const note = notes.get(f.id);
+    return [reason ? `${line} (not attached: ${reason})` : line, note].filter(Boolean).join(`
+`);
   }).join(`
 `);
 }
-function buildEffectiveText(text, files, failed) {
+function buildEffectiveText(text, files, failed, notes) {
   const hasText = !!text?.trim();
   const hasFiles = files && files.length > 0;
   if (hasText && hasFiles) {
     return `${text}
 
-${buildAttachmentText(files, failed)}`;
+${buildAttachmentText(files, failed, notes)}`;
   }
   if (hasFiles) {
-    return buildAttachmentText(files, failed);
+    return buildAttachmentText(files, failed, notes);
   }
   return text || "";
 }
 function bufferedFileFailures(files) {
   return (files ?? []).map((file) => ({ file, reason: BUFFERED_REASON }));
 }
-async function fetchSlackFiles(client, files) {
+async function fetchSlackFiles(client, files, options = {}) {
   let dir;
   const result = {
     files: [],
@@ -131710,8 +132926,19 @@ async function fetchSlackFiles(client, files) {
       result.fetched.push({ file, ...outcome });
     }
   }
+  if (options.transcribe) {
+    result.notes = await transcribeAudioNotes(result.fetched.filter(({ file }) => isSlackAudio(file)).map(({ file, path }) => ({
+      key: file.id,
+      name: file.name ?? file.id,
+      data: Bun.file(path),
+      mimeType: file.mimetype
+    })), "[Slack]");
+  }
   return result;
 }
+function isSlackAudio(file) {
+  return file.subtype === "slack_audio" || Boolean(file.mimetype?.startsWith("audio/"));
+}
 function looksLikeSignIn(head) {
   const joined = new Uint8Array(head.reduce((total, part) => total + part.byteLength, 0));
   let offset = 0;
@@ -133925,9 +135152,9 @@ var registerSystemOneDecideTool = (server) => {
   createToolRegistrar(server)("system-one-decide", {
     title: "Ask a SystemOne decision model",
     annotations: { destructiveHint: false, openWorldHint: true },
-    description: "Send a state and typed questions (noul, choice, score) to a SystemOne decision host such as Jev, and return the validated answers. " + "Same request, provider list, credentials and validation as the `system-one-decision` workflow node, without its human review band. " + "The provider credential is a global secret that stays on the server; this tool never returns it.",
+    description: "Send a state and typed questions (noul, choice, score) to a SystemOne decision host such as Jev or Clef, and return the validated answers. " + "Same request, provider list, credentials and validation as the `system-one-decision` workflow node, without its human review band. " + "The provider credential is a global secret that stays on the server; this tool never returns it.",
     inputSchema: object2({
-      provider: _enum2(SYSTEM_ONE_PROVIDER_IDS).optional().describe("Decision host (default typesafe)"),
+      provider: _enum2(SYSTEM_ONE_PROVIDER_IDS).optional().describe("Decision host (default: the SYSTEM_ONE_DEFAULT_PROVIDER global config, typesafe when unset)"),
       model: string2().min(1).optional().describe("Provider model id (default: the provider's)"),
       state: union2([string2(), array2(string2()), record2(string2(), unknown())]).describe("The state to decide on"),
       questions: record2(string2(), record2(string2(), unknown())).describe("Questions by id, each `{ type: 'noul' | 'choice' | 'score', instructions, criteria }`"),
@@ -133938,7 +135165,8 @@ var registerSystemOneDecideTool = (server) => {
       model: string2().optional(),
       answers: record2(string2(), unknown()).optional(),
       usage: record2(string2(), unknown()).optional(),
-      requestId: string2().optional()
+      requestId: string2().optional(),
+      providerUnavailable: boolean().optional().describe("On an error: true when this deployment refuses the provider (e.g. OpenRouter behind a gateway) and no request was sent, so a caller choosing automatically can try its next provider")
     })
   }, async ({ provider, model, state, questions, timeoutMs, maxRetries }, requestInfo) => {
     if (!requestInfo.agentId) {
@@ -133963,8 +135191,9 @@ var registerSystemOneDecideTool = (server) => {
       return toolErr("The system-one-decision executor is not available");
     }
     const decided = await executor.decide(parsed.data);
-    if (!decided.ok)
-      return toolErr(decided.error);
+    if (!decided.ok) {
+      return toolErr(decided.error, decided.deploymentRefused ? { data: { providerUnavailable: true } } : {});
+    }
     const { output } = decided;
     return toolOk(`Decision from ${output.model}`, {
       data: {
@@ -134099,7 +135328,7 @@ async function emitBudgetRefusalSideEffects(ctx, inserted) {
       console.warn(`[budget-refusal-notify] Failed to create follow-up task for budget refusal (task=${ctx.task.id.slice(0, 8)}): ${err}`);
     }
   }
-  import("./event-bus-9vpk8gmq.js").then(({ workflowEventBus }) => {
+  import("./event-bus-3z78ep5n.js").then(({ workflowEventBus }) => {
     workflowEventBus.emit("task.budget_refused", {
       taskId: ctx.task.id,
       agentId: ctx.agentId,
@@ -135150,7 +136379,7 @@ var registerCreateWorkflowTool = (server) => {
 ` + "- CROSS-NODE DATA: To use output from an upstream node, you MUST declare an 'inputs' mapping on the downstream node. " + 'Example: inputs: { "cityData": "generate-city" } → then use {{cityData.taskOutput.field}} in config templates. ' + "Without 'inputs', built-in trigger/input/workflow/swarm/run context remains available, but upstream outputs do not. " + "Agent-task templates may interpolate trigger and declared upstream aliases. SECURITY: executable source for script/swarm-script nodes does not: " + "inline script source allows only input/workflow/swarm/run values, while named swarm-script source is not workflow-interpolated. " + `Pass dynamic trigger or upstream values through config.args (argv for inline scripts; the args object for swarm-script).
 ` + "- STRUCTURED OUTPUT: For agent-task nodes, put outputSchema inside 'config' to validate the agent's raw JSON output. " + `Node-level outputSchema validates the executor's return ({taskId, taskOutput}), which is different.
 ` + `- Agent-task config: { template, outputSchema?, agentId?, tags?, priority?, dir?, vcsRepo?, model? }.
-` + "- FOREACH NODE: type 'foreach' fans out one agent-task per item. Config: " + "{ over: <array or exact {{input}} token>, itemKey: <property name>, body: { type: 'agent-task', config: {...} } }. " + "The body config is interpolated once per item with {{item.*}} and {{index}}. Child steps use synthetic IDs " + "'<foreachNodeId>#<itemKey>'; the parent waits for every child and exposes one aggregate result to successors. " + `concurrency is not supported in v1; use definition-level onNodeFailure: 'continue' to aggregate failed children.
+` + "- FOREACH NODE: type 'foreach' runs its body once per item. Config: " + "{ over: <array or exact {{input}} token>, itemKey: <property name>, body: { type: <any executor except foreach>, config: {...} }, " + "concurrency?: <integer >= 1, items in flight; unbounded when absent>, failurePolicy?: 'fail-fast' | 'collect-outcomes' }. " + "The body config is interpolated once per item with {{item.*}} and {{index}}. Child steps use synthetic IDs " + "'<foreachNodeId>#<itemKey>'; the parent waits for every child and exposes one aggregate result to successors. " + "failurePolicy defaults from onNodeFailure ('continue' = collect-outcomes, else fail-fast); fail-fast cancels queued items. " + `retry-workflow-run on a failed fan-out reruns only failed and cancelled items.
 ` + "- TRIGGER SCHEMA: Optional 'triggerSchema' is a JSON-Schema object that validates incoming trigger payloads. " + "Supported keywords: type, required, properties, enum, const, items (recursive into arrays). " + `Other JSON-Schema keywords (oneOf/anyOf/$ref/pattern/format/additionalProperties) are silently ignored.
 ` + "- WEBHOOK VERIFICATION: Webhook triggers use hmacSecret for all verification formats. " + "Omit verification for legacy HMAC-SHA256 over the raw body with fallback header scanning; " + "or set verification to { format: 'hmac-sha256', header }, { format: 'timestamped-hmac-sha256', header, toleranceSeconds? }, " + "{ format: 'token-equality', header }, or { format: 'standard-webhooks', toleranceSeconds? } " + "(standardwebhooks.com: webhook-id/webhook-timestamp/webhook-signature headers, hmacSecret is the whsec_ signing secret). Example: { type: 'webhook', hmacSecret: 'secret.SUPERAGENT_WEBHOOK_SECRET', " + `verification: { format: 'timestamped-hmac-sha256', header: 'X-Superagent-Signature', toleranceSeconds: 300 } }.
 ` + "- WAIT NODE: type 'wait' pauses a workflow for a duration or until a named workflowEventBus event arrives. " + "See runbooks/workflows.md#wait-nodes for config shapes, ordering caveats, and built-in event names.",
@@ -135961,7 +137190,8 @@ async function createServer(opts = {}) {
     ...opts.preloadedTools?.length ? { instructions: resolveTemplate("system.agent.tool_preload", {}).text } : {},
     capabilities: {
       logging: {}
-    }
+    },
+    maxToolInputElements: MCP_MAX_TOOL_INPUT_ELEMENTS
   });
   if (opts.preloadedTools?.length)
     setPreloadedTools(server, opts.preloadedTools);
@@ -136196,4 +137426,4 @@ async function createServer(opts = {}) {
   return server;
 }
 
-export { DEFAULT_NEGOTIATED_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, isJSONRPCRequest, isJSONRPCResultResponse, isJSONRPCErrorResponse, JSONRPCMessageSchema, isInitializeRequest, McpServer, isGitHubEnabled, initGitHub, verifyWebhookSignature, isAgentMailEnabled, initAgentMail, verifyAgentMailWebhook, resolveIdentity, renderIdentity, createAdditiveBuffer, taskModelPin, resumedTaskModelSelection, listHarnessModelSupport, recordHarnessModelSupport, agentRanModel, getAgentHarnessCliVersion, setAgentHarnessCliVersion, sanitizeModelTierOverrides, parseModelTierOverridesHeader, setAgentModelTierOverrides, previewModelTiers, recordClaimModelResolution, harnessModelErrorFor, poolTaskRunsOnHarness, explicitModelError, explicitModelErrorForAgent, referencedBundlePaths, skillDirs, TaskCreationBlockedError, recordUnmappedIdentity, MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload, buildEffectiveText, bufferedFileFailures, fetchSlackFiles, createSlackTaskWithFiles, notifySlackFileFailures, isRuntimePoolWakeable, isAgentReachable, hasOtherUserMention, broadcastMatches, routeMessage, extractTaskFromMessage, extractSlackMessageText, recoverIncompleteRuns, handleWebhookTrigger, verifyHmacSignature, WebhookError, snapshotAndUpdateWorkflow, RawLlmConfigSchema, RawLlmOutputSchema, executeRawLlm, getExecutorRegistry2, initWorkflows2, dispatchScheduleTarget, calculateNextRun2, startScheduler2, stopScheduler2, runScheduleNow2, ExtensionAssetConflictError, ExtensionOwnershipError, getExtensionFiles, getExtensionById, getExtensionByName, listExtensions, listExtensionVersions, updateExtensionMeta, listExtensionRuns, SDK_ALLOWLIST, mcpToolNameForSdkMethod, mcpOverflowAuthError, hasKvViewArgs, resolveKvView, toolErr, createToolRegistrar, handleMcpBridge, Redacted, SCRIPT_SDK_RESPONSE_LIMIT_BYTES, readScriptSdkJsonResponse, ExtensionConfigError, ExtensionLifecycleError, setExtensionLoopbackBaseUrl, enableExtension, disableExtension, activateVersion, ExtensionAssetsInvalidError, installExtensionWithAssets, uninstallExtension, reloadExtension, loadEnabledExtensions, stopExtensionRuntime, ExtensionAbortedError2, isRegistered2, isExtensionAgentId2, getExtensionBridgeToken2, resolveBridgeCallOrigin2, extensionIdForAgent2, runContext2, registerLoaded2, unregister2, listRegistered2, dispatchPre2, dispatchPost2, stripSiblingBlock, createTaskWithSiblingAwareness, isInboxAllowed, isSenderAllowed, handleMessageReceived, isAzureDevOpsEnabled, initAzureDevOps, verifyAzureDevOpsWebhook, repointTrackerSyncBySwarmId, isAzureDevOpsUrl, canonicalAzureDevOpsRepoUrl, parseAzureDevOpsRepoUrl, createdPullRequestOf, commentedPayloadOf, handlePullRequestCreated, handlePullRequestCommented, handleWorkItemCreated, handleWorkItemUpdated, handleWorkItemCommented, handleWorkItemDeleted, handleWorkItemRestored, initAzureDevOpsOutbound, AGENT_MAX_TASKS_CONFIG_KEY, reconcileAgentMaxTasksPolicy, resetAgentMaxTasksMirror, upsertSwarmConfigWithPolicyMirror, runtimeStaleThresholdMinutes, upsertRuntimeInstance, getRuntimeInstanceById, insertProvisioningRuntime, markRuntimeTerminated, touchRuntimeInstance, countActiveRuntimeInstancesForAgent, listRuntimeInstancesForAgent, setRuntimeCredentialReady, reconcileAgentStatusFromRuntimes, agentsWithLiveRuntime, expireStaleRuntimeInstances, listRuntimeInstancesForPool, enqueueAuditRow, enqueueAdmissionRow, flushAuditBuffer, startAuditWriter, stopAuditWriter, startAuditGc, stopAuditGc, getTelemetryIngestAnchor, initApiTelemetry, syncTelemetryEnabled, handlePullRequest, handleIssue, handleComment, handlePullRequestReview, handleCheckRun, handleCheckSuite, handleWorkflowRun, isGitLabEnabled, initGitLab, verifyGitLabWebhook, handleMergeRequest, handleIssue2, handleNote, handlePipeline, isChatSdkEnabled, getChatSdkConfig, errorMessage, resolveAdapterApiUrl, trackBackground, TelegramBotApiError, callTelegramBotApi, isTrustedTeamsServiceUrl, isChatSdkStopping, startChatSdk, getChatInstance, isChatAdapterConfigured, getChatSdkHealth, stopChatSdk, getJiraMetadata, updateJiraMetadata, clearJiraMetadata, registerJiraWebhook, deleteJiraWebhook, isJiraEnabled, initJira, handleJiraWebhook, handleAgentSessionEvent, handleIssueUpdate, handleIssueDelete, handleAgentSessionPrompted, isLinearEnabled, initLinear, parseCookieHeader, extractAndVerifyCookie, issuePageSessionCookie, resolveHttpRequestAuth, loadGlobalConfigsIntoEnv, reloadGlobalConfigsAndIntegrations, scheduleIntegrationsReload, handleCore, userCtx, requestPrincipal, agentFirstPrincipal, rejectGuest, handleApps, cancelApprovalRequest, cancelApprovalRequestAndRun, getUserCommsPrefs, getTaskDetailsInputSchema, getTaskDetailsOutputSchema, getTaskDetailsHandler, cancelTaskInputSchema, cancelTaskOutputSchema, cancelTaskHandler, executeReadOnlyQuery, assertSelectOnlyQuery, handleDbQuery, snapshotMetric, AssetKeyAuthorizationError, authorizeAssetKeyWrite, getPageEditCounter, snapshotPage, assertOAuthAppUrlsSafe, assertOAuthEgressUrlSafe, listOAuthPresets, listOAuthPresetIds, getOAuthPreset, hydrateOAuthAppFromPreset, scopedResourceScopeIdSchema, resolveScopedResourceId, dedupeMemoryDocumentIds, recordMemoryAccesses, recordRetrievals, ExplicitSelfDuplicateError, applyRating, shouldPersistAutomaticTaskMemory, REBOOT_RETRY_PIN_TAG, getPinCandidateAgent, resolveLeadOnlyRecoveryAssignment, getResumeGeneration, getNextResumeGeneration, inheritedModelSelection, createWorkerTaskFollowUp, createResumeFollowUp, createRerouteDecisionTask, createPoolStarvationDecisionTask, guardTerminalTaskResultWrite, getTasksInputSchema, getTasksOutputSchema, getTasksHandler, reservedNamespaceError, reservedRoomKeyError, updateMcpServerChecked, updateTouchesStdioExecution, MemoryKeyError, refreshLinks, canReadMemory, getLinksForMemory, expandCandidatesWithGraph, indexMemoryContent, isApiDraining, drainApi, markKapsoMessageRead, sendKapsoReaction, getKapsoConfig, getKapsoNumberMapping, markKapsoMessageSeen, changesAllowMerge, updateSwarmRepoChecked, getCombConfig, resolveRoomNamespace, roomRequestInfo, authorizeRoomNamespace, sessionAccessTopic, sessionPresenceRoot, RoomOperationSchema, removeAwarenessStates, roomTopic, decodeRoomSnapshot, roomView, getRoom, changeRoom, applyRoomUpdate, resetRoom, sweepRooms, closeRooms, removeNamespaceRooms, MEMORY_KEYS_DEFAULT_PREFIX, MEMORY_KEYS_MAX_LIMIT, estimateTokens, posteriorMean, listMemoryKeys, checkChunkIntegrity, getMemoryChunks, getPosteriorsByIds, createEvent, createEventsBatch, getEventCountsFiltered, getEventsFiltered, mergeScheduleTiming, validateRecurringTiming, checkOutputSchemaShape, sendTaskOutputSchema, sendTaskHandler, steerTaskUserInputSchema, steerTaskOutputSchema, steerTaskHandler, canClaim, emitBudgetRefusalSideEffects, workflowModelErrors, patchWorkflowDefinition, resolveScriptsOnlyMode, ALL_CAPABILITIES, hasCapability, getEnabledCapabilities, createServer };
+export { DEFAULT_NEGOTIATED_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, isJSONRPCRequest, isJSONRPCResultResponse, isJSONRPCErrorResponse, JSONRPCMessageSchema, isInitializeRequest, McpServer, isGitHubEnabled, initGitHub, verifyWebhookSignature, isAgentMailEnabled, initAgentMail, verifyAgentMailWebhook, resolveIdentity, renderIdentity, createAdditiveBuffer, taskModelPin, resumedTaskModelSelection, listHarnessModelSupport, recordHarnessModelSupport, agentRanModel, getAgentHarnessCliVersion, setAgentHarnessCliVersion, sanitizeModelTierOverrides, parseModelTierOverridesHeader, setAgentModelTierOverrides, previewModelTiers, recordClaimModelResolution, harnessModelErrorFor, poolTaskRunsOnHarness, explicitModelError, explicitModelErrorForAgent, referencedBundlePaths, skillDirs, TaskCreationBlockedError, recordUnmappedIdentity, MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload, scopeFromAttachment, backingProviderId, transcribeAudioNotes, buildEffectiveText, bufferedFileFailures, fetchSlackFiles, createSlackTaskWithFiles, notifySlackFileFailures, isRuntimePoolWakeable, isAgentReachable, hasOtherUserMention, broadcastMatches, routeMessage, extractTaskFromMessage, extractSlackMessageText, recoverIncompleteRuns, handleWebhookTrigger, verifyHmacSignature, WebhookError, snapshotAndUpdateWorkflow, RawLlmConfigSchema, RawLlmOutputSchema, executeRawLlm, getExecutorRegistry2, initWorkflows2, dispatchScheduleTarget, calculateNextRun2, startScheduler2, stopScheduler2, runScheduleNow2, ExtensionAssetConflictError, ExtensionOwnershipError, getExtensionFiles, getExtensionById, getExtensionByName, listExtensions, listExtensionVersions, updateExtensionMeta, listExtensionRuns, SDK_ALLOWLIST, mcpToolNameForSdkMethod, mcpOverflowAuthError, hasKvViewArgs, resolveKvView, toolErr, createToolRegistrar, handleMcpBridge, Redacted, SCRIPT_SDK_RESPONSE_LIMIT_BYTES, readScriptSdkJsonResponse, ExtensionConfigError, ExtensionLifecycleError, setExtensionLoopbackBaseUrl, enableExtension, disableExtension, activateVersion, ExtensionAssetsInvalidError, installExtensionWithAssets, uninstallExtension, reloadExtension, loadEnabledExtensions, stopExtensionRuntime, ExtensionAbortedError2, isRegistered2, isExtensionAgentId2, getExtensionBridgeToken2, resolveBridgeCallOrigin2, extensionIdForAgent2, runContext2, registerLoaded2, unregister2, listRegistered2, dispatchPre2, dispatchPost2, stripSiblingBlock, createTaskWithSiblingAwareness, isInboxAllowed, isSenderAllowed, handleMessageReceived, isAzureDevOpsEnabled, initAzureDevOps, verifyAzureDevOpsWebhook, repointTrackerSyncBySwarmId, isAzureDevOpsUrl, canonicalAzureDevOpsRepoUrl, parseAzureDevOpsRepoUrl, createdPullRequestOf, commentedPayloadOf, handlePullRequestCreated, handlePullRequestCommented, handleWorkItemCreated, handleWorkItemUpdated, handleWorkItemCommented, handleWorkItemDeleted, handleWorkItemRestored, initAzureDevOpsOutbound, AGENT_MAX_TASKS_CONFIG_KEY, reconcileAgentMaxTasksPolicy, resetAgentMaxTasksMirror, upsertSwarmConfigWithPolicyMirror, runtimeStaleThresholdMinutes, upsertRuntimeInstance, getRuntimeInstanceById, insertProvisioningRuntime, markRuntimeTerminated, touchRuntimeInstance, countActiveRuntimeInstancesForAgent, listRuntimeInstancesForAgent, setRuntimeCredentialReady, reconcileAgentStatusFromRuntimes, agentsWithLiveRuntime, expireStaleRuntimeInstances, listRuntimeInstancesForPool, enqueueAuditRow, enqueueAdmissionRow, flushAuditBuffer, startAuditWriter, stopAuditWriter, startAuditGc, stopAuditGc, getTelemetryIngestAnchor, initApiTelemetry, syncTelemetryEnabled, isBitbucketEnabled, initBitbucket, verifyBitbucketWebhook, isDuplicateDelivery, markDeliveryProcessed, pullRequestEventOf, pullRequestCommentEventOf, handlePullRequestCreated2, handlePullRequestCommentCreated, handlePullRequestClosed, handlePullRequest, handleIssue, handleComment, handlePullRequestReview, handleCheckRun, handleCheckSuite, handleWorkflowRun, isGitLabEnabled, initGitLab, verifyGitLabWebhook, handleMergeRequest, handleIssue2, handleNote, handlePipeline, isChatSdkEnabled, getChatSdkConfig, errorMessage, resolveAdapterApiUrl, trackBackground, TelegramBotApiError, callTelegramBotApi, isTrustedTeamsServiceUrl, isChatSdkStopping, startChatSdk, getChatInstance, isChatAdapterConfigured, getChatSdkHealth, stopChatSdk, getJiraMetadata, updateJiraMetadata, clearJiraMetadata, registerJiraWebhook, deleteJiraWebhook, isJiraEnabled, initJira, handleJiraWebhook, handleAgentSessionEvent, handleIssueUpdate, handleIssueDelete, handleAgentSessionPrompted, isLinearEnabled, initLinear, isCookieSafePageId, extractPageSession, extractLegacyPageSession, extractAndVerifyCookie, pageSessionSetCookies, resolveHttpRequestAuth, loadGlobalConfigsIntoEnv, reloadGlobalConfigsAndIntegrations, scheduleIntegrationsReload, handleCore, MCP_MAX_TOOL_INPUT_ELEMENTS, MCP_MAX_REQUEST_BODY_BYTES, userCtx, requestPrincipal, agentFirstPrincipal, rejectGuest, handleApps, cancelApprovalRequest, cancelApprovalRequestAndRun, getUserCommsPrefs, getTaskDetailsInputSchema, getTaskDetailsOutputSchema, getTaskDetailsHandler, cancelTaskInputSchema, cancelTaskOutputSchema, cancelTaskHandler, executeReadOnlyQuery, assertSelectOnlyQuery, handleDbQuery, snapshotMetric, AssetKeyAuthorizationError, authorizeAssetKeyWrite, getPageEditCounter, snapshotPage, assertOAuthAppUrlsSafe, assertOAuthEgressUrlSafe, listOAuthPresets, listOAuthPresetIds, getOAuthPreset, hydrateOAuthAppFromPreset, scopedResourceScopeIdSchema, resolveScopedResourceId, MemoryKeyError, refreshLinks, indexMemoryContent, dedupeMemoryDocumentIds, recordMemoryAccesses, recordRetrievals, ExplicitSelfDuplicateError, applyRating, shouldPersistAutomaticTaskMemory, REBOOT_RETRY_PIN_TAG, getPinCandidateAgent, resolveLeadOnlyRecoveryAssignment, getResumeGeneration, getNextResumeGeneration, inheritedModelSelection, createWorkerTaskFollowUp, createResumeFollowUp, createRerouteDecisionTask, createPoolStarvationDecisionTask, guardTerminalTaskResultWrite, getTasksInputSchema, getTasksOutputSchema, getTasksHandler, reservedNamespaceError, reservedRoomKeyError, updateMcpServerChecked, updateTouchesStdioExecution, canReadMemory, getLinksForMemory, expandCandidatesWithGraph, isApiDraining, drainApi, markKapsoMessageRead, sendKapsoReaction, getKapsoConfig, getKapsoNumberMapping, markKapsoMessageSeen, changesAllowMerge, updateSwarmRepoChecked, getCombConfig, resolveRoomNamespace, roomRequestInfo, authorizeRoomNamespace, sessionAccessTopic, sessionPresenceRoot, RoomOperationSchema, removeAwarenessStates, roomTopic, decodeRoomSnapshot, roomView, getRoom, changeRoom, applyRoomUpdate, resetRoom, sweepRooms, closeRooms, removeNamespaceRooms, MEMORY_KEYS_DEFAULT_PREFIX, MEMORY_KEYS_MAX_LIMIT, estimateTokens, posteriorMean, listMemoryKeys, checkChunkIntegrity, getMemoryChunks, getPosteriorsByIds, createEvent, createEventsBatch, getEventCountsFiltered, getEventsFiltered, mergeScheduleTiming, validateRecurringTiming, checkOutputSchemaShape, sendTaskOutputSchema, sendTaskHandler, steerTaskUserInputSchema, steerTaskOutputSchema, steerTaskHandler, canClaim, emitBudgetRefusalSideEffects, workflowModelErrors, patchWorkflowDefinition, resolveScriptsOnlyMode, ALL_CAPABILITIES, hasCapability, getEnabledCapabilities, createServer };