@desplega.ai/agent-swarm 1.91.0 → 1.92.1

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

@@ -5,13 +5,17 @@
  * Behaviors under test:
  *   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
- *      adapter writes `projects[cwd].hasTrustDialogAccepted: true` to
- *      `$HOME/.claude.json` before spawning. Idempotent. No-op for "claude".
+ *      whitespace-separated command strings.
+ *   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 uses the legacy
+ *      bridge compatibility path or claude-bridge is enabled, createSession
+ *      throws if `tmux` is not on PATH.
+ *   4. Trust pre-seed — when the resolved path drives interactive claude in
+ *      tmux, the adapter writes
+ *      `projects[cwd].hasTrustDialogAccepted: true` to `$HOME/.claude.json`
+ *      before spawning. Idempotent. No-op for "claude".
  *
  * `Bun.spawn` is stubbed so the tests don't actually exec anything; we read
  * the argv off the call args. `Bun.which` is stubbed for the tmux gate so
@@ -27,11 +31,17 @@ import { join } from "node:path";
 import {
   ClaudeAdapter,
   parseClaudeBinary,
+  parseClaudeBridgeEnabled,
   preseedClaudeTrustDialog,
   resolveClaudeBinary,
+  resolveClaudeBridgeEnabled,
 } from "../providers/claude-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
 
+const LEGACY_BRIDGE_COMPAT_BINARY = "shan" + "non";
+const LEGACY_BRIDGE_COMPAT_PACKAGE = `@dexh/${LEGACY_BRIDGE_COMPAT_BINARY}`;
+const LEGACY_BRIDGE_COMPAT_COMMAND = `bunx ${LEGACY_BRIDGE_COMPAT_PACKAGE}`;
+
 /** Minimal config — empty apiUrl/apiKey/agentId skips the MCP-server fetch. */
 function makeConfig(overrides: Partial<ProviderSessionConfig> = {}): ProviderSessionConfig {
   return {
@@ -79,36 +89,54 @@ describe("parseClaudeBinary", () => {
 
   test("single token → one-element array", () => {
     expect(parseClaudeBinary("claude")).toEqual(["claude"]);
-    expect(parseClaudeBinary("shannon")).toEqual(["shannon"]);
-    expect(parseClaudeBinary("/usr/local/bin/shannon")).toEqual(["/usr/local/bin/shannon"]);
+    expect(parseClaudeBinary(LEGACY_BRIDGE_COMPAT_BINARY)).toEqual([LEGACY_BRIDGE_COMPAT_BINARY]);
+    expect(parseClaudeBinary(`/usr/local/bin/${LEGACY_BRIDGE_COMPAT_BINARY}`)).toEqual([
+      `/usr/local/bin/${LEGACY_BRIDGE_COMPAT_BINARY}`,
+    ]);
   });
 
   test("command string → whitespace-split argv", () => {
-    expect(parseClaudeBinary("bunx @dexh/shannon")).toEqual(["bunx", "@dexh/shannon"]);
-    expect(parseClaudeBinary("npx -y @dexh/shannon")).toEqual(["npx", "-y", "@dexh/shannon"]);
+    expect(parseClaudeBinary(LEGACY_BRIDGE_COMPAT_COMMAND)).toEqual([
+      "bunx",
+      LEGACY_BRIDGE_COMPAT_PACKAGE,
+    ]);
+    expect(parseClaudeBinary(`npx -y ${LEGACY_BRIDGE_COMPAT_PACKAGE}`)).toEqual([
+      "npx",
+      "-y",
+      LEGACY_BRIDGE_COMPAT_PACKAGE,
+    ]);
   });
 
   test("version-pinned → preserves the version suffix", () => {
-    expect(parseClaudeBinary("bunx @dexh/shannon@1.2.3")).toEqual(["bunx", "@dexh/shannon@1.2.3"]);
+    expect(parseClaudeBinary(`${LEGACY_BRIDGE_COMPAT_COMMAND}@1.2.3`)).toEqual([
+      "bunx",
+      `${LEGACY_BRIDGE_COMPAT_PACKAGE}@1.2.3`,
+    ]);
   });
 
   test("multiple-space tolerance → trims + collapses", () => {
-    expect(parseClaudeBinary("  bunx  shannon  ")).toEqual(["bunx", "shannon"]);
-    expect(parseClaudeBinary("\tbunx\t@dexh/shannon\n")).toEqual(["bunx", "@dexh/shannon"]);
+    expect(parseClaudeBinary(`  bunx  ${LEGACY_BRIDGE_COMPAT_BINARY}  `)).toEqual([
+      "bunx",
+      LEGACY_BRIDGE_COMPAT_BINARY,
+    ]);
+    expect(parseClaudeBinary(`\tbunx\t${LEGACY_BRIDGE_COMPAT_PACKAGE}\n`)).toEqual([
+      "bunx",
+      LEGACY_BRIDGE_COMPAT_PACKAGE,
+    ]);
   });
 });
 
 describe("resolveClaudeBinary precedence", () => {
   test("resolvedEnv wins over fallbackEnv (swarm_config overrides process.env)", () => {
-    const resolvedEnv = { CLAUDE_BINARY: "shannon" };
+    const resolvedEnv = { CLAUDE_BINARY: LEGACY_BRIDGE_COMPAT_BINARY };
     const fallbackEnv = { CLAUDE_BINARY: "claude" };
-    expect(resolveClaudeBinary(resolvedEnv, fallbackEnv)).toBe("shannon");
+    expect(resolveClaudeBinary(resolvedEnv, fallbackEnv)).toBe(LEGACY_BRIDGE_COMPAT_BINARY);
   });
 
   test("falls back to fallbackEnv when resolvedEnv is absent", () => {
     const resolvedEnv = {};
-    const fallbackEnv = { CLAUDE_BINARY: "bunx @dexh/shannon" };
-    expect(resolveClaudeBinary(resolvedEnv, fallbackEnv)).toBe("bunx @dexh/shannon");
+    const fallbackEnv = { CLAUDE_BINARY: LEGACY_BRIDGE_COMPAT_COMMAND };
+    expect(resolveClaudeBinary(resolvedEnv, fallbackEnv)).toBe(LEGACY_BRIDGE_COMPAT_COMMAND);
   });
 
   test("both absent → 'claude' default", () => {
@@ -117,12 +145,12 @@ describe("resolveClaudeBinary precedence", () => {
 
   test("empty / whitespace-only resolvedEnv value falls through to fallbackEnv", () => {
     // `.trim() || …` falls through on empty/whitespace.
-    expect(resolveClaudeBinary({ CLAUDE_BINARY: "" }, { CLAUDE_BINARY: "shannon" })).toBe(
-      "shannon",
-    );
-    expect(resolveClaudeBinary({ CLAUDE_BINARY: "   " }, { CLAUDE_BINARY: "shannon" })).toBe(
-      "shannon",
-    );
+    expect(
+      resolveClaudeBinary({ CLAUDE_BINARY: "" }, { CLAUDE_BINARY: LEGACY_BRIDGE_COMPAT_BINARY }),
+    ).toBe(LEGACY_BRIDGE_COMPAT_BINARY);
+    expect(
+      resolveClaudeBinary({ CLAUDE_BINARY: "   " }, { CLAUDE_BINARY: LEGACY_BRIDGE_COMPAT_BINARY }),
+    ).toBe(LEGACY_BRIDGE_COMPAT_BINARY);
   });
 
   test("empty fallback after empty resolved → 'claude' default", () => {
@@ -130,8 +158,8 @@ describe("resolveClaudeBinary precedence", () => {
   });
 
   test("command-string passes through unchanged (caller does the argv split)", () => {
-    const resolvedEnv = { CLAUDE_BINARY: "bunx @dexh/shannon@1.2.3" };
-    expect(resolveClaudeBinary(resolvedEnv, {})).toBe("bunx @dexh/shannon@1.2.3");
+    const resolvedEnv = { CLAUDE_BINARY: `${LEGACY_BRIDGE_COMPAT_COMMAND}@1.2.3` };
+    expect(resolveClaudeBinary(resolvedEnv, {})).toBe(`${LEGACY_BRIDGE_COMPAT_COMMAND}@1.2.3`);
   });
 
   test("fallbackEnv defaults to process.env when omitted", () => {
@@ -150,6 +178,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,26 +308,32 @@ 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;
   let spawnSpy: ReturnType<typeof spyOn>;
   let whichSpy: ReturnType<typeof spyOn>;
   let spawnedArgs: Array<readonly string[]>;
+  let spawnedEnvs: Array<Record<string, string> | undefined>;
 
   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";
 
     spawnedArgs = [];
-    spawnSpy = spyOn(Bun, "spawn").mockImplementation(((cmd: readonly string[]) => {
+    spawnedEnvs = [];
+    spawnSpy = spyOn(Bun, "spawn").mockImplementation(((cmd: readonly string[], opts?: unknown) => {
       spawnedArgs.push(cmd);
+      spawnedEnvs.push((opts as { env?: Record<string, string> } | undefined)?.env);
       return makeFakeProc();
     }) as typeof Bun.spawn);
 
@@ -285,6 +358,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 {
@@ -301,68 +379,68 @@ describe("CLAUDE_BINARY env override", () => {
     expect(argv[0]).toBe("claude");
   });
 
-  test("override: argv[0] is 'shannon' when CLAUDE_BINARY=shannon", async () => {
-    process.env.CLAUDE_BINARY = "shannon";
+  test("legacy bridge override: argv[0] comes from CLAUDE_BINARY", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig());
 
     const argv = spawnedArgs[0];
-    expect(argv[0]).toBe("shannon");
+    expect(argv[0]).toBe(LEGACY_BRIDGE_COMPAT_BINARY);
   });
 
-  test("custom path: argv[0] is the absolute path when CLAUDE_BINARY=/usr/local/bin/shannon", async () => {
-    process.env.CLAUDE_BINARY = "/usr/local/bin/shannon";
+  test("custom legacy bridge path: argv[0] is the absolute path", async () => {
+    process.env.CLAUDE_BINARY = `/usr/local/bin/${LEGACY_BRIDGE_COMPAT_BINARY}`;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig());
 
-    expect(spawnedArgs[0][0]).toBe("/usr/local/bin/shannon");
+    expect(spawnedArgs[0][0]).toBe(`/usr/local/bin/${LEGACY_BRIDGE_COMPAT_BINARY}`);
   });
 
-  test("command string: 'bunx @dexh/shannon' → argv[0..1] is ['bunx', '@dexh/shannon']", async () => {
-    process.env.CLAUDE_BINARY = "bunx @dexh/shannon";
+  test("legacy bridge command string → argv[0..1] is split", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_COMMAND;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig());
 
     const argv = spawnedArgs[0];
     expect(argv[0]).toBe("bunx");
-    expect(argv[1]).toBe("@dexh/shannon");
+    expect(argv[1]).toBe(LEGACY_BRIDGE_COMPAT_PACKAGE);
     // Claude args follow.
     expect(argv).toContain("--model");
     expect(argv).toContain("-p");
   });
 
-  test("version-pinned command string: argv[0..1] = ['bunx', '@dexh/shannon@1.2.3']", async () => {
-    process.env.CLAUDE_BINARY = "bunx @dexh/shannon@1.2.3";
+  test("version-pinned legacy bridge command string keeps package suffix", async () => {
+    process.env.CLAUDE_BINARY = `${LEGACY_BRIDGE_COMPAT_COMMAND}@1.2.3`;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig());
 
     const argv = spawnedArgs[0];
     expect(argv[0]).toBe("bunx");
-    expect(argv[1]).toBe("@dexh/shannon@1.2.3");
+    expect(argv[1]).toBe(`${LEGACY_BRIDGE_COMPAT_PACKAGE}@1.2.3`);
   });
 
-  test("multiple-space tolerance: '  bunx  shannon  ' → argv = ['bunx', 'shannon', ...]", async () => {
-    process.env.CLAUDE_BINARY = "  bunx  shannon  ";
+  test("multiple-space tolerance for legacy bridge command", async () => {
+    process.env.CLAUDE_BINARY = `  bunx  ${LEGACY_BRIDGE_COMPAT_BINARY}  `;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig());
 
     const argv = spawnedArgs[0];
     expect(argv[0]).toBe("bunx");
-    expect(argv[1]).toBe("shannon");
+    expect(argv[1]).toBe(LEGACY_BRIDGE_COMPAT_BINARY);
     expect(argv).toContain("--model");
   });
 
-  test("argv[1..] (after prefix) matches between default 'claude' and command-string 'bunx @dexh/shannon'", async () => {
-    process.env.CLAUDE_BINARY = "bunx @dexh/shannon";
+  test("argv[1..] after prefix matches between default and legacy bridge command", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_COMMAND;
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig());
     // Drop the 2-element prefix.
-    const argvShannon = spawnedArgs[0].slice(2);
+    const argvLegacyBridge = spawnedArgs[0].slice(2);
 
     spawnedArgs = [];
     delete process.env.CLAUDE_BINARY;
@@ -370,47 +448,47 @@ describe("CLAUDE_BINARY env override", () => {
     // Drop the 1-element prefix.
     const argvClaude = spawnedArgs[0].slice(1);
 
-    expect(argvShannon).toEqual(argvClaude);
+    expect(argvLegacyBridge).toEqual(argvClaude);
   });
 
   test("swarm_config overlay (config.env) wins over process.env CLAUDE_BINARY", async () => {
     // process.env says "claude" — but the runner's resolvedEnv overlay (passed
-    // through config.env) says "shannon". The overlay must win, mirroring the
+    // through config.env) says a legacy bridge binary. The overlay must win, mirroring the
     // HARNESS_PROVIDER reload path.
     process.env.CLAUDE_BINARY = "claude";
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(
       makeConfig({
-        env: { CLAUDE_BINARY: "shannon", CLAUDE_CODE_OAUTH_TOKEN: "test-token" } as Record<
-          string,
-          string
-        >,
+        env: {
+          CLAUDE_BINARY: LEGACY_BRIDGE_COMPAT_BINARY,
+          CLAUDE_CODE_OAUTH_TOKEN: "test-token",
+        } as Record<string, string>,
       }),
     );
 
-    expect(spawnedArgs[0][0]).toBe("shannon");
+    expect(spawnedArgs[0][0]).toBe(LEGACY_BRIDGE_COMPAT_BINARY);
   });
 
-  test("config.env CLAUDE_BINARY='bunx @dexh/shannon' (swarm_config override) splits + spawns correctly", async () => {
+  test("config.env legacy bridge command override splits + spawns correctly", async () => {
     delete process.env.CLAUDE_BINARY;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(
       makeConfig({
         env: {
-          CLAUDE_BINARY: "bunx @dexh/shannon",
+          CLAUDE_BINARY: LEGACY_BRIDGE_COMPAT_COMMAND,
           CLAUDE_CODE_OAUTH_TOKEN: "test-token",
         } as Record<string, string>,
       }),
     );
 
     expect(spawnedArgs[0][0]).toBe("bunx");
-    expect(spawnedArgs[0][1]).toBe("@dexh/shannon");
+    expect(spawnedArgs[0][1]).toBe(LEGACY_BRIDGE_COMPAT_PACKAGE);
   });
 
   test("config.env without CLAUDE_BINARY falls back to process.env", async () => {
-    process.env.CLAUDE_BINARY = "shannon";
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(
@@ -420,12 +498,94 @@ describe("CLAUDE_BINARY env override", () => {
       }),
     );
 
-    expect(spawnedArgs[0][0]).toBe("shannon");
+    expect(spawnedArgs[0][0]).toBe(LEGACY_BRIDGE_COMPAT_BINARY);
+  });
+
+  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=true passes OAuth token to the bridge process", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig());
+
+    expect(spawnedArgs[0][0]).toBe("claude-bridge");
+    expect(spawnedEnvs[0]?.CLAUDE_CODE_OAUTH_TOKEN).toBe("test-token");
+  });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=true forwards Anthropic local auth through bridge flag", async () => {
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(
+      makeConfig({
+        env: {
+          SWARM_USE_CLAUDE_BRIDGE: "true",
+          ANTHROPIC_API_KEY: "sk-ant-test",
+        } as Record<string, string>,
+      }),
+    );
+
+    expect(spawnedArgs[0][0]).toBe("claude-bridge");
+    expect(spawnedArgs[0]).toContain("--desplega-local-auth");
+    expect(spawnedEnvs[0]?.ANTHROPIC_API_KEY).toBe("sk-ant-test");
+    expect(spawnedEnvs[0]?.CLAUDE_CODE_OAUTH_TOKEN).toBeUndefined();
+  });
+
+  test("SWARM_USE_CLAUDE_BRIDGE=1 wins over legacy CLAUDE_BINARY", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "1";
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
+
+    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", () => {
+describe("Claude Bridge 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 +594,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 +620,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 {
@@ -465,8 +632,8 @@ describe("Shannon tmux fail-fast gate", () => {
     }
   });
 
-  test("sad path: rejects with tmux-mentioning error when CLAUDE_BINARY=shannon and tmux is missing", async () => {
-    process.env.CLAUDE_BINARY = "shannon";
+  test("sad path: rejects with tmux-mentioning error when legacy CLAUDE_BINARY is set and tmux is missing", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
     whichSpy.mockImplementation((name: string) => {
       if (name === "tmux") return null;
       return `/usr/bin/${name}`;
@@ -476,8 +643,8 @@ describe("Shannon tmux fail-fast gate", () => {
     await expect(adapter.createSession(makeConfig())).rejects.toThrow(/tmux/i);
   });
 
-  test("happy path: does not throw when CLAUDE_BINARY=shannon and tmux IS on PATH", async () => {
-    process.env.CLAUDE_BINARY = "shannon";
+  test("happy path: does not throw when legacy CLAUDE_BINARY is set and tmux IS on PATH", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
     whichSpy.mockImplementation((name: string) => {
       if (name === "tmux") return "/usr/bin/tmux";
       return null;
@@ -487,7 +654,7 @@ describe("Shannon tmux fail-fast gate", () => {
     await expect(adapter.createSession(makeConfig())).resolves.toBeDefined();
   });
 
-  test("non-shannon binary skips the tmux check (no Bun.which call for tmux)", async () => {
+  test("default binary skips the tmux check (no Bun.which call for tmux)", async () => {
     process.env.CLAUDE_BINARY = "claude";
     whichSpy.mockImplementation((name: string) => {
       if (name === "tmux") return null;
@@ -499,8 +666,8 @@ describe("Shannon tmux fail-fast gate", () => {
     await expect(adapter.createSession(makeConfig())).resolves.toBeDefined();
   });
 
-  test("custom shannon path (e.g. /usr/local/bin/shannon) still triggers the tmux check", async () => {
-    process.env.CLAUDE_BINARY = "/usr/local/bin/shannon";
+  test("custom legacy bridge path still triggers the tmux check", async () => {
+    process.env.CLAUDE_BINARY = `/usr/local/bin/${LEGACY_BRIDGE_COMPAT_BINARY}`;
     whichSpy.mockImplementation((name: string) => {
       if (name === "tmux") return null;
       return null;
@@ -510,8 +677,8 @@ describe("Shannon tmux fail-fast gate", () => {
     await expect(adapter.createSession(makeConfig())).rejects.toThrow(/tmux/i);
   });
 
-  test("command-string CLAUDE_BINARY='bunx @dexh/shannon' still triggers the tmux check", async () => {
-    process.env.CLAUDE_BINARY = "bunx @dexh/shannon";
+  test("legacy bridge command string still triggers the tmux check", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_COMMAND;
     whichSpy.mockImplementation((name: string) => {
       if (name === "tmux") return null;
       return null;
@@ -520,10 +687,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 +711,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 +740,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 {
@@ -566,8 +752,8 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     }
   });
 
-  test("CLAUDE_BINARY=shannon writes hasTrustDialogAccepted for config.cwd", async () => {
-    process.env.CLAUDE_BINARY = "shannon";
+  test("legacy CLAUDE_BINARY writes hasTrustDialogAccepted for config.cwd", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
     const cwd = "/some/abs/cwd";
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig({ cwd }));
@@ -577,8 +763,8 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     expect(data.projects[cwd].hasCompletedProjectOnboarding).toBe(true);
   });
 
-  test("CLAUDE_BINARY='bunx @dexh/shannon' (command string) also triggers the pre-seed", async () => {
-    process.env.CLAUDE_BINARY = "bunx @dexh/shannon";
+  test("legacy CLAUDE_BINARY command string also triggers the pre-seed", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_COMMAND;
     const cwd = "/some/other/cwd";
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig({ cwd }));
@@ -587,8 +773,8 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     expect(data.projects[cwd].hasTrustDialogAccepted).toBe(true);
   });
 
-  test("idempotent: re-creating session with shannon does not rewrite the file", async () => {
-    process.env.CLAUDE_BINARY = "shannon";
+  test("idempotent: re-creating legacy bridge session does not rewrite the file", async () => {
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
     const cwd = "/some/abs/cwd";
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig({ cwd }));
@@ -607,7 +793,7 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
         },
       }),
     );
-    process.env.CLAUDE_BINARY = "shannon";
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig({ cwd: "/new/cwd" }));
 
@@ -625,4 +811,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 writes hasTrustDialogAccepted for config.cwd", async () => {
+    process.env.SWARM_USE_CLAUDE_BRIDGE = "true";
+    const cwd = "/some/bridge/cwd";
+    const adapter = new ClaudeAdapter();
+    await adapter.createSession(makeConfig({ cwd }));
+
+    const data = JSON.parse(await readFile(join(homeDir, ".claude.json"), "utf-8"));
+    expect(data.projects[cwd].hasTrustDialogAccepted).toBe(true);
+    expect(data.projects[cwd].hasCompletedProjectOnboarding).toBe(true);
+  });
 });