fix: bash wait-detach fans out on root-key miss instead of silently dropping

The user-message detach signal resolved the session directory and required
an exact live-transport key match; any canonicalization or cwd-fallback
mismatch made it return without a trace, so a wait:true bash kept blocking
through user messages. The command carries its own session_id and the Rust
side scopes by session, so a root-key miss now fans the signal out to every
live bridge, and both the fallback and the no-bridge case log.

Co-authored-by: Alfonso <289616620+alfonso-aft@users.noreply.github.com>

Author: ualtinok

packages/aft-bridge/src/pool.ts

@@ -195,6 +195,17 @@ export class BridgePool implements AftTransportPool {
     return entry.bridge;
   }
 
+  /** All live bridges, for session-scoped signals that must not depend on
+   * exact root-key resolution (the command itself carries the session ID). */
+  activeBridges(): BinaryBridge[] {
+    if (this.shutdownCalled) return [];
+    const alive: BinaryBridge[] = [];
+    for (const entry of this.bridges.values()) {
+      if (entry.bridge.isAlive()) alive.push(entry.bridge);
+    }
+    return alive;
+  }
+
   /**
    * Get or create the bridge for `projectRoot`.
    *

packages/aft-bridge/src/revivable-transport.ts

@@ -45,6 +45,12 @@ export class RevivableTransportPool implements AftTransportPool {
     return transport;
   }
 
+  /** Delegate to the active pool: session-scoped signal fan-out reaches the
+   * same live transports the underlying pool would report. */
+  activeBridges(): AftProjectTransport[] {
+    return this.activePool.activeBridges();
+  }
+
   getActiveBridgeForRoot(projectRoot: string): RevivableProjectTransport | null {
     const key = canonicalizeProjectRoot(projectRoot);
     const bridge = this.currentBridge(key);

packages/aft-bridge/src/subc-transport.ts

@@ -535,6 +535,14 @@ export class SubcTransportPool implements AftTransportPool {
     return this.transports.get(key) ?? null;
   }
 
+  /** All live per-root facades, for session-scoped signals that must not
+   * depend on exact root-key resolution (the command carries the session ID
+   * and the module scopes by session, so fan-out is safe). */
+  activeBridges(): SubcTransport[] {
+    if (!this.client || this.shuttingDown) return [];
+    return [...this.transports.values()];
+  }
+
   async toolCall(
     projectRoot: string,
     runtime: { sessionID?: string },

packages/aft-bridge/src/transport.ts

@@ -52,6 +52,13 @@ export interface AftProjectTransport {
 export interface AftTransportPool {
   getBridge(projectRoot: string): AftProjectTransport;
   getActiveBridgeForRoot(projectRoot: string): AftProjectTransport | null;
+  /**
+   * All currently-live project transports, for session-scoped signals (e.g.
+   * bash wait-detach) that must reach their target even when the caller's
+   * root-key resolution disagrees with the key the tool call used. Callers
+   * must only send session-scoped, read-only commands through these.
+   */
+  activeBridges(): AftProjectTransport[];
   toolCall(
     projectRoot: string,
     runtime: BridgeToolCallRuntime,

packages/opencode-plugin/src/__tests__/bash-wait-detach.test.ts

@@ -37,10 +37,11 @@ describe("bash wait detach helper", () => {
     });
   });
 
-  test("user-message detach is skipped without a session or active bridge", async () => {
+  test("user-message detach is skipped without a session or any live bridge", async () => {
     const send = mock(async () => ({ success: true }));
     const pool = {
       getActiveBridgeForRoot: () => null,
+      activeBridges: () => [],
     };
 
     await signalBashWaitDetachForProject(
@@ -56,4 +57,32 @@ describe("bash wait detach helper", () => {
 
     expect(send).not.toHaveBeenCalled();
   });
+
+  test("root-key miss fans out to every live bridge instead of dropping", async () => {
+    const sends: string[] = [];
+    const bridgeFor = (label: string) => ({
+      send: mock(async (command: string, params: Record<string, unknown>) => {
+        sends.push(`${label}:${command}:${String(params.session_id)}`);
+        return { success: true };
+      }),
+    });
+    const bridgeA = bridgeFor("a");
+    const bridgeB = bridgeFor("b");
+    const pool = {
+      // Exact root resolution misses (the silent-drop bug this guards):
+      getActiveBridgeForRoot: () => null,
+      activeBridges: () => [bridgeA, bridgeB],
+    };
+
+    await signalBashWaitDetachForProject(
+      pool as unknown as Parameters<typeof signalBashWaitDetachForProject>[0],
+      "/repo-that-does-not-match",
+      "session-3",
+    );
+
+    expect(sends.sort()).toEqual([
+      "a:bash_wait_detach:session-3",
+      "b:bash_wait_detach:session-3",
+    ]);
+  });
 });

packages/opencode-plugin/src/bash-wait-detach.ts

@@ -1,8 +1,8 @@
 import type { AftProjectTransport, AftTransportPool } from "@cortexkit/aft-bridge";
-import { warn } from "./logger.js";
+import { log, warn } from "./logger.js";
 import { BASH_TRANSPORT_TIMEOUT_MS } from "./tools/_shared.js";
 
-type ActiveBridgePool = Pick<AftTransportPool, "getActiveBridgeForRoot">;
+type ActiveBridgePool = Pick<AftTransportPool, "getActiveBridgeForRoot" | "activeBridges">;
 
 async function sendBashWaitDetach(bridge: AftProjectTransport, sessionID: string): Promise<void> {
   const response = await bridge.send(
@@ -21,13 +21,28 @@ export async function signalBashWaitDetachForProject(
   sessionID: string | undefined,
 ): Promise<void> {
   if (!sessionID) return;
-  const bridge = pool.getActiveBridgeForRoot(projectRoot);
-  if (!bridge) return;
-  try {
-    await sendBashWaitDetach(bridge, sessionID);
-  } catch (err) {
+  // Root-key resolution can disagree with the key the bash tool call used
+  // (canonicalization, worktrees, cwd fallbacks). The command is scoped by
+  // session_id on the Rust side, so when the exact root has no live bridge,
+  // fan out to every live bridge instead of silently dropping the signal.
+  const exact = pool.getActiveBridgeForRoot(projectRoot);
+  const targets = exact ? [exact] : pool.activeBridges();
+  if (targets.length === 0) {
+    warn(`[bash_wait_detach] no live bridge for session ${sessionID} (root ${projectRoot})`);
+    return;
+  }
+  const results = await Promise.allSettled(
+    targets.map((bridge: AftProjectTransport) => sendBashWaitDetach(bridge, sessionID)),
+  );
+  const failed = results.filter((result: PromiseSettledResult<void>) => result.status === "rejected");
+  if (failed.length === results.length) {
+    const err = (failed[0] as PromiseRejectedResult).reason;
     warn(
       `[bash_wait_detach] failed for session ${sessionID}: ${err instanceof Error ? err.message : String(err)}`,
     );
+  } else {
+    log(
+      `[bash_wait_detach] signaled for session ${sessionID} via ${results.length - failed.length} bridge(s)${exact ? "" : " (root-key fallback)"}`,
+    );
   }
 }