@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/src/slack/handlers.ts

@@ -18,6 +18,7 @@ import type { SlackFile } from "./files";
 import { extractTaskFromMessage, hasOtherUserMention, routeMessage } from "./router";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
+import { extractSlackMessageText } from "./message-text";
 import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "./thread-buffer";
 import { registerTreeMessage } from "./watcher";
 
@@ -173,6 +174,8 @@ interface ThreadMessage {
   subtype?: string;
   text?: string;
   ts: string;
+  attachments?: Array<{ fallback?: string; text?: string; title?: string; pretext?: string }>;
+  blocks?: unknown[];
 }
 
 // Cache for bot's own user ID (avoids redundant auth.test calls)
@@ -286,8 +289,11 @@ async function getThreadContext(
     });
 
     const messages = (result.messages || []) as ThreadMessage[];
-    // Filter out the current message only (keep bot messages for context)
-    const previousMessages = messages.filter((m) => m.ts !== currentTs && m.text);
+    // Filter out the current message; include any message with extractable text
+    const previousMessages = messages.filter((m) => {
+      if (m.ts === currentTs) return false;
+      return extractSlackMessageText(m) !== "";
+    });
 
     if (previousMessages.length === 0) return "";
 
@@ -298,13 +304,14 @@ async function getThreadContext(
       const isBotMessage =
         m.user === botUserId || m.bot_id !== undefined || m.subtype === "bot_message";
 
+      const text = extractSlackMessageText(m);
       if (isBotMessage) {
         // Bot/agent message - truncate if too long
-        const truncatedText = m.text && m.text.length > 500 ? `${m.text.slice(0, 500)}...` : m.text;
+        const truncatedText = text.length > 500 ? `${text.slice(0, 500)}...` : text;
         formattedMessages.push(`[Agent]: ${truncatedText}`);
       } else {
         const userName = m.user ? await getUserDisplayName(client, m.user) : "Unknown";
-        formattedMessages.push(`${userName}: ${m.text}`);
+        formattedMessages.push(`${userName}: ${text}`);
       }
     }
 

package/src/slack/message-text.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared utility for extracting displayable text from a Slack message.
+ *
+ * Slack integration/alert apps (Datadog, PagerDuty, GitHub) often post with
+ * an empty top-level `text` field and put all content in legacy `attachments`
+ * or Block Kit `blocks`. This helper falls back through those layers so callers
+ * never silently drop those messages.
+ */
+
+interface SlackAttachment {
+  fallback?: string;
+  text?: string;
+  title?: string;
+  pretext?: string;
+}
+
+// Internal shape used only inside the helper; callers pass `blocks?: unknown[]`
+interface SlackBlockInternal {
+  type?: string;
+  text?: { type?: string; text?: string };
+  /** section blocks may use fields[] instead of (or alongside) a top-level text object */
+  fields?: Array<{ type?: string; text?: string }>;
+  elements?: unknown[];
+}
+
+export interface SlackMessageLike {
+  text?: string;
+  attachments?: SlackAttachment[];
+  /** Typed as unknown[] so any Slack SDK block variant is accepted without casting. */
+  blocks?: unknown[];
+}
+
+/**
+ * Recursively collect plain text from a Slack rich_text node tree.
+ *
+ * Handles text leaf nodes plus all container types that carry child elements:
+ * rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted.
+ */
+function collectRichTextParts(node: unknown, parts: string[]): void {
+  if (node == null || typeof node !== "object") return;
+  const n = node as { type?: string; text?: string; elements?: unknown[] };
+  if (n.type === "text" && n.text) {
+    parts.push(n.text);
+  }
+  if (Array.isArray(n.elements)) {
+    for (const child of n.elements) {
+      collectRichTextParts(child, parts);
+    }
+  }
+}
+
+/**
+ * Return the best displayable text for a Slack message.
+ *
+ * Priority:
+ * 1. `msg.text` (non-empty)
+ * 2. `msg.attachments[]` — joins `fallback || text || title || pretext` for each
+ * 3. `msg.blocks[]` — extracts text from section (text + fields) and rich_text blocks
+ * 4. `""` if nothing found
+ */
+export function extractSlackMessageText(msg: SlackMessageLike): string {
+  if (msg.text?.trim()) return msg.text;
+
+  // Legacy attachments (Datadog, PagerDuty, GitHub alert apps)
+  if (Array.isArray(msg.attachments) && msg.attachments.length > 0) {
+    const parts = msg.attachments
+      .filter((a): a is SlackAttachment => a != null && typeof a === "object")
+      .map((a) => a.fallback || a.text || a.title || a.pretext || "")
+      .filter(Boolean);
+    if (parts.length > 0) return parts.join("\n");
+  }
+
+  // Block Kit blocks
+  if (Array.isArray(msg.blocks) && msg.blocks.length > 0) {
+    const parts: string[] = [];
+    for (const rawBlock of msg.blocks) {
+      if (rawBlock == null || typeof rawBlock !== "object") continue;
+      const block = rawBlock as SlackBlockInternal;
+      if (block.type === "section") {
+        if (block.text?.text) parts.push(block.text.text);
+        if (Array.isArray(block.fields)) {
+          for (const field of block.fields) {
+            if (field != null && typeof field === "object" && field.text) {
+              parts.push(field.text);
+            }
+          }
+        }
+      } else if (block.type === "rich_text" && Array.isArray(block.elements)) {
+        for (const el of block.elements) {
+          collectRichTextParts(el, parts);
+        }
+      }
+    }
+    if (parts.length > 0) return parts.join("\n");
+  }
+
+  return "";
+}

package/src/slack/thread-buffer.ts

@@ -4,6 +4,7 @@ import { slackContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
+import { extractSlackMessageText } from "./message-text";
 import { registerTreeMessage } from "./watcher";
 
 interface BufferedMessage {
@@ -93,15 +94,16 @@ async function getThreadContextForBuffer(channelId: string, threadTs: string): P
     if (messages.length === 0) return "";
 
     const formatted = messages
-      .filter((m) => m.text)
+      .filter((m) => extractSlackMessageText(m) !== "")
       .map((m) => {
         const msg = m as Record<string, unknown>;
         const isBotMessage = msg.bot_id !== undefined || msg.subtype === "bot_message";
+        const text = extractSlackMessageText(m);
         if (isBotMessage) {
-          const truncated = m.text && m.text.length > 500 ? `${m.text.slice(0, 500)}...` : m.text;
+          const truncated = text.length > 500 ? `${text.slice(0, 500)}...` : text;
           return `[Agent]: ${truncated}`;
         }
-        return `<@${m.user}>: ${m.text}`;
+        return `<@${m.user}>: ${text}`;
       })
       .join("\n");
 

package/src/tests/claude-adapter-binary.test.ts

@@ -6,10 +6,12 @@
  *   1. Binary resolution — argv[0..n] tracks `parseClaudeBinary(process.env.CLAUDE_BINARY)`,
  *      with `["claude"]` as the default. Same flags follow. Supports
  *      whitespace-separated command strings (e.g. `"bunx @dexh/shannon"`).
- *   2. Tmux fail-fast — when the resolved binary string contains "shannon"
- *      (anywhere — including inside a command string), createSession throws
- *      if `tmux` is not on PATH.
- *   3. Trust pre-seed — when the resolved binary contains "shannon", the
+ *   2. Claude Bridge routing — SWARM_USE_CLAUDE_BRIDGE=true/1 forces the
+ *      installed `claude-bridge` argv prefix and wins over
+ *      `CLAUDE_BINARY`.
+ *   3. Tmux fail-fast — when the resolved binary string contains "shannon"
+ *      or claude-bridge is enabled, createSession throws if `tmux` is not on PATH.
+ *   4. Trust pre-seed — when the resolved binary contains "shannon", the
  *      adapter writes `projects[cwd].hasTrustDialogAccepted: true` to
  *      `$HOME/.claude.json` before spawning. Idempotent. No-op for "claude".
  *
@@ -27,8 +29,10 @@ import { join } from "node:path";
 import {
   ClaudeAdapter,
   parseClaudeBinary,
+  parseClaudeBridgeEnabled,
   preseedClaudeTrustDialog,
   resolveClaudeBinary,
+  resolveClaudeBridgeEnabled,
 } from "../providers/claude-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
 
@@ -150,6 +154,45 @@ describe("resolveClaudeBinary precedence", () => {
   });
 });
 
+describe("SWARM_USE_CLAUDE_BRIDGE boolean parsing", () => {
+  test("true/1 enable claude-bridge", () => {
+    expect(parseClaudeBridgeEnabled("true")).toBe(true);
+    expect(parseClaudeBridgeEnabled("TRUE")).toBe(true);
+    expect(parseClaudeBridgeEnabled(" 1 ")).toBe(true);
+  });
+
+  test("false/0/unset and invalid values are disabled", () => {
+    expect(parseClaudeBridgeEnabled("false")).toBe(false);
+    expect(parseClaudeBridgeEnabled("0")).toBe(false);
+    expect(parseClaudeBridgeEnabled(undefined)).toBe(false);
+    expect(parseClaudeBridgeEnabled("yes")).toBe(false);
+  });
+
+  test("resolvedEnv wins over fallbackEnv", () => {
+    expect(
+      resolveClaudeBridgeEnabled(
+        { SWARM_USE_CLAUDE_BRIDGE: "false" },
+        { SWARM_USE_CLAUDE_BRIDGE: "true" },
+      ),
+    ).toBe(false);
+    expect(
+      resolveClaudeBridgeEnabled(
+        { SWARM_USE_CLAUDE_BRIDGE: "1" },
+        { SWARM_USE_CLAUDE_BRIDGE: "0" },
+      ),
+    ).toBe(true);
+  });
+
+  test("empty resolvedEnv value falls through to fallbackEnv", () => {
+    expect(
+      resolveClaudeBridgeEnabled(
+        { SWARM_USE_CLAUDE_BRIDGE: " " },
+        { SWARM_USE_CLAUDE_BRIDGE: "true" },
+      ),
+    ).toBe(true);
+  });
+});
+
 describe("preseedClaudeTrustDialog", () => {
   let homeDir: string;
 
@@ -241,6 +284,7 @@ describe("preseedClaudeTrustDialog", () => {
 describe("CLAUDE_BINARY env override", () => {
   // Cache the originals and restore after each test so the suite stays clean.
   let originalClaudeBinary: string | undefined;
+  let originalUseClaudeBridge: string | undefined;
   let originalOauthToken: string | undefined;
   let originalHome: string | undefined;
   let homeDir: string;
@@ -250,11 +294,13 @@ describe("CLAUDE_BINARY env override", () => {
 
   beforeEach(async () => {
     originalClaudeBinary = process.env.CLAUDE_BINARY;
+    originalUseClaudeBridge = process.env.SWARM_USE_CLAUDE_BRIDGE;
     originalOauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
     originalHome = process.env.HOME;
     homeDir = await mkdtemp(join(tmpdir(), "claude-adapter-test-home-"));
     process.env.HOME = homeDir;
     delete process.env.CLAUDE_BINARY;
+    delete process.env.SWARM_USE_CLAUDE_BRIDGE;
     // Credential check runs before binary resolution; satisfy it.
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-token";
 
@@ -285,6 +331,11 @@ describe("CLAUDE_BINARY env override", () => {
     } else {
       process.env.CLAUDE_BINARY = originalClaudeBinary;
     }
+    if (originalUseClaudeBridge === undefined) {
+      delete process.env.SWARM_USE_CLAUDE_BRIDGE;
+    } else {
+      process.env.SWARM_USE_CLAUDE_BRIDGE = originalUseClaudeBridge;
+    }
     if (originalOauthToken === undefined) {
       delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
     } else {
@@ -422,10 +473,65 @@ describe("CLAUDE_BINARY env override", () => {
 
     expect(spawnedArgs[0][0]).toBe("shannon");
   });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=true routes through installed claude-bridge", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig());
+
+    const argv = spawnedArgs[0];
+    expect(argv[0]).toBe("claude-bridge");
+    expect(argv).toContain("--model");
+    expect(argv).toContain("-p");
+  });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=1 wins over CLAUDE_BINARY=shannon", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "1";
+    process.env.CLAUDE_BINARY = "shannon";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig());
+
+    expect(spawnedArgs[0][0]).toBe("claude-bridge");
+  });
+
+  test("config.env SWARM_USE_CLAUDE_BRIDGE=true is reloadable and wins over process.env false", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "false";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(
+      makeConfig({
+        env: {
+          SWARM_USE_CLAUDE_BRIDGE: "true",
+          CLAUDE_CODE_OAUTH_TOKEN: "test-token",
+        } as Record<string, string>,
+      }),
+    );
+
+    expect(spawnedArgs[0][0]).toBe("claude-bridge");
+  });
+
+  test("config.env SWARM_USE_CLAUDE_BRIDGE=false disables process.env true", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(
+      makeConfig({
+        env: {
+          SWARM_USE_CLAUDE_BRIDGE: "false",
+          CLAUDE_CODE_OAUTH_TOKEN: "test-token",
+        } as Record<string, string>,
+      }),
+    );
+
+    expect(spawnedArgs[0][0]).toBe("claude");
+  });
 });
 
 describe("Shannon tmux fail-fast gate", () => {
   let originalClaudeBinary: string | undefined;
+  let originalUseClaudeBridge: string | undefined;
   let originalOauthToken: string | undefined;
   let originalHome: string | undefined;
   let homeDir: string;
@@ -434,11 +540,13 @@ describe("Shannon tmux fail-fast gate", () => {
 
   beforeEach(async () => {
     originalClaudeBinary = process.env.CLAUDE_BINARY;
+    originalUseClaudeBridge = process.env.SWARM_USE_CLAUDE_BRIDGE;
     originalOauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
     originalHome = process.env.HOME;
     homeDir = await mkdtemp(join(tmpdir(), "claude-adapter-test-home-"));
     process.env.HOME = homeDir;
     delete process.env.CLAUDE_BINARY;
+    delete process.env.SWARM_USE_CLAUDE_BRIDGE;
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-token";
     spawnSpy = spyOn(Bun, "spawn").mockImplementation((() => makeFakeProc()) as typeof Bun.spawn);
     whichSpy = spyOn(Bun, "which");
@@ -458,6 +566,11 @@ describe("Shannon tmux fail-fast gate", () => {
     } else {
       process.env.CLAUDE_BINARY = originalClaudeBinary;
     }
+    if (originalUseClaudeBridge === undefined) {
+      delete process.env.SWARM_USE_CLAUDE_BRIDGE;
+    } else {
+      process.env.SWARM_USE_CLAUDE_BRIDGE = originalUseClaudeBridge;
+    }
     if (originalOauthToken === undefined) {
       delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
     } else {
@@ -520,10 +633,22 @@ describe("Shannon tmux fail-fast gate", () => {
     const adapter = new ClaudeAdapter();
     await expect(adapter.createSession(makeConfig())).rejects.toThrow(/tmux/i);
   });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=true triggers the tmux check", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+    whichSpy.mockImplementation((name: string) => {
+      if (name === "tmux") return null;
+      return null;
+    });
+
+    const adapter = new ClaudeAdapter();
+    await expect(adapter.createSession(makeConfig())).rejects.toThrow(/SWARM_USE_CLAUDE_BRIDGE/);
+  });
 });
 
 describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
   let originalClaudeBinary: string | undefined;
+  let originalUseClaudeBridge: string | undefined;
   let originalOauthToken: string | undefined;
   let originalHome: string | undefined;
   let homeDir: string;
@@ -532,11 +657,13 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
 
   beforeEach(async () => {
     originalClaudeBinary = process.env.CLAUDE_BINARY;
+    originalUseClaudeBridge = process.env.SWARM_USE_CLAUDE_BRIDGE;
     originalOauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
     originalHome = process.env.HOME;
     homeDir = await mkdtemp(join(tmpdir(), "claude-adapter-trust-test-"));
     process.env.HOME = homeDir;
     delete process.env.CLAUDE_BINARY;
+    delete process.env.SWARM_USE_CLAUDE_BRIDGE;
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "test-token";
     spawnSpy = spyOn(Bun, "spawn").mockImplementation((() => makeFakeProc()) as typeof Bun.spawn);
     whichSpy = spyOn(Bun, "which").mockImplementation((name: string) => {
@@ -559,6 +686,11 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     } else {
       process.env.CLAUDE_BINARY = originalClaudeBinary;
     }
+    if (originalUseClaudeBridge === undefined) {
+      delete process.env.SWARM_USE_CLAUDE_BRIDGE;
+    } else {
+      process.env.SWARM_USE_CLAUDE_BRIDGE = originalUseClaudeBridge;
+    }
     if (originalOauthToken === undefined) {
       delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
     } else {
@@ -625,4 +757,15 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     const exists = await Bun.file(join(homeDir, ".claude.json")).exists();
     expect(exists).toBe(false);
   });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=true does NOT use the legacy shannon trust pre-seed", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig({ cwd: "/some/abs/cwd" }));
+
+    // claude-bridge owns its own pre-clear flow; the adapter should not write
+    // the legacy shannon pre-seed file before spawning.
+    const exists = await Bun.file(join(homeDir, ".claude.json")).exists();
+    expect(exists).toBe(false);
+  });
 });

package/src/tests/claude-adapter-otel.test.ts

@@ -15,7 +15,11 @@
 
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { type Span, trace } from "@opentelemetry/api";
-import { buildClaudeCodeOtelEnv, ClaudeAdapter } from "../providers/claude-adapter";
+import {
+  buildClaudeCodeOtelEnv,
+  buildClaudeCodeRuntimeEnv,
+  ClaudeAdapter,
+} from "../providers/claude-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
 
 // Example IDs from the task — trace af2c8371…, span adff4f24… (the orphaned
@@ -136,6 +140,51 @@ describe("buildClaudeCodeOtelEnv — gate on", () => {
   });
 });
 
+describe("buildClaudeCodeRuntimeEnv", () => {
+  test("sets memory/privacy defaults for ephemeral Claude Code sessions", () => {
+    const env = buildClaudeCodeRuntimeEnv({});
+
+    expect(env.ENABLE_TOOL_SEARCH).toBe("true");
+    expect(env.CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING).toBe("1");
+    expect(env.CLAUDE_CODE_SKIP_PROMPT_HISTORY).toBe("1");
+    expect(env.CLAUDE_CODE_DISABLE_ATTACHMENTS).toBe("1");
+    expect(env.DISABLE_FEEDBACK_COMMAND).toBe("1");
+    expect(env.DISABLE_BUG_COMMAND).toBe("1");
+  });
+
+  test("always disables Claude Code Statsig/DNT telemetry", () => {
+    const env = buildClaudeCodeRuntimeEnv({});
+
+    expect(env.DISABLE_TELEMETRY).toBe("1");
+    expect(env.DO_NOT_TRACK).toBe("1");
+  });
+
+  test("keeps Claude Code Statsig/DNT opt-out separate from OTel config", () => {
+    for (const sourceEnv of [
+      { CLAUDE_CODE_ENABLE_TELEMETRY: "1" },
+      { CLAUDE_CODE_ENABLE_TELEMETRY: "true" },
+      { OTEL_EXPORTER_OTLP_ENDPOINT: "https://otel.example.test" },
+      { OTEL_TRACES_EXPORTER: "otlp" },
+      { OTEL_METRICS_EXPORTER: "otlp" },
+      { OTEL_LOGS_EXPORTER: "otlp" },
+    ]) {
+      const env = buildClaudeCodeRuntimeEnv(sourceEnv);
+      expect(env.DISABLE_TELEMETRY).toBe("1");
+      expect(env.DO_NOT_TRACK).toBe("1");
+    }
+  });
+
+  test("ignores empty OTel env values for runtime defaults", () => {
+    const env = buildClaudeCodeRuntimeEnv({
+      OTEL_EXPORTER_OTLP_ENDPOINT: "",
+      CLAUDE_CODE_ENABLE_TELEMETRY: "0",
+    });
+
+    expect(env.DISABLE_TELEMETRY).toBe("1");
+    expect(env.DO_NOT_TRACK).toBe("1");
+  });
+});
+
 // ─── Spawn integration through ClaudeAdapter.createSession ────────────────────
 
 /** Fake Bun.Subprocess — exits cleanly with no output. */
@@ -222,4 +271,39 @@ describe("ClaudeSession spawn env — SWARM_ENABLE_CLAUDE_CODE_OTEL", () => {
     expect(env?.ENABLE_PROMPT_CACHING_1H).toBe("1");
     expect(env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("test-token");
   });
+
+  test("spawn env carries Claude Code runtime guardrails", async () => {
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig({ env: { CLAUDE_CODE_OAUTH_TOKEN: "test-token" } }));
+
+    expect(spawnedEnvs).toHaveLength(1);
+    const env = spawnedEnvs[0];
+    expect(env?.ENABLE_TOOL_SEARCH).toBe("true");
+    expect(env?.CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING).toBe("1");
+    expect(env?.CLAUDE_CODE_SKIP_PROMPT_HISTORY).toBe("1");
+    expect(env?.CLAUDE_CODE_DISABLE_ATTACHMENTS).toBe("1");
+    expect(env?.DISABLE_FEEDBACK_COMMAND).toBe("1");
+    expect(env?.DISABLE_BUG_COMMAND).toBe("1");
+    expect(env?.DISABLE_TELEMETRY).toBe("1");
+    expect(env?.DO_NOT_TRACK).toBe("1");
+    expect(env?.CLAUDE_CODE_DISABLE_THINKING).toBeUndefined();
+  });
+
+  test("spawn env keeps Statsig/DNT opt-out even when OTel is configured", async () => {
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(
+      makeConfig({
+        env: {
+          CLAUDE_CODE_OAUTH_TOKEN: "test-token",
+          CLAUDE_CODE_ENABLE_TELEMETRY: "1",
+          OTEL_EXPORTER_OTLP_ENDPOINT: "https://otel.example.test",
+        },
+      }),
+    );
+
+    expect(spawnedEnvs).toHaveLength(1);
+    const env = spawnedEnvs[0];
+    expect(env?.DISABLE_TELEMETRY).toBe("1");
+    expect(env?.DO_NOT_TRACK).toBe("1");
+  });
 });

package/src/tests/db-query.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { DbQueryInputSchema, resolveDbQuerySql } from "../http/db-query";
+
+describe("db-query input compatibility", () => {
+  test("canonical sql input resolves to sql", () => {
+    const parsed = DbQueryInputSchema.parse({ sql: "SELECT 1", params: [] });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 1");
+  });
+
+  test("legacy query input remains a runtime alias", () => {
+    const parsed = DbQueryInputSchema.parse({ query: "SELECT 2" });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 2");
+  });
+
+  test("sql takes precedence when both sql and query are present", () => {
+    const parsed = DbQueryInputSchema.parse({ sql: "SELECT 3", query: "SELECT 4" });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 3");
+  });
+
+  test("rejects input without sql or query", () => {
+    const parsed = DbQueryInputSchema.safeParse({});
+
+    expect(parsed.success).toBe(false);
+  });
+});