@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/tests/workflow-system-one-decision-providers.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, getDbClient, initDb, upsertSwarmConfig } from "../be/db";
+import { SYSTEM_ONE_DEFAULT_PROVIDER_OPTIONS, validateConfigValue } from "../be/swarm-config-guard";
 import type { WorkflowNode } from "../types";
 import { validateDefinition } from "../workflows/definition";
 import { InProcessEventBus } from "../workflows/event-bus";
@@ -11,6 +12,7 @@ import {
   SystemOneDecisionExecutor,
   type SystemOneDecisionExecutorOptions,
 } from "../workflows/executors/system-one-decision";
+import { SYSTEM_ONE_PROVIDER_IDS } from "../workflows/executors/system-one-providers";
 import { interpolate } from "../workflows/template";
 
 const TEST_DB_PATH = "./test-workflow-system-one-decision-providers.sqlite";
@@ -50,7 +52,7 @@ afterAll(async () => {
 
 beforeEach(async () => {
   await getDbClient().run(
-    "DELETE FROM swarm_config WHERE key IN ('OPENAI_API_KEY', 'OPENAI_DECISIONS_API_KEY', 'CLOUDFLARE_ACCOUNT_ID', 'CLOUDFLARE_API_TOKEN')",
+    "DELETE FROM swarm_config WHERE key IN ('OPENAI_API_KEY', 'OPENAI_DECISIONS_API_KEY', 'CLOUDFLARE_ACCOUNT_ID', 'CLOUDFLARE_API_TOKEN', 'SYSTEM_ONE_DEFAULT_PROVIDER')",
   );
 });
 
@@ -708,6 +710,101 @@ describe("system-one-decision openai provider", () => {
   });
 });
 
+// ─── Default provider ───────────────────────────────────────
+
+describe("system-one-decision default provider", () => {
+  const TYPESAFE_KEY = "typesafe-example-test-key-0123456789";
+  const jevBody = () =>
+    jsonResponse({
+      model: "jev",
+      answers: systemOneAnswers,
+      usage: { input_tokens: 1, output_tokens: 0 },
+    });
+  const setDefault = (value: string) =>
+    upsertSwarmConfig({ scope: "global", key: "SYSTEM_ONE_DEFAULT_PROVIDER", value });
+  const withTypesafeKey = {
+    getApiKey: async (id: string) =>
+      id === "typesafe" ? TYPESAFE_KEY : id === "cloudflare" ? CF_TOKEN : null,
+  };
+
+  test("unset, a node with no provider still calls typesafe", async () => {
+    const { executor, calls } = makeExecutor([jevBody()], withTypesafeKey);
+    const result = await run(executor, config());
+    expect(result.status).toBe("success");
+    expect(calls[0]?.url).toBe("https://api.typesafe.ai/v1/systemone");
+    expect(calls[0]?.body.model).toBe("jev-latest");
+    // The schema leaves the provider unset; the executor resolves it per run.
+    expect(SystemOneDecisionConfigSchema.parse(config()).provider).toBeUndefined();
+  });
+
+  test("set to cloudflare, a node with no provider calls Clef with no workflow edit", async () => {
+    await setDefault("cloudflare");
+    const { executor, calls } = makeExecutor([jsonResponse(clefEnvelope())], withTypesafeKey);
+    const result = await run(executor, config());
+    expect(result.status).toBe("success");
+    expect(calls[0]?.url).toBe(`${CF_BASE}/clef`);
+    expect((calls[0]?.init.headers as Record<string, string>).authorization).toBe(
+      `Bearer ${CF_TOKEN}`,
+    );
+    expect(result.output).toMatchObject({ model: "clef", answers: systemOneAnswers as never });
+  });
+
+  test("a node that names its provider keeps it", async () => {
+    await setDefault("cloudflare");
+    const { executor, calls } = makeExecutor([jevBody()], withTypesafeKey);
+    expect((await run(executor, config({ provider: "typesafe" }))).status).toBe("success");
+    expect(calls[0]?.url).toBe("https://api.typesafe.ai/v1/systemone");
+  });
+
+  test("readiness checks the default provider's credentials", async () => {
+    await setDefault("cloudflare");
+    const { executor } = makeExecutor([], { getApiKey: async () => null });
+    const problems = await executor.checkReadiness([{ id: "a", config: config() }]);
+    expect(problems).toHaveLength(1);
+    expect(problems[0]?.nodeIds).toEqual(["a"]);
+    expect(problems[0]?.message).toContain("CLOUDFLARE_API_TOKEN is not configured");
+  });
+
+  test("the environment is read when no row is stored; a stored row wins", async () => {
+    const env = { SYSTEM_ONE_DEFAULT_PROVIDER: "cloudflare" };
+    const fromEnv = makeExecutor([jsonResponse(clefEnvelope())], { ...withTypesafeKey, env });
+    expect((await run(fromEnv.executor, config())).status).toBe("success");
+    expect(fromEnv.calls[0]?.url).toBe(`${CF_BASE}/clef`);
+
+    await setDefault("typesafe");
+    const stored = makeExecutor([jevBody()], { ...withTypesafeKey, env });
+    expect((await run(stored.executor, config())).status).toBe("success");
+    expect(stored.calls[0]?.url).toBe("https://api.typesafe.ai/v1/systemone");
+  });
+
+  test("a defaulted provider's limits are checked at run, and nothing is sent", async () => {
+    await setDefault("cloudflare");
+    const qs: Record<string, unknown> = {};
+    const rs: Record<string, unknown> = {};
+    for (let i = 0; i < 65; i++) {
+      qs[`q${i}`] = { type: "noul", instructions: `Question ${i}?` };
+      rs[`q${i}`] = { type: "noul" };
+    }
+    const { executor, calls } = makeExecutor([jsonResponse(clefEnvelope())]);
+    const result = await run(executor, config({ questions: qs, returns: rs }));
+    expect(result.status).toBe("failed");
+    expect(result.error).toContain("at most 64 questions per node; this node has 65");
+    expect(calls).toHaveLength(0);
+  });
+
+  test("the config guard accepts exactly the decide hosts", () => {
+    expect([...SYSTEM_ONE_DEFAULT_PROVIDER_OPTIONS].sort()).toEqual(
+      [...SYSTEM_ONE_PROVIDER_IDS].sort(),
+    );
+    for (const id of SYSTEM_ONE_PROVIDER_IDS) {
+      expect(validateConfigValue("SYSTEM_ONE_DEFAULT_PROVIDER", id)).toBeNull();
+    }
+    expect(validateConfigValue("SYSTEM_ONE_DEFAULT_PROVIDER", "jev")).toContain(
+      "Invalid SYSTEM_ONE_DEFAULT_PROVIDER value",
+    );
+  });
+});
+
 // ─── Existing providers ─────────────────────────────────────
 
 describe("system-one-decision SystemOne wire is unchanged", () => {

package/src/tests/workflow-system-one-decision.test.ts

@@ -227,7 +227,8 @@ describe("system-one-decision config schema", () => {
       questions: { fit: { type: "noul", instructions: "Is it real?" } },
       returns: { fit: { type: "noul" } },
     });
-    expect(parsed.provider).toBe("typesafe");
+    // Unset: the executor reads SYSTEM_ONE_DEFAULT_PROVIDER at run time (typesafe when unset).
+    expect(parsed.provider).toBeUndefined();
     // The model default belongs to the provider, so the schema leaves it unset.
     expect(parsed.model).toBeUndefined();
     expect(parsed.timeoutMs).toBe(30_000);

package/src/tests/workflow-tla-races.test.ts

@@ -213,7 +213,7 @@ describe("TLA+ workflow counterexamples", () => {
     const stepB = await untilStatus(runId, "B", "waiting");
 
     // EF: B's task fails -> run failed.
-    await failStepAndRunIfWaiting(stepB!.id, runId, "task failed");
+    await failStepAndRunIfWaiting(def, stepB!.id, runId, "task failed");
     expect((await getWorkflowRun(runId))?.status).toBe("failed");
 
     // U1/U2: the user retries; findReadyNodes returns A because it is not completed.
@@ -240,7 +240,7 @@ describe("TLA+ workflow counterexamples", () => {
 
     // EF: B's task fails -> run failed. XCkWait(A): the checkpoint CAS sees a
     // failed run, so A's row stays `running` with its task out.
-    await failStepAndRunIfWaiting(stepB!.id, runId, "task failed");
+    await failStepAndRunIfWaiting(def, stepB!.id, runId, "task failed");
     holdA.release();
     await initial;
     expect((await stepsOf(runId, "A"))[0]?.status).toBe("running");

package/src/tools/chat-access.ts

@@ -1,8 +1,18 @@
+import * as z from "zod";
 import { getAgentById, getAgentCurrentTask, getTaskById } from "@/be/db";
 import { can } from "@/rbac";
 import { chatThreadOfContextKey } from "@/tasks/context-key";
 import type { RequestInfo } from "@/tools/utils";
 
+/** The `attachments` input of `chat-reply` and `chat-post`. */
+export const chatAttachmentsSchema = z
+  .array(z.string().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.",
+  );
+
 /** Chat SDK verbs; the legacy policy grants them to the lead only. */
 export type ChatVerb = "integration.chat.post" | "integration.chat.read" | "integration.chat.dm";
 

package/src/tools/chat-post.ts

@@ -2,8 +2,13 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { CHAT_SDK_ADAPTER_NAMES } from "@/integrations/chat-sdk/config";
 import { errorMessage } from "@/integrations/chat-sdk/logger";
-import { adapterOfChatId, postChatMessage } from "@/integrations/chat-sdk/outbound";
-import { canUseChatVerb } from "@/tools/chat-access";
+import {
+  adapterOfChatId,
+  postChatMessage,
+  unsentFilesSummary,
+} from "@/integrations/chat-sdk/outbound";
+import { resolveChatAttachmentRefs } from "@/integrations/chat-sdk/outbound-files";
+import { canUseChatVerb, chatAttachmentsSchema } from "@/tools/chat-access";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 export const registerChatPostTool = (server: McpServer) => {
@@ -27,6 +32,7 @@ export const registerChatPostTool = (server: McpServer) => {
           .optional()
           .describe("Full SDK channel id, such as slack:C123. Ignored when threadId is set."),
         text: z.string().min(1).max(20_000).describe("Markdown text to post."),
+        attachments: chatAttachmentsSchema,
       }),
       outputSchema: swarmToolOutputSchema({
         yourAgentId: z.string().optional(),
@@ -34,9 +40,12 @@ export const registerChatPostTool = (server: McpServer) => {
         adapter: z.string().optional(),
         threadId: z.string().optional(),
         channelId: z.string().optional(),
+        unsentFiles: z
+          .array(z.looseObject({ name: z.string().optional(), reason: z.string().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) return toolErr("Give a threadId or a channelId.", { data });
@@ -49,22 +58,33 @@ export const registerChatPostTool = (server: McpServer) => {
           { 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,
+          files: resolved.files,
         });
-        return toolOk(`Posted to ${adapter} ${threadId ? "thread" : "channel"} ${target}.`, {
-          data: {
-            ...data,
-            messageId: sent.messageIds.at(-1),
-            adapter: sent.adapter,
-            threadId: sent.threadId,
-            channelId: sent.channelId,
+        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,
+              unsentFiles: sent.unsentFiles,
+            },
           },
-        });
+        );
       } catch (error) {
         const message = errorMessage(error);
         return toolErr(`Could not post: ${message}`, { data });

package/src/tools/chat-reply.ts

@@ -2,8 +2,14 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getAgentCurrentTask, getTaskById } from "@/be/db";
 import { errorMessage } from "@/integrations/chat-sdk/logger";
-import { ChatAdapterUnavailableError, postChatMessage } from "@/integrations/chat-sdk/outbound";
+import {
+  ChatAdapterUnavailableError,
+  postChatMessage,
+  unsentFilesSummary,
+} from "@/integrations/chat-sdk/outbound";
+import { resolveChatAttachmentRefs } from "@/integrations/chat-sdk/outbound-files";
 import { chatThreadOfContextKey } from "@/tasks/context-key";
+import { chatAttachmentsSchema } from "@/tools/chat-access";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 export const registerChatReplyTool = (server: McpServer) => {
@@ -12,19 +18,23 @@ export const registerChatReplyTool = (server: McpServer) => {
     {
       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.",
+        "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: z.object({
         text: z.string().min(1).max(20_000).describe("Markdown text to post to the thread."),
+        attachments: chatAttachmentsSchema,
       }),
       outputSchema: swarmToolOutputSchema({
         yourAgentId: z.string().optional(),
         messageId: z.string().optional(),
         adapter: z.string().optional(),
         threadId: z.string().optional(),
+        unsentFiles: z
+          .array(z.looseObject({ name: z.string().optional(), reason: z.string().optional() }))
+          .optional(),
       }),
     },
-    async ({ text }, requestInfo) => {
+    async ({ text, attachments }, requestInfo) => {
       if (!requestInfo.agentId) return toolErr("Agent ID not found.");
       const data = { yourAgentId: requestInfo.agentId };
 
@@ -46,21 +56,33 @@ export const registerChatReplyTool = (server: McpServer) => {
         );
       }
 
+      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,
+          files: resolved.files,
         });
-        return toolOk(`Posted to ${thread.adapter} thread ${sent.threadId}.`, {
-          data: {
-            ...data,
-            messageId: sent.messageIds.at(-1),
-            adapter: sent.adapter,
-            threadId: 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,
+              unsentFiles: sent.unsentFiles,
+            },
           },
-        });
+        );
       } catch (error) {
         const message = errorMessage(error);
         return toolErr(

package/src/tools/memory-search.ts

@@ -11,6 +11,7 @@ import {
   recordRetrievals,
 } from "@/be/memory/raters/retrieval";
 import { rerank } from "@/be/memory/reranker";
+import { searchMemoryCandidates } from "@/be/memory/search-candidates";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import type { AgentMemorySource } from "@/types";
 import { AgentMemoryScopeSchema, AgentMemorySourceSchema } from "@/types";
@@ -122,7 +123,8 @@ export const registerMemorySearchTool = (server: McpServer) => {
       const queryEmbedding = await provider.embed(query);
 
       const candidateLimit = limit * CANDIDATE_SET_MULTIPLIER;
-      const candidates = await store.search(
+      const candidates = await searchMemoryCandidates(
+        store,
         queryEmbedding ?? new Float32Array(0),
         requestInfo.agentId,
         {

package/src/tools/script-delete.ts

@@ -9,7 +9,7 @@ import {
 } from "./script-common";
 
 export const SCRIPT_DELETE_DESCRIPTION =
-  "Remove a swarm-shared script from the catalog. Versions table preserves history.";
+  "Permanently remove a swarm-shared script and all its versions from the catalog. This cannot be undone.";
 
 export const registerScriptDeleteTool = (server: McpServer) => {
   createToolRegistrar(server)(

package/src/tools/system-one-decide.ts

@@ -10,7 +10,7 @@ import {
 import { SYSTEM_ONE_PROVIDER_IDS } from "@/workflows/executors/system-one-providers";
 
 /**
- * One typed decision (Jev and the other SystemOne hosts) made in the API
+ * One typed decision (Jev, Clef and the other SystemOne hosts) made in the API
  * process, the same way a `system-one-decision` workflow node makes it. The
  * provider credential is read and sent here and never reaches the caller, so a
  * script can ask for a decision without a credential binding in its own realm.
@@ -22,14 +22,16 @@ export const registerSystemOneDecideTool = (server: McpServer) => {
       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. " +
+        "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: z.object({
         provider: z
           .enum(SYSTEM_ONE_PROVIDER_IDS)
           .optional()
-          .describe("Decision host (default typesafe)"),
+          .describe(
+            "Decision host (default: the SYSTEM_ONE_DEFAULT_PROVIDER global config, typesafe when unset)",
+          ),
         model: z.string().min(1).optional().describe("Provider model id (default: the provider's)"),
         state: z
           .union([z.string(), z.array(z.string()), z.record(z.string(), z.unknown())])
@@ -55,6 +57,12 @@ export const registerSystemOneDecideTool = (server: McpServer) => {
         answers: z.record(z.string(), z.unknown()).optional(),
         usage: z.record(z.string(), z.unknown()).optional(),
         requestId: z.string().optional(),
+        providerUnavailable: z
+          .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) => {
@@ -88,7 +96,12 @@ export const registerSystemOneDecideTool = (server: McpServer) => {
         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}`, {

package/src/tools/workflows/create-workflow.ts

@@ -40,11 +40,13 @@ export const registerCreateWorkflowTool = (server: McpServer) => {
         "- 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.\n" +
         "- Agent-task config: { template, outputSchema?, agentId?, tags?, priority?, dir?, vcsRepo?, model? }.\n" +
-        "- 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: {...} } }. " +
+        "- 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. " +
-        "concurrency is not supported in v1; use definition-level onNodeFailure: 'continue' to aggregate failed children.\n" +
+        "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.\n" +
         "- 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.\n" +

package/src/types.ts

@@ -384,6 +384,7 @@ export const AgentTaskSourceSchema = z.enum([
   "github",
   "gitlab",
   "azure-devops",
+  "bitbucket",
   "agentmail",
   "system",
   "schedule",
@@ -697,7 +698,7 @@ export const AgentTaskSchema = z
     slackTreeRootMessageTs: z.string().optional(),
 
     // VCS metadata (GitHub / GitLab / Azure DevOps — provider-agnostic)
-    vcsProvider: z.enum(["github", "gitlab", "azure-devops"]).optional(),
+    vcsProvider: z.enum(["github", "gitlab", "azure-devops", "bitbucket"]).optional(),
     vcsRepo: z.string().optional(),
     vcsEventType: z.string().optional(),
     vcsNumber: z.number().int().optional(),
@@ -863,7 +864,7 @@ export const CreateTaskOptionsSchema = z.object({
    * this boundary must not let a caller silently persist a mismatch.
    */
   overrideSlackContext: z.boolean().optional(),
-  vcsProvider: z.enum(["github", "gitlab", "azure-devops"]).optional(),
+  vcsProvider: z.enum(["github", "gitlab", "azure-devops", "bitbucket"]).optional(),
   vcsRepo: z.string().optional(),
   vcsEventType: z.string().optional(),
   vcsNumber: z.number().int().optional(),
@@ -905,6 +906,12 @@ export const CreateTaskOptionsSchema = z.object({
    * contract on completion (which would block the control task — DES-523).
    */
   inheritParentOutputSchema: z.boolean().optional(),
+  /**
+   * When a `parentTaskId` is set and `requestedByUserId` is not, the child
+   * inherits the parent's requester by default. Set this to `false` when the
+   * child answers a different person (a chat message whose sender is unknown).
+   */
+  inheritParentRequester: z.boolean().optional(),
   /**
    * Skip parent routing requirements only for a child with its own explicit
    * Lead-only control-plane authorization.

package/src/utils/config-env-export.ts

@@ -8,7 +8,8 @@
  * binding instead.
  *
  * Keys below are read only by the API server (integration signing secrets, app
- * private keys, OAuth client secrets, the API's own agent-fs key). They can
+ * private keys, OAuth client secrets, the API's own agent-fs and
+ * speech-to-text keys). They can
  * never be exported: the config API rejects `exportToEnv: true` for them and
  * every reader treats a stored true as false.
  */
@@ -23,8 +24,10 @@ export const ENV_EXPORT_RESTRICTED_KEYS: ReadonlySet<string> = new Set([
   "JIRA_CLIENT_SECRET",
   "JIRA_WEBHOOK_TOKEN",
   "AZURE_DEVOPS_WEBHOOK_SECRET",
+  "BITBUCKET_WEBHOOK_SECRET",
   "AGENTMAIL_WEBHOOK_SECRET",
   "API_AGENT_FS_API_KEY",
+  "TRANSCRIPTION_API_KEY",
 ]);
 
 /**