@@ -28,7 +28,6 @@ import {
   resetDetachedToastScope,
   setDetachedToastScope,
 } from "@/features/messages/lib/detachedToastScope";
-import { resetDetachedAgentStarts } from "@/features/messages/ui/useDetachedAgentStart";
 import {
   resetActiveAgentTurnsStore,
   saveActiveAgentTurnsForCommunity,
@@ -83,7 +82,13 @@ async function resetCommunityState({
   resetBackgroundMediaUploads();
   resetLinkPreviewPreparations();
   resetPersistentAgentAudienceStore();
-  resetDetachedAgentStarts();
+  // Intentionally NOT reset: the in-flight detached agent-start map
+  // (`useDetachedAgentStart`). Its entries are keyed by tenant scope (relay
+  // URL + pubkey), so they cannot leak into the new community, and they
+  // self-clean when the start settles. Clearing them here is what permitted
+  // the A→B→A duplicate provider deploy: the backend's scope assertion is a
+  // current-state check, so a start held across a round-trip is valid again
+  // once A is re-applied — the map entry is its only duplicate guard.
   resetDetachedToastScope();
   clearSearchHitEventCache();
   clearMarkdownNodeCache();
 
@@ -23,6 +23,12 @@
  *    agent over community B's UI. Delivery compares the captured scope against
  *    the on-screen mirror (`detachedToastScope`) at toast time — not a reset
  *    generation, so an A→B→A round-trip warns again once A is back on screen.
+ * 5. The in-flight map outlives a community switch on purpose: the backend's
+ *    scope assertion is a current-state check, so an A→B→A round-trip
+ *    re-validates a still-held start — the map entry is its only duplicate
+ *    guard, and it is tenant-keyed, so retention cannot affect the community
+ *    being entered. (`resetCommunityState` no longer clears it; that seam is
+ *    pinned E2E.)
  *
  * These tests drive the real hook against the real CommunitiesProvider; the
  * scope mirror is driven directly through its module seam, standing in for
@@ -370,6 +376,76 @@ test("a wake fires again once the previous one has settled", async () => {
   rendered.unmount();
 });
 
+test("an A→B→A community round-trip does not reopen the in-flight window", async () => {
+  // The production seam — `resetCommunityState` deliberately not clearing the
+  // map on switch — is pinned E2E, where the real switch path runs. This pins
+  // the hook contract that makes retention sufficient: the round-trip hands
+  // back a callback carrying A's scope again, its key matches the retained
+  // entry, and the wake stays suppressed while the first start (whose scope
+  // is valid again now that A is re-applied) is still deploying.
+  holdStarts = true;
+  const { act, rendered } = await renderDetachedStart();
+
+  await act(async () => {
+    rendered.result.current.startDetached(AGENT_RECORD);
+    await settle();
+  });
+  await act(async () => {
+    rendered.result.current.switchCommunity("community-b");
+  });
+  await act(async () => {
+    rendered.result.current.switchCommunity("community-a");
+  });
+
+  let refire;
+  await act(async () => {
+    refire = rendered.result.current.startDetached(AGENT_RECORD);
+    await settle();
+  });
+
+  assert.equal(refire, false, "the retained entry must still suppress");
+  assert.equal(
+    startCalls.length,
+    1,
+    "a round-trip must not duplicate a deploy the first start is still performing",
+  );
+  rendered.unmount();
+});
+
+test("a wake re-fires once the start held across a round-trip has rejected", async () => {
+  // Retention ends at settlement, not at some later reset: the `finally`
+  // self-cleans, so a failed start never latches the agent — the user's next
+  // send after the failure toast gets a real wake.
+  holdStarts = true;
+  const { act, rendered } = await renderDetachedStart();
+
+  await act(async () => {
+    rendered.result.current.startDetached(AGENT_RECORD);
+    await settle();
+  });
+  await act(async () => {
+    rendered.result.current.switchCommunity("community-b");
+  });
+  await act(async () => {
+    rendered.result.current.switchCommunity("community-a");
+  });
+  await act(async () => {
+    heldStarts[0].reject();
+    await settle();
+  });
+  await act(async () => {
+    assert.equal(rendered.result.current.startDetached(AGENT_RECORD), true);
+    await settle();
+  });
+
+  assert.equal(
+    startCalls.length,
+    2,
+    "settlement must end the suppression even across a round-trip",
+  );
+  rendered.unmount();
+});
+
 test("a failed wake clears the key instead of latching the agent", async () => {
   holdStarts = true;
   const { act, rendered } = await renderDetachedStart();
 
@@ -23,13 +23,23 @@ import { getErrorMessage } from "./useMentionSendFlow.helpers";
  * Keyed by relay as well as pubkey to mirror the backend's own runtime pair
  * key, so a start in one community can never suppress one in another — the
  * same tenant boundary `expectedRelayUrl` enforces below.
+ *
+ * Entries deliberately survive community switches (`resetCommunityState` does
+ * NOT clear this map). A held start is not invalidated by leaving its
+ * community: the backend's scope assertion is a current-state check, so a
+ * start fired in A is valid again the moment A is re-applied — an A→B→A
+ * round-trip that cleared the map would let a second send duplicate a
+ * provider deploy the first start is still performing (and hand the harness
+ * the second message's replay floor, past the first message). The key is the
+ * tenant scope, so a retained entry cannot affect another community, and the
+ * `finally` below self-cleans on settlement, which the deploy op bounds.
  */
 const inFlightDetachedStarts = new Map<string, Promise<unknown>>();
 
 /**
- * Drops every tracked in-flight start. Registered in `resetCommunityState`:
- * these starts belong to the community being left and are about to fail closed
- * at the backend's scope assertion anyway.
+ * Drops every tracked in-flight start. Test-only isolation seam — one test's
+ * held start must not suppress the next test's. Production deliberately never
+ * calls this: see the map's doc for why entries survive community switches.
  */
 export function resetDetachedAgentStarts(): void {
   inFlightDetachedStarts.clear();
@@ -181,11 +191,12 @@ export function useDetachedAgentStart(): (
           warnAgentMayNotRespond(agent.name, detachedStartFailureDetail(error));
         })
         .finally(() => {
-          // Identity-guarded: `resetDetachedAgentStarts` may have cleared the
-          // map and a later start re-registered this key while this one was in
-          // flight (an A→B→A community switch), and an unguarded delete would
-          // drop that newer entry. Clearing in `finally` rather than on success
-          // is what keeps a failed start from latching the agent permanently.
+          // Identity-guarded: only test isolation clears this map now
+          // (production retains entries across community switches), but if a
+          // reset-and-re-register did interleave while this start was in
+          // flight, an unguarded delete would drop the newer entry. Clearing
+          // in `finally` rather than on success is what keeps a failed start
+          // from latching the agent permanently.
           if (inFlightDetachedStarts.get(key) === started) {
             inFlightDetachedStarts.delete(key);
           }
 
@@ -360,7 +360,8 @@ type E2eConfig = {
     openDmDelayMs?: number;
     sendMessageDelayMs?: number;
     /** Delay (ms) for `start_managed_agent` so e2e tests can switch the
-     *  community mid-startup and observe the fail-closed scope check. */
+     *  community mid-startup and observe the fail-closed scope check.
+     *  Releasable early via `__BUZZ_E2E_RELEASE_MANAGED_AGENT_STARTS__()`. */
     startManagedAgentDelayMs?: number;
     /** Hold the media proxy at port 0 until the E2E release seam is invoked. */
     mediaProxyInitiallyUnavailable?: boolean;
@@ -1467,6 +1468,11 @@ declare global {
     /** Count of `get_event` invocations for the current defer-target ID since
      *  the last time `__BUZZ_E2E_DEFER_GET_EVENT__` was set. */
     __BUZZ_E2E_GET_EVENT_CALL_COUNT__?: number;
+    /** Release every `start_managed_agent` currently held behind
+     *  `startManagedAgentDelayMs`, letting it settle (scope checks, then any
+     *  armed `startManagedAgentErrors` rejection) without waiting out the
+     *  delay. Returns the number of holds flushed. */
+    __BUZZ_E2E_RELEASE_MANAGED_AGENT_STARTS__?: () => number;
     /** Hold the next channel read until released. */
     __BUZZ_E2E_DEFER_NEXT_CHANNELS_READ__?: () => void;
     /** Disarm the latch and release the held channel read, if any. */
@@ -1593,6 +1599,11 @@ let deferredGetEventQueue: DeferredGetEvent[] = [];
 let deferredLinkPreviewMetadataQueue: Array<() => void> = [];
 let deferredLinkPreviewUploadQueue: Array<() => void> = [];
 let deferredThreadRepliesQueue: Array<() => void> = [];
+// Starts currently held behind `startManagedAgentDelayMs`, releasable early
+// via `__BUZZ_E2E_RELEASE_MANAGED_AGENT_STARTS__()`: a spec that holds a
+// start across a community round-trip needs the hold long enough to be
+// deterministic AND a way to settle it on demand afterwards.
+let heldManagedAgentStartReleases: Array<() => void> = [];
 let cancelledMediaUploadIds = new Set<string>();
 let deferNextChannelsRead = false;
 let deferredChannelsReadResolve: (() => void) | null = null;
@@ -9486,7 +9497,20 @@ async function handleStartManagedAgent(
 ): Promise<RawManagedAgent> {
   const delayMs = config?.mock?.startManagedAgentDelayMs ?? 0;
   if (delayMs > 0) {
-    await new Promise((resolve) => window.setTimeout(resolve, delayMs));
+    await new Promise<void>((resolve) => {
+      let settled = false;
+      const release = () => {
+        if (settled) return;
+        settled = true;
+        window.clearTimeout(timer);
+        heldManagedAgentStartReleases = heldManagedAgentStartReleases.filter(
+          (held) => held !== release,
+        );
+        resolve();
+      };
+      const timer = window.setTimeout(release, delayMs);
+      heldManagedAgentStartReleases.push(release);
+    });
   }
   // After the injected delay, like the real command's checks before any
   // spawn/deploy side effect: a caller-captured tenant scope and signer
@@ -11311,6 +11335,12 @@ export function maybeInstallE2eTauriMocks() {
   window.__BUZZ_E2E_GET_EVENT_CALL_COUNT__ = 0;
   window.__BUZZ_E2E_DEFER_GET_EVENT__ = null;
   deferredGetEventQueue = [];
+  heldManagedAgentStartReleases = [];
+  window.__BUZZ_E2E_RELEASE_MANAGED_AGENT_STARTS__ = () => {
+    const held = heldManagedAgentStartReleases.splice(0);
+    for (const release of held) release();
+    return held.length;
+  };
   deferNextChannelsRead = false;
   deferredChannelsReadResolve = null;
   window.__BUZZ_E2E_CHANNELS_READ_PENDING__ = 0;
 
@@ -2981,6 +2981,164 @@ test("a detached start fired before a real community switch fails closed and kee
   ).toBe(0);
 });
 
+test("a deploy held across an A→B→A community round-trip is not fired twice", async ({
+  page,
+}) => {
+  // The in-flight detached-start map used to be cleared by every community
+  // switch, and the backend's scope assertion is a current-state check — so a
+  // deploy still held from community A became valid again the moment A was
+  // re-applied, and a second mention back in A deployed the agent a second
+  // time (carrying the second message's replay floor, past the first
+  // message). The entries are tenant-keyed and self-cleaning, so they now
+  // survive the switch. This drives the real rail-switch path (provider →
+  // remount → resetCommunityState) that did the clearing; the map contract
+  // itself is pinned at the unit level.
+  const COMMUNITY_A = {
+    id: "ws-a",
+    name: "Alpha",
+    relayUrl: "ws://localhost:3000",
+    addedAt: "2026-01-01T00:00:00.000Z",
+  };
+  const COMMUNITY_B = {
+    id: "ws-b",
+    name: "Bravo",
+    relayUrl: "ws://localhost:3001",
+    addedAt: "2026-01-02T00:00:00.000Z",
+  };
+  await installMockBridge(
+    page,
+    {
+      managedAgents: [
+        {
+          pubkey: OUT_OF_CHANNEL_PROVIDER_AGENT_PUBKEY,
+          name: "portal",
+          status: "not_deployed",
+          channelNames: ["general"],
+          backend: {
+            type: "provider",
+            id: "portal",
+            config: { region: "test" },
+          },
+        },
+      ],
+      // Far longer than the round-trip below ever takes, so the first deploy
+      // is deterministically still in flight when the second send fires;
+      // settled on demand via the release seam for the retry leg.
+      startManagedAgentDelayMs: 45_000,
+      // Arms the first settlement to reject. A successful mock settle writes
+      // `deployed` into the record, and the third send below would then skip
+      // the wake on status alone — the retry leg has to prove the *map entry*
+      // self-cleaned, so the record must still read `not_deployed`.
+      startManagedAgentErrors: ["Mock provider deploy failed."],
+    },
+    { skipCommunitySeed: true },
+  );
+  await page.addInitScript(
+    ({ list, active }) => {
+      window.localStorage.setItem("buzz-communities", JSON.stringify(list));
+      window.localStorage.setItem("buzz-active-community-id", active);
+    },
+    { list: [COMMUNITY_A, COMMUNITY_B], active: COMMUNITY_A.id },
+  );
+  await page.goto("/");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+
+  const sendMention = async (text: string) => {
+    const input = page.getByTestId("message-input");
+    await input.fill("Hey @portal");
+    await expect(autocomplete(page).getByText("portal")).toBeVisible();
+    await input.press("Enter");
+    await page.keyboard.type(` ${text}`);
+    // Enter rather than the send button: the third send happens while the
+    // first deploy's failure toast is on screen, and the toast overlay
+    // intercepts pointer events aimed at the composer's corner.
+    await input.press("Enter");
+    await expect(
+      page.getByTestId("message-row").filter({ hasText: text }),
+    ).toBeVisible();
+  };
+
+  const baselineCommands = await readCommandLog(page);
+  const baselineStartCount = commandCount(
+    baselineCommands,
+    "start_managed_agent",
+  );
+  const baselineSettledCount = commandCount(
+    baselineCommands,
+    "start_managed_agent:settled",
+  );
+  const baselinePayloadCount = (await readCommandPayloadLog(page)).length;
+
+  await sendMention("do X");
+  await expect
+    .poll(async () =>
+      commandCount(await readCommandLog(page), "start_managed_agent"),
+    )
+    .toBe(baselineStartCount + 1);
+  const startCall = (await readCommandPayloadLog(page))
+    .slice(baselinePayloadCount)
+    .find((entry) => entry.command === "start_managed_agent");
+  expect(startCall?.payload).toMatchObject({
+    expectedRelayUrl: COMMUNITY_A.relayUrl,
+    expectedSignerPubkey: MOCK_VIEWER_PUBKEY,
+  });
+
+  // The round trip, while the deploy is still held.
+  await page.getByTestId(`community-rail-button-${COMMUNITY_B.id}`).click();
+  await expect(
+    page.getByTestId(`community-rail-button-${COMMUNITY_B.id}`),
+  ).toHaveAttribute("aria-current", "true");
+  await page.getByTestId(`community-rail-button-${COMMUNITY_A.id}`).click();
+  await expect(
+    page.getByTestId(`community-rail-button-${COMMUNITY_A.id}`),
+  ).toHaveAttribute("aria-current", "true");
+  await page.getByTestId("channel-general").click();
+  await expect(page.getByTestId("chat-title")).toHaveText("general");
+
+  // Back in A, the held deploy's scope is valid again and the record still
+  // reads `not_deployed`, so this send queues a wake — the retained map entry
+  // is the only thing standing between it and a duplicate deploy. A
+  // suppressed wake makes no call, so give the post-publish flush a moment
+  // before snapshotting: pre-fix the duplicate invoke landed well inside it.
+  await sendMention("also Y");
+  await page.waitForTimeout(500);
+  expect(commandCount(await readCommandLog(page), "start_managed_agent")).toBe(
+    baselineStartCount + 1,
+  );
+
+  // Settle the held deploy on demand (the armed rejection). Retention must
+  // end at settlement rather than latching the agent for the session.
+  const released = await page.evaluate(
+    () =>
+      (
+        window as {
+          __BUZZ_E2E_RELEASE_MANAGED_AGENT_STARTS__?: () => number;
+        }
+      ).__BUZZ_E2E_RELEASE_MANAGED_AGENT_STARTS__?.() ?? 0,
+  );
+  expect(released).toBe(1);
+  await expect
+    .poll(async () =>
+      commandCount(await readCommandLog(page), "start_managed_agent:settled"),
+    )
+    .toBe(baselineSettledCount + 1);
+  // The failure settled with A on screen, so its warning delivers here — the
+  // round-trip kept it out of B without dropping it.
+  await expect(
+    page.getByText("Could not start portal", { exact: false }),
+  ).toBeVisible();
+
+  // The map entry self-cleaned at settlement, so a third mention of the
+  // still-undeployed agent re-fires the wake.
+  await sendMention("try again");
+  await expect
+    .poll(async () =>
+      commandCount(await readCommandLog(page), "start_managed_agent"),
+    )
+    .toBe(baselineStartCount + 2);
+});
+
 test("mentioning an in-channel provider managed agent publishes first and deploys it detached", async ({
   page,
 }) => {