@desplega.ai/agent-swarm 1.92.0 → 1.92.2

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

@@ -5,15 +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"`).
+ *      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 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".
+ *   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
@@ -36,6 +38,10 @@ import {
 } 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 {
@@ -83,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", () => {
@@ -121,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", () => {
@@ -134,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", () => {
@@ -291,6 +315,7 @@ describe("CLAUDE_BINARY env override", () => {
   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;
@@ -305,8 +330,10 @@ describe("CLAUDE_BINARY env override", () => {
     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);
 
@@ -352,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;
@@ -421,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(
@@ -471,7 +498,7 @@ 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 () => {
@@ -486,9 +513,36 @@ describe("CLAUDE_BINARY env override", () => {
     expect(argv).toContain("-p");
   });
 
-  test("SWARM_USE_CLAUDE_BRIDGE=1 wins over CLAUDE_BINARY=shannon", async () => {
+  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 = "shannon";
+    process.env.CLAUDE_BINARY = LEGACY_BRIDGE_COMPAT_BINARY;
 
     const adapter = new ClaudeAdapter();
     await adapter.createSession(makeConfig());
@@ -529,7 +583,7 @@ describe("CLAUDE_BINARY env override", () => {
   });
 });
 
-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;
@@ -578,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}`;
@@ -589,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;
@@ -600,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;
@@ -612,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;
@@ -623,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;
@@ -698,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 }));
@@ -709,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 }));
@@ -719,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 }));
@@ -739,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" }));
 
@@ -758,14 +812,14 @@ describe("Trust pre-seed via ClaudeAdapter.createSession", () => {
     expect(exists).toBe(false);
   });
 
-  test("SWARM_USE_CLAUDE_BRIDGE=true does NOT use the legacy shannon trust pre-seed", async () => {
+  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: "/some/abs/cwd" }));
+    await adapter.createSession(makeConfig({ 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);
+    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);
   });
 });

package/src/tests/create-page-tool.test.ts

@@ -63,14 +63,13 @@ describe("create_page MCP tool", () => {
     }
   });
 
-  test("first call creates a row + returns shareable URLs", async () => {
+  test("first call creates an authed row by default + returns shareable URLs", async () => {
     const tool = buildServer();
     const result = (await tool.handler(
       {
         title: "Hello Page",
         body: "<h1>hello</h1>",
         contentType: "text/html",
-        authMode: "public",
       },
       fakeMeta,
     )) as {
@@ -97,6 +96,24 @@ describe("create_page MCP tool", () => {
     const row = getPageBySlug(agentId, "hello-page");
     expect(row).not.toBeNull();
     expect(row!.body).toBe("<h1>hello</h1>");
+    expect(row!.authMode).toBe("authed");
+  });
+
+  test("explicit public auth mode is preserved", async () => {
+    const tool = buildServer();
+    await tool.handler(
+      {
+        title: "Public Page",
+        body: "<h1>public</h1>",
+        contentType: "text/html",
+        authMode: "public",
+      },
+      fakeMeta,
+    );
+
+    const row = getPageBySlug(agentId, "public-page");
+    expect(row).not.toBeNull();
+    expect(row!.authMode).toBe("public");
   });
 
   test("re-running with the same slug upserts + bumps edit-counter", async () => {

package/src/tests/heartbeat-checklist.test.ts

@@ -271,6 +271,26 @@ describe("Heartbeat Checklist", () => {
       expect(tasks[0]!.task).toContain("Review blocked tasks");
     });
 
+    test("created task enforces HEARTBEAT tracked-item cap and seeded audit call", async () => {
+      const lead = createAgent({ name: "lead", isLead: true, status: "idle" });
+      updateAgentProfile(lead.id, {
+        heartbeatMd: "- Watch PR #123 until 2026-06-07\n",
+      });
+
+      await checkHeartbeatChecklist();
+
+      const tasks = getDb()
+        .query("SELECT task FROM agent_tasks WHERE taskType = 'heartbeat-checklist'")
+        .all() as Array<{ task: string }>;
+      expect(tasks.length).toBe(1);
+      expect(tasks[0]!.task).toContain("Active Blockers + Watch Items + Open Discussion");
+      expect(tasks[0]!.task).toContain("≤10 items");
+      expect(tasks[0]!.task).toContain("20 is the absolute max");
+      expect(tasks[0]!.task).toContain("script-run");
+      expect(tasks[0]!.task).toContain("Heartbeat Audit");
+      expect(tasks[0]!.task).toContain("Rule #11");
+    });
+
     test("created task has correct tags", async () => {
       const lead = createAgent({ name: "lead", isLead: true, status: "idle" });
       updateAgentProfile(lead.id, {
@@ -369,6 +389,22 @@ describe("Heartbeat Checklist", () => {
       expect(tasks[0]!.task).toContain("Check Slack for unaddressed requests");
     });
 
+    test("boot-triage task enforces HEARTBEAT cap and seeded boot-triage call", async () => {
+      createAgent({ name: "lead", isLead: true, status: "idle" });
+
+      await createBootTriageTask();
+
+      const tasks = getDb()
+        .query("SELECT task FROM agent_tasks WHERE taskType = 'boot-triage'")
+        .all() as Array<{ task: string }>;
+      expect(tasks[0]!.task).toContain("Active Blockers + Watch Items + Open Discussion");
+      expect(tasks[0]!.task).toContain("≤10 items");
+      expect(tasks[0]!.task).toContain("20 is the absolute max");
+      expect(tasks[0]!.task).toContain("script-run");
+      expect(tasks[0]!.task).toContain("boot-triage");
+      expect(tasks[0]!.task).toContain("one read-only call");
+    });
+
     test("dedup: skips when active boot-triage task exists", async () => {
       const lead = createAgent({ name: "lead", isLead: true, status: "idle" });
       updateAgentProfile(lead.id, {

package/src/tests/mcp-transport-gc.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { closeIdleMcpTransports } from "../http/mcp";
+import { closeIdleMcpUserTransports } from "../http/mcp-user";
+
+function fakeTransport(onClose: () => void): StreamableHTTPServerTransport {
+  return {
+    close: onClose,
+  } as StreamableHTTPServerTransport;
+}
+
+describe("MCP transport idle GC", () => {
+  test("closes and deletes stale owner transports", () => {
+    const closed: string[] = [];
+    const transports: Record<string, StreamableHTTPServerTransport> = {
+      fresh: fakeTransport(() => closed.push("fresh")),
+      stale: fakeTransport(() => closed.push("stale")),
+      unknown: fakeTransport(() => closed.push("unknown")),
+    };
+    const activity = {
+      fresh: 9_500,
+      stale: 1_000,
+    };
+
+    const removed = closeIdleMcpTransports(transports, activity, {
+      now: 10_000,
+      idleTimeoutMs: 1_000,
+    });
+
+    expect(removed).toBe(1);
+    expect(closed).toEqual(["stale"]);
+    expect(transports.stale).toBeUndefined();
+    expect(activity.stale).toBeUndefined();
+    expect(transports.fresh).toBeDefined();
+    expect(transports.unknown).toBeDefined();
+    expect(activity.unknown).toBe(10_000);
+  });
+
+  test("deletes user ownership metadata for stale user transports", () => {
+    const closed: string[] = [];
+    const transports: Record<string, StreamableHTTPServerTransport> = {
+      stale: fakeTransport(() => closed.push("stale")),
+    };
+    const sessionUsers = { stale: "user_1" };
+    const activity = { stale: 1_000 };
+
+    const removed = closeIdleMcpUserTransports(transports, sessionUsers, activity, {
+      now: 10_000,
+      idleTimeoutMs: 1_000,
+    });
+
+    expect(removed).toBe(1);
+    expect(closed).toEqual(["stale"]);
+    expect(transports.stale).toBeUndefined();
+    expect(sessionUsers.stale).toBeUndefined();
+    expect(activity.stale).toBeUndefined();
+  });
+});