@desplega.ai/agent-swarm 2.5.4 → 2.7.0

package/src/scripts-runtime/host-validated-args.ts

@@ -0,0 +1,133 @@
+/**
+ * Unforgeable host-only capability symbol set on `RunScriptInput` strictly at
+ * the host boundary (`POST /api/x/script/{endpointId}`) after `validateJsonSchema`
+ * succeeds. Because `Symbol` keys cannot be produced by JSON deserialization,
+ * callers that forward request-shaped JSON fields into `RunScriptInput` can
+ * never opt out of `argsSchema` validation.
+ */
+export const HOST_VALIDATED_ARGS = Symbol("swarm.hostValidatedArgs");
+
+/**
+ * Checks whether a runtime `argsSchema` (Zod v4 / `zod/mini` schema) and its
+ * candidate `value` are semantically equivalent to the host-side JSON Schema
+ * validation performed by `validateJsonSchema` in `src/http/x.ts`.
+ *
+ * Returns `true` only when `schema.parse(value)` is guaranteed to succeed and
+ * return a value deeply identical to `value` without running any defaults,
+ * coercions, transforms, refinements, or unknown-key stripping.
+ */
+export function isHostValidationEquivalent(schema: unknown, value: unknown): boolean {
+  if (!schema || typeof schema !== "object") return false;
+  const zodInternal = (schema as { _zod?: { def?: Record<string, unknown>; values?: unknown } })
+    ._zod;
+  const def = zodInternal?.def;
+  if (!def || typeof def !== "object") return false;
+
+  if (def.coerce) return false;
+  if (Array.isArray(def.checks) && def.checks.length > 0) return false;
+
+  switch (def.type) {
+    case "string":
+      return typeof value === "string" && !def.format;
+    case "number":
+      return typeof value === "number" && Number.isFinite(value) && !def.format;
+    case "boolean":
+      return typeof value === "boolean";
+    case "literal": {
+      const rawValues = def.values;
+      const values = Array.isArray(rawValues)
+        ? rawValues
+        : rawValues instanceof Set
+          ? Array.from(rawValues)
+          : [];
+      return (
+        values.length > 0 &&
+        values.some((v) => v === value && typeof v !== "bigint" && typeof v !== "symbol")
+      );
+    }
+    case "enum": {
+      if (zodInternal?.values instanceof Set) {
+        return zodInternal.values.has(value);
+      }
+      const entriesObj =
+        def.entries && typeof def.entries === "object"
+          ? (def.entries as Record<string, unknown>)
+          : null;
+      if (!entriesObj) return false;
+      const entries = Object.values(entriesObj).filter(
+        (v) => !(typeof v === "string" && typeof entriesObj[v] === "number"),
+      );
+      return entries.length > 0 && entries.includes(value);
+    }
+    case "optional":
+      return value === undefined
+        ? isStructuralSchemaNode(def.innerType)
+        : isHostValidationEquivalent(def.innerType, value);
+    case "nullable":
+      return value === null
+        ? isStructuralSchemaNode(def.innerType)
+        : isHostValidationEquivalent(def.innerType, value);
+    case "array":
+      return (
+        Array.isArray(value) &&
+        isStructuralSchemaNode(def.element) &&
+        value.every((item) => isHostValidationEquivalent(def.element, item))
+      );
+    case "object": {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+      const rawShape = typeof def.shape === "function" ? def.shape() : def.shape;
+      if (!rawShape || typeof rawShape !== "object") return false;
+      const shape = rawShape as Record<string, unknown>;
+      const obj = value as Record<string, unknown>;
+
+      // If `value` carries extra keys not declared in `shape`, let `.parse()`
+      // handle key stripping (`z.object`), passthrough (`z.looseObject`), or
+      // rejection (`z.strictObject`).
+      for (const key of Object.keys(obj)) {
+        if (!Object.hasOwn(shape, key)) return false;
+      }
+
+      for (const [key, propSchema] of Object.entries(shape)) {
+        // Retain Zod's property lookup semantics: if `key` is absent as an own
+        // property on `obj` but resolves via `Object.prototype` (e.g. `constructor`,
+        // `toString`), fall back to `.parse()` so Zod validates/rejects the
+        // inherited prototype value identically to `main`.
+        if (!Object.hasOwn(obj, key) && key in obj) return false;
+        const propValue = obj[key];
+        if (!isHostValidationEquivalent(propSchema, propValue)) return false;
+      }
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
+function isStructuralSchemaNode(schema: unknown): boolean {
+  if (!schema || typeof schema !== "object") return false;
+  const def = (schema as { _zod?: { def?: Record<string, unknown> } })._zod?.def;
+  if (!def || typeof def !== "object") return false;
+  if (def.coerce) return false;
+  if (Array.isArray(def.checks) && def.checks.length > 0) return false;
+  switch (def.type) {
+    case "string":
+    case "number":
+      return !def.format;
+    case "boolean":
+    case "literal":
+    case "enum":
+      return true;
+    case "optional":
+    case "nullable":
+      return isStructuralSchemaNode(def.innerType);
+    case "array":
+      return isStructuralSchemaNode(def.element);
+    case "object": {
+      const rawShape = typeof def.shape === "function" ? def.shape() : def.shape;
+      if (!rawShape || typeof rawShape !== "object") return false;
+      return Object.values(rawShape as Record<string, unknown>).every(isStructuralSchemaNode);
+    }
+    default:
+      return false;
+  }
+}

package/src/scripts-runtime/loader.ts

@@ -6,16 +6,18 @@ import { createValueScrubber, scrubObject, scrubSecrets } from "../utils/secret-
 import type { ScriptApiConnectionDescriptor, ScriptMcpConnectionDescriptor } from "./api-types";
 import type { FailedCredentialBinding } from "./credential-broker";
 import { buildEgressSecrets } from "./egress-secrets";
-import { getScriptExecutor } from "./executors/registry";
+import { isExecutorAllowedByDeployment, resolveScriptExecutor } from "./executors/registry";
 import {
   DEFAULT_SCRIPT_RESOURCES,
   type EgressSecretEntry,
   type ExecutorOutput,
   type ScriptAgentFsDescriptor,
+  type ScriptExecutorName,
   type ScriptFsMode,
   type ScriptResourcePolicy,
   type SwarmConfigPayload,
 } from "./executors/types";
+import { HOST_VALIDATED_ARGS } from "./host-validated-args";
 import { validateScriptImports } from "./import-allowlist";
 
 /**
@@ -38,7 +40,19 @@ const CAPACITY_EXCEEDED_RETRY_DELAYS_MS = [200, 750];
 export type RunScriptInput = {
   source: string;
   args?: unknown;
+  /**
+   * Unforgeable host-only capability symbol set only when the host has already
+   * validated `args` against the script's `argsJsonSchema` (e.g. `POST /api/x/script/{endpointId}`).
+   * Keyed by a `Symbol` so request-shaped JSON inputs forwarded into `RunScriptInput`
+   * can never opt out of `argsSchema` validation.
+   */
+  [HOST_VALIDATED_ARGS]?: boolean;
   fsMode?: ScriptFsMode;
+  /**
+   * Optional per-script executor override ("native" | "quickjs"). When null or
+   * undefined, `getScriptExecutor` falls back to `SCRIPT_EXECUTOR ?? "native"`.
+   */
+  executor?: ScriptExecutorName | null;
   agentId: string;
   /**
    * Bearer for the run's `ctx.swarm` SDK calls. Api-side callers pass a
@@ -118,6 +132,18 @@ export async function runScript(input: RunScriptInput): Promise<RunScriptOutput>
     };
   }
 
+  if (!isExecutorAllowedByDeployment(input.executor)) {
+    return {
+      result: undefined,
+      stdout: "",
+      stderr: 'Executor "native" is not permitted when deployment SCRIPT_EXECUTOR="quickjs"',
+      truncated: { stdout: false, stderr: false },
+      durationMs: 0,
+      exitCode: 1,
+      error: "executor_error",
+    };
+  }
+
   // The global scrubber skips values under its length floor, so this run's own
   // secret config is redacted here at any length before the global pass. Built
   // before the import check: its diagnostic quotes source, which can hold a value.
@@ -150,6 +176,7 @@ export async function runScript(input: RunScriptInput): Promise<RunScriptOutput>
   const executorInput = {
     source: input.source,
     args: input.args ?? null,
+    ...(input[HOST_VALIDATED_ARGS] === true ? { hostValidatedArgs: true } : {}),
     configPayload,
     resources,
     fsMode: input.fsMode ?? "none",
@@ -157,11 +184,11 @@ export async function runScript(input: RunScriptInput): Promise<RunScriptOutput>
     signal: input.signal,
   };
 
-  let output = await getScriptExecutor().run(executorInput);
+  let output = await resolveScriptExecutor(input.executor).run(executorInput);
   for (const delayMs of CAPACITY_EXCEEDED_RETRY_DELAYS_MS) {
     if (output.error !== "capacity_exceeded" || input.signal?.aborted) break;
     await Bun.sleep(delayMs);
-    output = await getScriptExecutor().run(executorInput);
+    output = await resolveScriptExecutor(input.executor).run(executorInput);
   }
 
   return {

package/src/scripts-runtime/swarm-sdk.ts

@@ -8,6 +8,7 @@ type BridgeRequest = {
   method: string;
   path: string;
   body?: unknown;
+  headers?: Record<string, string>;
 };
 
 function headers(config: SwarmConfig): Record<string, string> {
@@ -319,7 +320,13 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
     case "workflow_getRun": {
       const id = typeof body.id === "string" ? body.id : undefined;
       if (!id) throw new Error("workflow_getRun requires string `id`");
-      return { method: "GET", path: `/api/workflow-runs/${encodeURIComponent(id)}` };
+      if (body.fields !== undefined && body.fields !== "full" && body.fields !== "slim") {
+        throw new Error('workflow_getRun `fields` must be "full" or "slim"');
+      }
+      return {
+        method: "GET",
+        path: appendQuery(`/api/workflow-runs/${encodeURIComponent(id)}`, { fields: body.fields }),
+      };
     }
     case "workflow_delete": {
       const id = typeof body.id === "string" ? body.id : undefined;
@@ -356,10 +363,16 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
     case "workflow_trigger": {
       const id = typeof body.id === "string" ? body.id : undefined;
       if (!id) throw new Error("workflow_trigger requires string `id`");
+      const path = `/api/workflows/${encodeURIComponent(id)}/trigger`;
       return {
         method: "POST",
-        path: `/api/workflows/${encodeURIComponent(id)}/trigger`,
+        path: body.wait === false ? `${path}?wait=false` : path,
         body: body.triggerData ?? {},
+        // The route's own Idempotency-Key: recorded in the run's transaction,
+        // so a retry after a kill replays the run instead of starting another.
+        ...(typeof body.idempotencyKey === "string"
+          ? { headers: { "Idempotency-Key": body.idempotencyKey } }
+          : {}),
       };
     }
     case "workflow_retryRun": {
@@ -485,7 +498,7 @@ async function callBridgeApi(
 
   const res = await fetch(`${baseUrl}${request.path}`, {
     method: request.method,
-    headers: headers(config),
+    headers: { ...headers(config), ...request.headers },
     body: request.body === undefined ? undefined : JSON.stringify(request.body),
   });
   const data = await readScriptSdkJsonResponse(res, `ctx.swarm.${name}`);

package/src/scripts-runtime/types/stdlib.d.ts

@@ -26,6 +26,7 @@ declare module "swarm-sdk" {
     | { [key: string]: JsonValue };
   export type ScriptScope = "agent" | "global";
   export type ScriptFsMode = "none" | "workspace-rw";
+  export type ScriptExecutorName = "native" | "quickjs";
   export type ScriptApiRawOptions = { raw: true };
   export type ScriptApiDefaultOptions = { raw?: false };
   export type RoutingReason =
@@ -304,6 +305,7 @@ declare module "swarm-sdk" {
       intent?: string;
       scope?: ScriptScope;
       fsMode?: ScriptFsMode;
+      executor?: ScriptExecutorName | null;
       idempotencyKey?: string;
     }): Promise<unknown>;
     // --- swarm / agent ---
@@ -378,7 +380,7 @@ declare module "swarm-sdk" {
       limit?: number;
       offset?: number;
     }): Promise<unknown>;
-    workflow_getRun(args: { id: string }): Promise<unknown>;
+    workflow_getRun(args: { id: string; fields?: "full" | "slim" }): Promise<unknown>;
     // --- prompt templates ---
     prompt_list(args?: {
       eventType?: string;
@@ -535,7 +537,12 @@ declare module "swarm-sdk" {
     workflow_patch(args: Record<string, unknown>): Promise<unknown>;
     workflow_patchNode(args: Record<string, unknown>): Promise<unknown>;
     workflow_delete(args: { id: string }): Promise<unknown>;
-    workflow_trigger(args: { id: string; triggerData?: Record<string, unknown> }): Promise<unknown>;
+    workflow_trigger(args: {
+      id: string;
+      triggerData?: Record<string, unknown>;
+      wait?: boolean;
+      idempotencyKey?: string;
+    }): Promise<unknown>;
     workflow_retryRun(args: { id: string }): Promise<unknown>;
     workflow_cancelRun(args: { id: string }): Promise<unknown>;
 
@@ -552,6 +559,7 @@ declare module "swarm-sdk" {
       intent?: string;
       scope?: ScriptScope;
       fsMode?: ScriptFsMode;
+      executor?: ScriptExecutorName | null;
     }): Promise<unknown>;
     script_delete(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
     script_queryTypes(args: { name: string; scope?: ScriptScope }): Promise<unknown>;

package/src/scripts-runtime/types/swarm-extension.d.ts

@@ -9,16 +9,16 @@ declare module "swarm-extension" {
       | "schedule"
       | "slack"
       | "agentmail"
-      | "mcp"
-      | "api"
-      | "ui"
       | "github"
       | "gitlab"
       | "azure-devops"
       | "bitbucket"
-      | "system"
       | "linear"
       | "jira"
+      | "mcp"
+      | "api"
+      | "ui"
+      | "system"
       | "comb"
       | "chat"
       | undefined;
@@ -127,16 +127,16 @@ declare module "swarm-extension" {
       | "schedule"
       | "slack"
       | "agentmail"
-      | "mcp"
-      | "api"
-      | "ui"
       | "github"
       | "gitlab"
       | "azure-devops"
       | "bitbucket"
-      | "system"
       | "linear"
       | "jira"
+      | "mcp"
+      | "api"
+      | "ui"
+      | "system"
       | "comb"
       | "chat";
     tags: string[];
@@ -401,6 +401,15 @@ declare module "swarm-extension" {
     description: string;
     origin: TaskCreateOrigin;
     requestInfo?: RequestInfo;
+    /** Slack ingress metadata; not persisted or writable through modify. */
+    slack?: {
+      trigger: "mention" | "thread-buffer";
+      messages: {
+        ts: string;
+        userId: string;
+        text: string;
+      }[];
+    };
   }
   /** A pre.task.create hook blocked a task before it was created. */
   export interface TaskBlockedEvent {

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -8,6 +8,7 @@ declare module "swarm-sdk" {
     | { [key: string]: JsonValue };
   export type ScriptScope = "agent" | "global";
   export type ScriptFsMode = "none" | "workspace-rw";
+  export type ScriptExecutorName = "native" | "quickjs";
   export type ScriptApiRawOptions = { raw: true };
   export type ScriptApiDefaultOptions = { raw?: false };
   export type RoutingReason =
@@ -286,6 +287,7 @@ declare module "swarm-sdk" {
       intent?: string;
       scope?: ScriptScope;
       fsMode?: ScriptFsMode;
+      executor?: ScriptExecutorName | null;
       idempotencyKey?: string;
     }): Promise<unknown>;
     // --- swarm / agent ---
@@ -360,7 +362,7 @@ declare module "swarm-sdk" {
       limit?: number;
       offset?: number;
     }): Promise<unknown>;
-    workflow_getRun(args: { id: string }): Promise<unknown>;
+    workflow_getRun(args: { id: string; fields?: "full" | "slim" }): Promise<unknown>;
     // --- prompt templates ---
     prompt_list(args?: {
       eventType?: string;
@@ -517,7 +519,12 @@ declare module "swarm-sdk" {
     workflow_patch(args: Record<string, unknown>): Promise<unknown>;
     workflow_patchNode(args: Record<string, unknown>): Promise<unknown>;
     workflow_delete(args: { id: string }): Promise<unknown>;
-    workflow_trigger(args: { id: string; triggerData?: Record<string, unknown> }): Promise<unknown>;
+    workflow_trigger(args: {
+      id: string;
+      triggerData?: Record<string, unknown>;
+      wait?: boolean;
+      idempotencyKey?: string;
+    }): Promise<unknown>;
     workflow_retryRun(args: { id: string }): Promise<unknown>;
     workflow_cancelRun(args: { id: string }): Promise<unknown>;
 
@@ -534,6 +541,7 @@ declare module "swarm-sdk" {
       intent?: string;
       scope?: ScriptScope;
       fsMode?: ScriptFsMode;
+      executor?: ScriptExecutorName | null;
     }): Promise<unknown>;
     script_delete(args: { name: string; scope?: ScriptScope }): Promise<unknown>;
     script_queryTypes(args: { name: string; scope?: ScriptScope }): Promise<unknown>;

package/src/slack/assistant.ts

@@ -213,6 +213,10 @@ export function createAssistant(): Assistant {
           buildEffectiveText(messageText, inbound.files, inbound.failed, inbound.notes),
           cachedBotUserId ?? undefined,
         );
+        const slack = {
+          trigger: "mention" as const,
+          messages: [{ ts: message.ts, userId, text: messageText }],
+        };
 
         if (workingAgent && workingAgent.status !== "offline") {
           // Otherwise, create a follow-up task for the working agent
@@ -236,6 +240,7 @@ export function createAssistant(): Assistant {
               contextKey: slackContextKey({ channelId, threadTs }),
             },
             inbound,
+            slack,
           );
           await ackSlackMessage(
             client,
@@ -285,6 +290,7 @@ export function createAssistant(): Assistant {
               contextKey: slackContextKey({ channelId, threadTs }),
             },
             inbound,
+            slack,
           );
           await ackSlackMessage(
             client,
@@ -318,6 +324,7 @@ export function createAssistant(): Assistant {
             contextKey: slackContextKey({ channelId, threadTs }),
           },
           inbound,
+          slack,
         );
         await ackSlackMessage(client, channelId, message.ts, reactionName("accepted"), "accepted");
         await notifySlackFileFailures(client, channelId, threadTs, unattached);

package/src/slack/channel-labels.ts

@@ -0,0 +1,74 @@
+import type { WebClient } from "@slack/web-api";
+import { rememberSessionLabel } from "../be/db/session-labels";
+import { getSlackApp } from "./app";
+import { callSlackWithRetry, slackErrorCode } from "./render-v2";
+
+const LABEL_TTL_MS = 24 * 60 * 60 * 1000;
+const FAILURE_TTL_MS = 10 * 60 * 1000;
+const FAILURE_CACHE_MAX = 500;
+const LOOKUP_QUEUE_MAX = 50;
+const inFlight = new Set<string>();
+const failedUntil = new Map<string, number>();
+let pending = Promise.resolve();
+
+async function channelLabel(client: WebClient, id: string): Promise<string> {
+  const result = await callSlackWithRetry(client, "conversations.info", {
+    channel: id.toUpperCase(),
+  });
+  const channel = result.channel as
+    | { name?: string; is_im?: boolean; is_mpim?: boolean; user?: string }
+    | undefined;
+  if (result.ok === false || !channel) throw new Error("Channel lookup failed");
+  if (channel.is_mpim) return "Group DM";
+  if (channel.is_im && channel.user) {
+    const result = await callSlackWithRetry(client, "users.info", { user: channel.user });
+    const user = result.user as
+      | { profile?: { display_name?: string; real_name?: string }; real_name?: string }
+      | undefined;
+    const name = user?.profile?.display_name || user?.real_name || user?.profile?.real_name;
+    if (result.ok !== false && name) return `DM · ${name}`;
+  } else if (channel.name) {
+    return `#${channel.name}`;
+  }
+  throw new Error("Channel label unavailable");
+}
+
+const CHANNEL_GROUP_KEY = /^shared\/slack\/([^/]+)\/$/;
+
+/**
+ * Queue a Slack lookup for each channel group key (`shared/slack/<channel>/`)
+ * without delaying the tree response. Other keys are ignored.
+ */
+export function warmSlackChannelLabels(groupKeys: string[]): void {
+  const client = getSlackApp()?.client;
+  if (!client) return;
+  for (const groupKey of groupKeys) {
+    const id = CHANNEL_GROUP_KEY.exec(groupKey)?.[1];
+    if (!id) continue;
+    if (inFlight.has(id) || (failedUntil.get(id) ?? 0) > Date.now()) continue;
+    failedUntil.delete(id);
+    if (inFlight.size >= LOOKUP_QUEUE_MAX) continue;
+    // Reserve failure capacity for queued work. Live failures must retain their TTL.
+    if (failedUntil.size + inFlight.size >= FAILURE_CACHE_MAX) {
+      const now = Date.now();
+      for (const [failedId, until] of failedUntil) {
+        if (until <= now) failedUntil.delete(failedId);
+      }
+      if (failedUntil.size + inFlight.size >= FAILURE_CACHE_MAX) continue;
+    }
+    inFlight.add(id);
+    pending = pending.then(async () => {
+      try {
+        const label = await channelLabel(client, id);
+        await rememberSessionLabel(groupKey, label, LABEL_TTL_MS);
+      } catch (error) {
+        failedUntil.set(id, Date.now() + FAILURE_TTL_MS);
+        console.warn(
+          `[Slack] Could not cache a session channel label: ${slackErrorCode(error) ?? "unknown error"}`,
+        );
+      } finally {
+        inFlight.delete(id);
+      }
+    });
+  }
+}

package/src/slack/handlers.ts

@@ -679,6 +679,11 @@ export function registerMessageHandler(app: App): void {
       routingThreadContext,
     );
 
+    const slack = {
+      trigger: "mention" as const,
+      messages: [{ ts: msg.ts, userId: msg.user, text: msg.text ?? "" }],
+    };
+
     if (matches.length === 0) {
       if (!botMentioned && !isImplicitMention) return ignoreSlackInbound("not_addressed");
 
@@ -742,6 +747,7 @@ export function registerMessageHandler(app: App): void {
           contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
         },
         inbound,
+        slack,
       );
       await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
       await notifySlackFileFailures(client, msg.channel, threadTs, unattached);
@@ -864,6 +870,7 @@ export function registerMessageHandler(app: App): void {
               contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
             },
             inbound,
+            slack,
           );
           const { task } = created;
           unattached.push(...created.unattached);
@@ -888,6 +895,7 @@ export function registerMessageHandler(app: App): void {
             contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
           },
           inbound,
+          slack,
         );
         const { task } = created;
         unattached.push(...created.unattached);

package/src/slack/inbound-files.ts

@@ -22,6 +22,7 @@ import { join } from "node:path";
 import type { WebClient } from "@slack/web-api";
 import { getTaskAttachments, getTaskById, promoteDraftTask, refreshDraftTaskLease } from "../be/db";
 import { MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload } from "../be/task-attachment-store";
+import type { TaskCreateEvent } from "../extensions/contract";
 import { providerPath } from "../fs/provider";
 import { getFileStorageProvider } from "../fs/registry";
 import { resolveTemplate } from "../prompts/resolver";
@@ -320,17 +321,19 @@ export async function createSlackTaskWithFiles(
   description: string,
   options: CreateTaskOptions,
   inbound: InboundSlackFiles,
+  slack?: TaskCreateEvent["slack"],
 ): Promise<{ task: AgentTask; unattached: SlackFileFailure[] }> {
   noteSlackInboundSideEffect("task_created");
+  const context = { origin: "slack" as const, slack };
   if (inbound.fetched.length === 0) {
-    const task = await createTaskWithSiblingAwareness(description, options, { origin: "slack" });
+    const task = await createTaskWithSiblingAwareness(description, options, context);
     return { task, unattached: inbound.failed };
   }
 
   const task = await createTaskWithSiblingAwareness(
     description,
     { ...options, status: "draft" },
-    { origin: "slack" },
+    context,
   );
   const unattached = [...inbound.failed];
   // Uploads run one after another and can outlast the abandoned-draft sweep's

package/src/slack/thread-buffer.ts

@@ -313,6 +313,10 @@ async function slackFlush(
         contextKey: slackContextKey({ channelId, threadTs }),
       },
       inbound,
+      {
+        trigger: "thread-buffer",
+        messages: items.map(({ ts, userId, text }) => ({ ts, userId, text })),
+      },
     );
   } catch (error) {
     if (!(error instanceof TaskCreationBlockedError)) throw error;

package/src/tasks/sibling-awareness.ts

@@ -18,7 +18,7 @@ import {
   getInProgressTasksByContextKey,
 } from "../be/db";
 import { applyPreTaskCreate } from "../extensions/apply-task-create";
-import type { TaskCreateOrigin } from "../extensions/contract";
+import type { TaskCreateEvent, TaskCreateOrigin } from "../extensions/contract";
 import type { AgentTask } from "../types";
 import { TaskCreationBlockedError } from "./errors";
 import {
@@ -151,7 +151,11 @@ export type PreparedTaskCreate = { description: string; options: CreateTaskOptio
 export async function prepareTaskWithSiblingAwareness(
   description: string,
   options: CreateTaskOptions,
-  args: { origin?: TaskCreateOrigin; allowCustomModel?: boolean } = {},
+  args: {
+    origin?: TaskCreateOrigin;
+    allowCustomModel?: boolean;
+    slack?: TaskCreateEvent["slack"];
+  } = {},
 ): Promise<PreparedTaskCreate> {
   const preCreate = await applyPreTaskCreate({
     description,
@@ -159,6 +163,7 @@ export async function prepareTaskWithSiblingAwareness(
     // Preserve the plan's REST default for callers without an explicit ingress origin.
     origin: args.origin ?? "rest",
     allowCustomModel: args.allowCustomModel,
+    slack: args.slack,
   });
   if (preCreate.kind === "blocked") {
     throw new TaskCreationBlockedError(preCreate.reason, preCreate.extension);
@@ -169,7 +174,11 @@ export async function prepareTaskWithSiblingAwareness(
 export async function createTaskWithSiblingAwareness(
   description: string,
   options: CreateTaskOptions,
-  args: { origin?: TaskCreateOrigin; allowCustomModel?: boolean } = {},
+  args: {
+    origin?: TaskCreateOrigin;
+    allowCustomModel?: boolean;
+    slack?: TaskCreateEvent["slack"];
+  } = {},
 ): Promise<AgentTask> {
   const { description: d, options: o } = await prepareTaskWithSiblingAwareness(
     description,

package/src/telemetry-context.ts

@@ -12,8 +12,8 @@ import catalog from "./telemetry-contract/catalog.json";
 import {
   COMPANY_ACQUISITION_SOURCES,
   COMPANY_TEAM_SIZES,
-  COMPANY_USE_CASES,
-  USER_FUNCTIONS,
+  reportedUseCase,
+  reportedUserFunction,
 } from "./utils/company-profile";
 
 /** `org_` + 16 lowercase hex (self-host, minted here) or 27 alphanumerics (cloud). Same pattern the proxy enforces. */
@@ -115,10 +115,9 @@ export function buildContext(input: ContextInput): EventContext {
   const orgDomain = validOrgDomain(input.orgDomain);
   const orgWebsite = validOrgDomain(input.orgWebsite);
   const teamSize = COMPANY_TEAM_SIZES.find((value) => value === input.teamSize);
-  const useCase = COMPANY_USE_CASES.find((value) => value === input.useCase);
-  const userFunction = userId
-    ? USER_FUNCTIONS.find((value) => value === input.userFunction)
-    : undefined;
+  // A value the catalog does not list yet is left out, as if unset.
+  const useCase = reportedUseCase(input.useCase);
+  const userFunction = userId ? reportedUserFunction(input.userFunction) : undefined;
   return {
     org_id: input.orgId,
     org_name: orgName ? orgName : null,