From 1597d7cc3ba202af5ae91fa0feca895560f1c49e Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 11:50:02 +1100
Subject: [PATCH 01/13] feat(agents): let hosted agents join teams, warning
 about instructions

Hosted agents can be picked as team members. While one is on the team,
the Instructions field warns that remote agents may not get them. Local
members' rosters now name the community's listed teammates too, so they
can reach hosted ones.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 src/bundled/agents/AgentsPage.test.tsx | 27 +++++++++++++++++++++++
 src/bundled/agents/AgentsPage.tsx      | 19 ++++++++++++++--
 src/features/agents/service.test.ts    | 30 ++++++++++++++++++++++++++
 src/features/agents/service.ts         | 26 +++++++++++-----------
 4 files changed, 88 insertions(+), 14 deletions(-)

diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index cb29da7b90..80c2117ac9 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -2460,6 +2460,33 @@ it("makes a team of chosen agents and lists it with its members", async () => {
   expect(screen.queryByRole("list", { name: "Teams" })).not.toBeInTheDocument();
 });
 
+it("offers hosted agents as members, warning that they may not get the instructions", async () => {
+  const user = userEvent.setup();
+  setup([
+    agent("Ada", 1),
+    { ...agent("Sky", 2), place: "hosted" },
+    { ...agent("Bo", 3), place: "hosted", unfinished: true },
+    { ...agent("Cy", 4), place: "elsewhere" },
+  ]);
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  await user.click(screen.getByRole("button", { name: "New team" }));
+  await user.click(
+    await screen.findByRole("menuitem", { name: "Create a new team" }),
+  );
+  const members = ["Ada", "Sky", "Bo", "Cy"].map((name) =>
+    screen.queryByRole("checkbox", { name }),
+  );
+  expect(members.map(Boolean)).toEqual([true, true, false, false]);
+  const instructions = screen.getByRole("textbox", { name: "Instructions" });
+  const warning = /Remote agents on this team/;
+  await user.click(screen.getByRole("checkbox", { name: "Ada" }));
+  expect(instructions).not.toHaveAccessibleDescription(warning);
+  await user.click(screen.getByRole("checkbox", { name: "Sky" }));
+  expect(instructions).toHaveAccessibleDescription(warning);
+  await user.click(screen.getByRole("checkbox", { name: "Sky" }));
+  expect(instructions).not.toHaveAccessibleDescription(warning);
+});
+
 it("closes the team editor when leaving Your teams", async () => {
   const user = userEvent.setup();
   const { agents } = setup([agent("Ada", 1)]);
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index 1575648112..9b0077ad2c 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -545,7 +545,9 @@ export function AgentsPage({
           ) : (
             <Teams
               agents={agents}
-              saved={snapshot.agents.filter((agent) => agent.place === "here")}
+              saved={snapshot.agents.filter(
+                (agent) => agent.place !== "elsewhere" && !agent.unfinished,
+              )}
               teams={teams}
               editing={editing}
               onEdit={setEditingTeam}
@@ -2142,6 +2144,10 @@ function TeamEditor({
       !saved.some((agent) => agent.pubkey === pubkey) &&
       agents.memberships(pubkey).length > 0,
   ).length;
+  // Their provider runs them, so they may not get the team's instructions.
+  const remote = saved.some(
+    (agent) => agent.place === "hosted" && members.includes(agent.pubkey),
+  );
   const act = async (work: () => Promise<unknown>) => {
     if (pending) return;
     setPending(true);
@@ -2193,7 +2199,16 @@ function TeamEditor({
       </Field>
       <Field
         label="Instructions"
-        description="Every member follows these after its own instructions."
+        description={
+          <>
+            Every member follows these after its own instructions.
+            {remote && (
+              <span className="mt-1 block text-warning">
+                Remote agents on this team may not get these instructions.
+              </span>
+            )}
+          </>
+        }
       >
         <Textarea
           rows={5}
diff --git a/src/features/agents/service.test.ts b/src/features/agents/service.test.ts
index 70f6080a3c..9c6f71f5b2 100644
--- a/src/features/agents/service.test.ts
+++ b/src/features/agents/service.test.ts
@@ -11711,6 +11711,36 @@ describe("synced teams", () => {
     expect(error).not.toContain(away);
   });
 
+  it("puts set-up hosted agents on a team and names them in its roster", async () => {
+    const unfinished = "d".repeat(64);
+    const team = stored(viewer, [bot, hostedKey, unfinished]);
+    const f = await ready([], team.storage);
+    const { type, remote } = cloud();
+    f.plugin.agents.register(type);
+    await f.service.create({ type: "example/echo", name: "Echo" });
+    await f.service.create({ type: "example/cloud", name: "Sky" });
+    remote.provision.mockResolvedValueOnce({ pubkey: unfinished });
+    remote.activate.mockRejectedValueOnce(new Error("provider down"));
+    await expect(
+      f.service.create({ type: "example/cloud", name: "Bo" }),
+    ).rejects.toThrow("provider down");
+    await f.service.saveTeam(crew([bot, hostedKey]));
+    expect(f.saveTeam).toHaveBeenCalledWith(
+      expect.objectContaining({ members: [bot, hostedKey] }),
+    );
+    await expect(f.service.saveTeam(crew([unfinished]))).rejects.toThrow(
+      /^Add .+ to relay\.example\.test first$/,
+    );
+    team.confirm(f.stores.get(home));
+    await vi.waitFor(() =>
+      expect(f.service.snapshot().teams.map((t) => t.name)).toEqual(["Crew"]),
+    );
+    await handleOf(f.run, f.emit);
+    const roster = f.run.mock.calls.at(-1)?.[0].team;
+    expect(roster).toContain(`- Sky (${npubEncode(hostedKey)})\n`);
+    expect(roster).not.toContain(npubEncode(unfinished));
+  });
+
   it("shows only the signed-in account's synced teams", async () => {
     const team = stored(other, []);
     const f = await ready([here(alder)], team.storage);
diff --git a/src/features/agents/service.ts b/src/features/agents/service.ts
index e57712059b..98c5732fbd 100644
--- a/src/features/agents/service.ts
+++ b/src/features/agents/service.ts
@@ -1635,15 +1635,8 @@ export class AgentsService extends Service implements Agents {
         const member = this.liveMember(key);
         const origin = member && originOf(member.relay);
         // Only teammates in the same community, where it can reach them.
-        return member
-          ? teamPrompt(
-              this.allTeams(),
-              this.identities.filter(
-                (identity) =>
-                  !identity.deleted && originOf(identity.relay) === origin,
-              ),
-              member.pubkey,
-            )
+        return member && origin
+          ? teamPrompt(this.allTeams(), this.teamAgents(origin), member.pubkey)
           : "";
       },
       agentTypes: () =>
@@ -3862,10 +3855,9 @@ export class AgentsService extends Service implements Agents {
       this.liveRows(pubkey)[0]?.name || (labels.get(pubkey) ?? pubkey);
     // Members the team already has may run on another device; the roster
     // proves them.
+    const members = new Set(this.teamAgents(home).map((agent) => agent.pubkey));
     const outside = team.members.find(
-      (pubkey) =>
-        !opened.includes(pubkey) &&
-        !this.liveRows(pubkey).some((row) => originOf(row.relay) === home),
+      (pubkey) => !opened.includes(pubkey) && !members.has(pubkey),
     );
     if (outside) throw new Error(`Add ${name(outside)} to ${host} first`);
     const config = this.communityConfigs.get(home);
@@ -4251,6 +4243,16 @@ export class AgentsService extends Service implements Agents {
         (pubkey === undefined || identity.pubkey === pubkey),
     );
   }
+  /** The agents a team in `origin` can have: the ones here, and the listed
+   * ones whose setup finished, such as hosted ones. */
+  private teamAgents(origin: string) {
+    return [
+      ...this.liveRows().filter(
+        (identity) => originOf(identity.relay) === origin,
+      ),
+      ...this.listedAgents(origin).filter((agent) => !agent.unfinished),
+    ];
+  }
   /** The membership of this key, unless it was deleted. */
   private liveMember(key: AgentKey) {
     return this.identities.find(

From 89f26ee9074fc2c4304a70e4ebdac4a42563bee3 Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 12:03:30 +1100
Subject: [PATCH 02/13] feat(agents): name the remote team members in the
 warning, with an icon

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 src/bundled/agents/AgentsPage.test.tsx | 12 ++++++++++--
 src/bundled/agents/AgentsPage.tsx      | 14 ++++++++++----
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index 80c2117ac9..7f9e32238b 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -2465,6 +2465,7 @@ it("offers hosted agents as members, warning that they may not get the instructi
   setup([
     agent("Ada", 1),
     { ...agent("Sky", 2), place: "hosted" },
+    { ...agent("Kai", 5), place: "hosted" },
     { ...agent("Bo", 3), place: "hosted", unfinished: true },
     { ...agent("Cy", 4), place: "elsewhere" },
   ]);
@@ -2478,12 +2479,19 @@ it("offers hosted agents as members, warning that they may not get the instructi
   );
   expect(members.map(Boolean)).toEqual([true, true, false, false]);
   const instructions = screen.getByRole("textbox", { name: "Instructions" });
-  const warning = /Remote agents on this team/;
+  const warning = /remotely/;
   await user.click(screen.getByRole("checkbox", { name: "Ada" }));
   expect(instructions).not.toHaveAccessibleDescription(warning);
   await user.click(screen.getByRole("checkbox", { name: "Sky" }));
-  expect(instructions).toHaveAccessibleDescription(warning);
+  expect(instructions).toHaveAccessibleDescription(
+    /Sky runs remotely and may not get these instructions\.$/,
+  );
+  await user.click(screen.getByRole("checkbox", { name: "Kai" }));
+  expect(instructions).toHaveAccessibleDescription(
+    /Sky and Kai run remotely and may not get these instructions\.$/,
+  );
   await user.click(screen.getByRole("checkbox", { name: "Sky" }));
+  await user.click(screen.getByRole("checkbox", { name: "Kai" }));
   expect(instructions).not.toHaveAccessibleDescription(warning);
 });
 
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index 9b0077ad2c..513178b2b0 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -79,6 +79,7 @@ import {
   PlusIcon,
   RobotIcon,
   StarFilledIcon,
+  WarningCircleIcon,
   XIcon,
 } from "../../shared/design-system/icons";
 import { Button } from "../../shared/design-system/ui/Button";
@@ -116,6 +117,10 @@ import { agentProviderRoute, agentProviderTarget, agentRoute } from "./routes";
 const message = (error: unknown) =>
   error instanceof Error ? error.message : String(error);
 const noSubscribe = () => () => {};
+const names = (agents: readonly Agent[]) =>
+  new Intl.ListFormat(undefined, { type: "conjunction" }).format(
+    agents.map((agent) => agent.name),
+  );
 const importReminderKey = "agent-community-import:dismissed";
 
 /** The type's one-line summary of an agent; its title when it has none. */
@@ -2145,7 +2150,7 @@ function TeamEditor({
       agents.memberships(pubkey).length > 0,
   ).length;
   // Their provider runs them, so they may not get the team's instructions.
-  const remote = saved.some(
+  const remote = saved.filter(
     (agent) => agent.place === "hosted" && members.includes(agent.pubkey),
   );
   const act = async (work: () => Promise<unknown>) => {
@@ -2202,9 +2207,10 @@ function TeamEditor({
         description={
           <>
             Every member follows these after its own instructions.
-            {remote && (
-              <span className="mt-1 block text-warning">
-                Remote agents on this team may not get these instructions.
+            {remote.length > 0 && (
+              <span className="mt-1 flex items-start gap-1 text-warning">
+                <WarningCircleIcon className="mt-0.5 shrink-0" aria-hidden />
+                {`${names(remote)} ${remote.length === 1 ? "runs" : "run"} remotely and may not get these instructions.`}
               </span>
             )}
           </>

From 962fb24835cf504900de79a9afa0b45b2064dce2 Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 12:14:27 +1100
Subject: [PATCH 03/13] feat(agents): say which members follow team
 instructions

With a provider-run member, the description names the agents on the
owner's devices as the ones that follow the instructions, and the
warning names the provider-run ones that won't get them.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 src/bundled/agents/AgentsPage.test.tsx | 10 +++++-----
 src/bundled/agents/AgentsPage.tsx      | 15 ++++++++++-----
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index 7f9e32238b..66186335a0 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -2479,20 +2479,20 @@ it("offers hosted agents as members, warning that they may not get the instructi
   );
   expect(members.map(Boolean)).toEqual([true, true, false, false]);
   const instructions = screen.getByRole("textbox", { name: "Instructions" });
-  const warning = /remotely/;
+  const local = "Every member follows these after its own instructions.";
   await user.click(screen.getByRole("checkbox", { name: "Ada" }));
-  expect(instructions).not.toHaveAccessibleDescription(warning);
+  expect(instructions).toHaveAccessibleDescription(local);
   await user.click(screen.getByRole("checkbox", { name: "Sky" }));
   expect(instructions).toHaveAccessibleDescription(
-    /Sky runs remotely and may not get these instructions\.$/,
+    "Agents on your devices follow these after their own instructions. Agents run by their provider (Sky) will not get these team instructions.",
   );
   await user.click(screen.getByRole("checkbox", { name: "Kai" }));
   expect(instructions).toHaveAccessibleDescription(
-    /Sky and Kai run remotely and may not get these instructions\.$/,
+    /\(Sky and Kai\) will not get these team instructions\.$/,
   );
   await user.click(screen.getByRole("checkbox", { name: "Sky" }));
   await user.click(screen.getByRole("checkbox", { name: "Kai" }));
-  expect(instructions).not.toHaveAccessibleDescription(warning);
+  expect(instructions).toHaveAccessibleDescription(local);
 });
 
 it("closes the team editor when leaving Your teams", async () => {
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index 513178b2b0..830ec6e150 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -2206,12 +2206,17 @@ function TeamEditor({
         label="Instructions"
         description={
           <>
-            Every member follows these after its own instructions.
+            {remote.length > 0
+              ? "Agents on your devices follow these after their own instructions."
+              : "Every member follows these after its own instructions."}
             {remote.length > 0 && (
-              <span className="mt-1 flex items-start gap-1 text-warning">
-                <WarningCircleIcon className="mt-0.5 shrink-0" aria-hidden />
-                {`${names(remote)} ${remote.length === 1 ? "runs" : "run"} remotely and may not get these instructions.`}
-              </span>
+              <>
+                {" "}
+                <span className="mt-1 flex items-start gap-1 text-warning">
+                  <WarningCircleIcon className="mt-0.5 shrink-0" aria-hidden />
+                  {`Agents run by their provider (${names(remote)}) will not get these team instructions.`}
+                </span>
+              </>
             )}
           </>
         }

From 053953bad708ac17c20b86b103afe763505433e3 Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 16:53:55 +1100
Subject: [PATCH 04/13] fix(agents): keep a hosted-only synced team in its home
 community

A synced team's roster is its home config channel's members, so every
member is in its home. The Teams list now shows such a team in another
community only while it has no members, rather than whenever none of
its members runs on this device. A team of hosted agents, or of agents
on another device, no longer shows up empty in other communities.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 src/bundled/agents/AgentsPage.test.tsx | 47 +++++++++++++++++++++++++-
 src/bundled/agents/AgentsPage.tsx      |  7 ++--
 2 files changed, 51 insertions(+), 3 deletions(-)

diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index 66186335a0..40f89058e1 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -165,6 +165,7 @@ function setup(
       navigator?: Navigation;
       communities?: CommunityReader;
     },
+    teams = [] as AgentsSnapshot["teams"],
   } = {},
 ) {
   let snapshot: AgentsSnapshot = {
@@ -173,7 +174,7 @@ function setup(
     agents: saved,
     running: saved,
     interrupted: [],
-    teams: [],
+    teams,
   };
   const listeners = new Set<() => void>();
   const echoProvider = provider("ready", ({ onClose }) => (
@@ -2560,6 +2561,50 @@ it("explains an unavailable harness without claiming the key is on another devic
   ).not.toBeInTheDocument();
 });
 
+it("shows a synced team only where its members are, after switching communities", async () => {
+  const user = userEvent.setup();
+  const sky: Agent = { ...agent("Sky", 2), place: "hosted" };
+  const { show } = setup([agent("Ada", 1), sky], {
+    teams: [
+      {
+        id: "sky",
+        name: "Sky crew",
+        instructions: "",
+        members: [sky.pubkey],
+        revision: "1",
+      },
+      {
+        id: "empty",
+        name: "Empty",
+        instructions: "",
+        members: [],
+        revision: "1",
+      },
+      {
+        id: "stale",
+        name: "Stale",
+        instructions: "",
+        members: ["9".repeat(64)],
+      },
+    ],
+  });
+  const listed = () =>
+    within(screen.getByRole("list", { name: "Teams" }))
+      .getAllByRole("button")
+      .map((card) => card.getAttribute("aria-label"));
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  expect(listed()).toEqual(["Sky crew", "Empty", "Stale"]);
+  await user.click(screen.getByRole("button", { name: "Sky crew" }));
+  expect(
+    screen.getByRole("form", { name: "Edit Sky crew" }),
+  ).toBeInTheDocument();
+  act(() => show([agent("Bo", 3)]));
+  expect(
+    screen.queryByRole("form", { name: "Edit Sky crew" }),
+  ).not.toBeInTheDocument();
+  expect(listed()).toEqual(["Empty", "Stale"]);
+});
+
 it("shows an agent on another device read-only, and offers only Finish setup and Delete for an unfinished hosted one", async () => {
   const user = userEvent.setup();
   const far: Agent = {
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index 830ec6e150..444ea7cb86 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -274,12 +274,15 @@ export function AgentsPage({
   // Importing gives an agent a key here, so a hosted type cannot take one.
   const runnable = types.filter((type) => !type.remote);
   // Teams are shared by every community; this one shows each with a member
-  // here, or with none in any community.
+  // here, or with none in any community. A synced team's members are all in
+  // its home, so it shows elsewhere only while it has none.
   const members = new Set(snapshot.agents.map((agent) => agent.pubkey));
   const teams = snapshot.teams.filter(
     (team) =>
       team.members.some((pubkey) => members.has(pubkey)) ||
-      !team.members.some((pubkey) => agents.memberships(pubkey).length),
+      (team.revision
+        ? !team.members.length
+        : !team.members.some((pubkey) => agents.memberships(pubkey).length)),
   );
   // Only a team still saved, or one being made, keeps its editor open.
   const editing =

From 5e7d57f75e7cbe72a0c54d3b30b4bfa310043e0d Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 16:54:38 +1100
Subject: [PATCH 05/13] fix(agents): offer hosted members only to teams that
 can take them

Only a synced team can have hosted members: Save keeps a team stored on
this device local, and that branch refuses any member that isn't an
agent here. Editing such a team now offers only the agents here, as it
did before hosted agents could join teams. New and synced teams still
offer hosted agents.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 src/bundled/agents/AgentsPage.test.tsx | 27 ++++++++++++++++++++++++++
 src/bundled/agents/AgentsPage.tsx      |  7 ++++++-
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index 40f89058e1..f37a13e87a 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -2496,6 +2496,33 @@ it("offers hosted agents as members, warning that they may not get the instructi
   expect(instructions).toHaveAccessibleDescription(local);
 });
 
+it("offers hosted agents only to new and synced teams", async () => {
+  const user = userEvent.setup();
+  const ada = agent("Ada", 1);
+  setup([ada, { ...agent("Sky", 2), place: "hosted" }], {
+    teams: [
+      { id: "crew", name: "Crew", instructions: "", members: [ada.pubkey] },
+      {
+        id: "synced",
+        name: "Synced",
+        instructions: "",
+        members: [ada.pubkey],
+        revision: "1",
+      },
+    ],
+  });
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  await user.click(screen.getByRole("button", { name: "Crew" }));
+  expect(screen.getByRole("checkbox", { name: "Ada" })).toBeChecked();
+  expect(
+    screen.queryByRole("checkbox", { name: "Sky" }),
+  ).not.toBeInTheDocument();
+  await user.keyboard("{Escape}");
+  await user.click(screen.getByRole("button", { name: "Synced" }));
+  expect(screen.getByRole("checkbox", { name: "Ada" })).toBeChecked();
+  expect(screen.getByRole("checkbox", { name: "Sky" })).toBeInTheDocument();
+});
+
 it("closes the team editor when leaving Your teams", async () => {
   const user = userEvent.setup();
   const { agents } = setup([agent("Ada", 1)]);
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index 444ea7cb86..a05d2a8ad9 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -2091,7 +2091,12 @@ function Teams({
       <TeamEditor
         key={editing}
         agents={agents}
-        saved={saved}
+        // A team kept on this device can have only agents here.
+        saved={
+          team && !team.revision
+            ? saved.filter((agent) => agent.place === "here")
+            : saved
+        }
         {...(team ? { team } : {})}
         onDone={() => onEdit(undefined)}
       />

From 42f0be3b1c6b2d4bb41e4bceac98cbda65bc5012 Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 16:56:42 +1100
Subject: [PATCH 06/13] fix(agents): let teams take hosted listings only, not
 other devices'

A team's agents in a community were every listed agent whose setup
finished, which took in agents on the owner's other devices as well as
hosted ones. Save then accepted a new member running on another device,
and rosters named those agents, though the member picker never offered
them. Now only hosted listings join the agents here: Save again refuses
a new member on another device with "Add <agent> to <community> first",
and rosters leave such agents out. Members a team already has still
stay, as its opened roster proves them.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 docs/agents.md                      |  4 +++-
 src/features/agents/service.test.ts | 26 +++++++++++++++++++++++++-
 src/features/agents/service.ts      | 16 ++++++++++------
 3 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/docs/agents.md b/docs/agents.md
index 6d8704279d..609b3fdb24 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -694,7 +694,9 @@ in its home record and applies everywhere.
   local fields. Changes and Delete (which archives the home channel) run online,
   one at a time per team, and report anything left part way. Existing local
   teams are not migrated.
-- **Hosted agents** stay in one community, as their provider holds the key.
+- **Hosted agents** stay in one community, as their provider holds the key. A
+  synced team in that community can have them as members, but they do not get
+  its instructions.
 
 `removeRelayAgent` applies the same steps to a relay-only agent: archive when
 consent exists, delete the owner's kind 30177 record (NIP-09), then remove it from
diff --git a/src/features/agents/service.test.ts b/src/features/agents/service.test.ts
index 9c6f71f5b2..b143ba7bbd 100644
--- a/src/features/agents/service.test.ts
+++ b/src/features/agents/service.test.ts
@@ -11625,9 +11625,10 @@ describe("synced teams", () => {
   async function ready(
     identities: AgentIdentity[],
     storage?: ReturnType<typeof memoryStorage>,
+    listed: RelayEvent[] = [],
   ) {
     const channels = teamChannels();
-    const f = await setup({ identities, storage });
+    const f = await setup({ identities, storage, listed });
     await vi.waitFor(() => expect(channels.made.has(home)).toBe(true));
     return { ...f, ...channels };
   }
@@ -11741,6 +11742,29 @@ describe("synced teams", () => {
     expect(roster).not.toContain(npubEncode(unfinished));
   });
 
+  it("refuses a new member on another device, and leaves it out of rosters", async () => {
+    const team = stored(viewer, [bot, hostedKey, sibling]);
+    const f = await ready([], team.storage, [record(sibling)]);
+    f.plugin.agents.register(cloud().type);
+    await f.service.create({ type: "example/echo", name: "Echo" });
+    await f.service.create({ type: "example/cloud", name: "Sky" });
+    await vi.waitFor(() =>
+      expect(f.service.find(sibling)?.place).toBe("elsewhere"),
+    );
+    await expect(f.service.saveTeam(crew([bot, sibling]))).rejects.toThrow(
+      /^Add npub…\w+ to relay\.example\.test first$/,
+    );
+    expect(f.saveTeam).not.toHaveBeenCalled();
+    team.confirm(f.stores.get(home));
+    await vi.waitFor(() =>
+      expect(f.service.snapshot().teams.map((t) => t.name)).toEqual(["Crew"]),
+    );
+    await handleOf(f.run, f.emit);
+    const roster = f.run.mock.calls.at(-1)?.[0].team;
+    expect(roster).toContain(`- Sky (${npubEncode(hostedKey)})\n`);
+    expect(roster).not.toContain(npubEncode(sibling));
+  });
+
   it("shows only the signed-in account's synced teams", async () => {
     const team = stored(other, []);
     const f = await ready([here(alder)], team.storage);
diff --git a/src/features/agents/service.ts b/src/features/agents/service.ts
index 98c5732fbd..8a38a0da8e 100644
--- a/src/features/agents/service.ts
+++ b/src/features/agents/service.ts
@@ -1143,7 +1143,9 @@ export type Agents = {
   /** Whether a watch's classifier can run on this device now. */
   classifier(): ClassifierAvailability;
   /** Creates a team, or replaces the one with `id`. Members, by pubkey, must
-   * be agents on this device. Each community has the members that are in it. */
+   * be agents on this device or, for a synced team, its home community's
+   * hosted agents whose setup finished. Each community has the members that
+   * are in it. */
   saveTeam(team: TeamChange): Promise<Team>;
   /** Deletes the team; its agents are untouched. */
   removeTeam(id: string): Promise<void>;
@@ -3853,8 +3855,8 @@ export class AgentsService extends Service implements Agents {
     const labels = publicKeyLabels(new Set([...team.members, ...opened]));
     const name = (pubkey: string) =>
       this.liveRows(pubkey)[0]?.name || (labels.get(pubkey) ?? pubkey);
-    // Members the team already has may run on another device; the roster
-    // proves them.
+    // New members must be here or hosted in the home community. Ones the team
+    // already has may run on another device; the roster proves them.
     const members = new Set(this.teamAgents(home).map((agent) => agent.pubkey));
     const outside = team.members.find(
       (pubkey) => !opened.includes(pubkey) && !members.has(pubkey),
@@ -4243,14 +4245,16 @@ export class AgentsService extends Service implements Agents {
         (pubkey === undefined || identity.pubkey === pubkey),
     );
   }
-  /** The agents a team in `origin` can have: the ones here, and the listed
-   * ones whose setup finished, such as hosted ones. */
+  /** The agents a team in `origin` can have: its agents here, and its hosted
+   * ones whose setup finished. */
   private teamAgents(origin: string) {
     return [
       ...this.liveRows().filter(
         (identity) => originOf(identity.relay) === origin,
       ),
-      ...this.listedAgents(origin).filter((agent) => !agent.unfinished),
+      ...this.listedAgents(origin).filter(
+        (agent) => agent.place === "hosted" && !agent.unfinished,
+      ),
     ];
   }
   /** The membership of this key, unless it was deleted. */

From cba0640d753e8c9e7a38d01801207b92fd230073 Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 19:05:49 +1100
Subject: [PATCH 07/13] fix(agents): offer hosted members only to teams Save
 puts here

The member picker offered hosted agents to a new team in a community
whose relay doesn't sync teams, and to a synced team seen outside its
home. Save kept the new team on this device and refused them with "A
member is not an agent on this device", and checked the synced team
against its home, refusing them with "Add <agent> to <home> first".

The service now says whether Save puts a team, or a new team's draft,
in the selected community, from the same home Save picks. The editor
offers hosted agents only then, which also covers a team stored on
this device and replaces the editor's own check for one.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 docs/agents.md                         |  7 ++--
 src/bundled/agents/AgentsPage.test.tsx | 50 ++++++++++++++++----------
 src/bundled/agents/AgentsPage.tsx      | 19 +++++-----
 src/features/agents/service.test.ts    | 34 ++++++++++++++++++
 src/features/agents/service.ts         | 35 +++++++++++++-----
 5 files changed, 105 insertions(+), 40 deletions(-)

diff --git a/docs/agents.md b/docs/agents.md
index 609b3fdb24..ff010ca17b 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -694,9 +694,10 @@ in its home record and applies everywhere.
   local fields. Changes and Delete (which archives the home channel) run online,
   one at a time per team, and report anything left part way. Existing local
   teams are not migrated.
-- **Hosted agents** stay in one community, as their provider holds the key. A
-  synced team in that community can have them as members, but they do not get
-  its instructions.
+- **Hosted agents** stay in one community, as their provider holds the key.
+  Only a synced team homed there can have them as members, so the team editor
+  offers them only for such a team, or for a new one that will sync there. They
+  do not get its instructions.
 
 `removeRelayAgent` applies the same steps to a relay-only agent: archive when
 consent exists, delete the owner's kind 30177 record (NIP-09), then remove it from
diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index f37a13e87a..1cc018f419 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -357,6 +357,11 @@ function setup(
       for (const listener of listeners) listener();
       return team;
     }),
+    // The selected community syncs teams and is every synced team's home.
+    teamHere: vi.fn(
+      ({ id }: Pick<TeamChange, "id" | "draft">) =>
+        !id || !!snapshot.teams.find((team) => team.id === id)?.revision,
+    ),
     core: vi.fn(async () => undefined),
     removeTeam: vi.fn(async (id: string) => {
       snapshot = {
@@ -2496,31 +2501,40 @@ it("offers hosted agents as members, warning that they may not get the instructi
   expect(instructions).toHaveAccessibleDescription(local);
 });
 
-it("offers hosted agents only to new and synced teams", async () => {
+it("offers hosted agents only to a team Save puts in this community", async () => {
   const user = userEvent.setup();
   const ada = agent("Ada", 1);
-  setup([ada, { ...agent("Sky", 2), place: "hosted" }], {
+  const synced = (id: string, name: string) => ({
+    id,
+    name,
+    instructions: "",
+    members: [ada.pubkey],
+    revision: "1",
+  });
+  const { agents } = setup([ada, { ...agent("Sky", 2), place: "hosted" }], {
     teams: [
       { id: "crew", name: "Crew", instructions: "", members: [ada.pubkey] },
-      {
-        id: "synced",
-        name: "Synced",
-        instructions: "",
-        members: [ada.pubkey],
-        revision: "1",
-      },
+      synced("synced", "Synced"),
+      synced("away", "Away"),
     ],
   });
+  // Away's home is another community, and a new team made here is local.
+  agents.teamHere.mockImplementation(({ id }) => id === "synced");
+  const sky = () => screen.queryByRole("checkbox", { name: "Sky" });
   await user.click(screen.getByRole("tab", { name: "Your teams" }));
-  await user.click(screen.getByRole("button", { name: "Crew" }));
-  expect(screen.getByRole("checkbox", { name: "Ada" })).toBeChecked();
-  expect(
-    screen.queryByRole("checkbox", { name: "Sky" }),
-  ).not.toBeInTheDocument();
-  await user.keyboard("{Escape}");
-  await user.click(screen.getByRole("button", { name: "Synced" }));
-  expect(screen.getByRole("checkbox", { name: "Ada" })).toBeChecked();
-  expect(screen.getByRole("checkbox", { name: "Sky" })).toBeInTheDocument();
+  for (const name of ["Crew", "Away", "Synced"]) {
+    await user.click(screen.getByRole("button", { name }));
+    expect(screen.getByRole("checkbox", { name: "Ada" })).toBeChecked();
+    expect(!!sky()).toBe(name === "Synced");
+    await user.keyboard("{Escape}");
+  }
+  await user.click(screen.getByRole("button", { name: "New team" }));
+  await user.click(
+    await screen.findByRole("menuitem", { name: "Create a new team" }),
+  );
+  expect(agents.teamHere).toHaveBeenCalledWith({ draft: expect.any(String) });
+  expect(screen.getByRole("checkbox", { name: "Ada" })).toBeInTheDocument();
+  expect(sky()).not.toBeInTheDocument();
 });
 
 it("closes the team editor when leaving Your teams", async () => {
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index a05d2a8ad9..f13163073b 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -2091,12 +2091,7 @@ function Teams({
       <TeamEditor
         key={editing}
         agents={agents}
-        // A team kept on this device can have only agents here.
-        saved={
-          team && !team.revision
-            ? saved.filter((agent) => agent.place === "here")
-            : saved
-        }
+        saved={saved}
         {...(team ? { team } : {})}
         onDone={() => onEdit(undefined)}
       />
@@ -2151,14 +2146,18 @@ function TeamEditor({
   // What a synced Save revises, and a new team's id for every retry.
   const [opened] = useState(team);
   const [draft] = useState(() => crypto.randomUUID());
+  // Only a team Save puts in this community can have its hosted agents.
+  const choices = agents.teamHere(opened ? { id: opened.id } : { draft })
+    ? saved
+    : saved.filter((agent) => agent.place === "here");
   // Members not in this community, which it doesn't list but keeps.
   const away = members.filter(
     (pubkey) =>
-      !saved.some((agent) => agent.pubkey === pubkey) &&
+      !choices.some((agent) => agent.pubkey === pubkey) &&
       agents.memberships(pubkey).length > 0,
   ).length;
   // Their provider runs them, so they may not get the team's instructions.
-  const remote = saved.filter(
+  const remote = choices.filter(
     (agent) => agent.place === "hosted" && members.includes(agent.pubkey),
   );
   const act = async (work: () => Promise<unknown>) => {
@@ -2237,9 +2236,9 @@ function TeamEditor({
         />
       </Field>
       <Section title="Members">
-        {saved.length ? (
+        {choices.length ? (
           <div className="grid gap-2">
-            {saved.map((agent) => (
+            {choices.map((agent) => (
               <Checkbox
                 key={agent.pubkey}
                 label={agent.name}
diff --git a/src/features/agents/service.test.ts b/src/features/agents/service.test.ts
index b143ba7bbd..cec6328b08 100644
--- a/src/features/agents/service.test.ts
+++ b/src/features/agents/service.test.ts
@@ -11725,6 +11725,7 @@ describe("synced teams", () => {
     await expect(
       f.service.create({ type: "example/cloud", name: "Bo" }),
     ).rejects.toThrow("provider down");
+    expect(f.service.teamHere({ draft })).toBe(true);
     await f.service.saveTeam(crew([bot, hostedKey]));
     expect(f.saveTeam).toHaveBeenCalledWith(
       expect.objectContaining({ members: [bot, hostedKey] }),
@@ -11765,6 +11766,39 @@ describe("synced teams", () => {
     expect(roster).not.toContain(npubEncode(sibling));
   });
 
+  it("keeps a new team, hosted agents and all, off a relay without config channels", async () => {
+    const make = vi.fn((_community: string) => null);
+    coordinators.make = make;
+    const f = await setup();
+    f.plugin.agents.register(cloud().type);
+    await f.service.create({ type: "example/echo", name: "Echo" });
+    await f.service.create({ type: "example/cloud", name: "Sky" });
+    await vi.waitFor(() =>
+      expect(make).toHaveBeenCalledWith(home, expect.anything()),
+    );
+    await settle();
+    expect(f.service.teamHere({ draft })).toBe(false);
+    await expect(f.service.saveTeam(crew([bot, hostedKey]))).rejects.toThrow(
+      "A member is not an agent on this device",
+    );
+  });
+
+  it("puts a synced team in the selected community only while it is home", async () => {
+    const team = stored(viewer, [alder]);
+    const local = { id: "local", name: "Local", instructions: "", members: [] };
+    writeTeams(team.storage, [local]);
+    const f = await ready([here(alder)], team.storage);
+    team.confirm(f.stores.get(home));
+    expect(f.service.snapshot().teams.map((t) => t.id)).toEqual([
+      "local",
+      draft,
+    ]);
+    expect(f.service.teamHere({ id: draft })).toBe(true);
+    expect(f.service.teamHere({ id: "local" })).toBe(false);
+    f.select(f.second.origin);
+    expect(f.service.teamHere({ id: draft })).toBe(false);
+  });
+
   it("shows only the signed-in account's synced teams", async () => {
     const team = stored(other, []);
     const f = await ready([here(alder)], team.storage);
diff --git a/src/features/agents/service.ts b/src/features/agents/service.ts
index 8a38a0da8e..f1e41795b9 100644
--- a/src/features/agents/service.ts
+++ b/src/features/agents/service.ts
@@ -1147,6 +1147,10 @@ export type Agents = {
    * hosted agents whose setup finished. Each community has the members that
    * are in it. */
   saveTeam(team: TeamChange): Promise<Team>;
+  /** Whether Save puts the team with `id`, or the new team `draft`, in the
+   * selected community: a synced team homed there, or a new team where it
+   * syncs. Only such a team can have that community's hosted agents. */
+  teamHere(team: Pick<TeamChange, "id" | "draft">): boolean;
   /** Deletes the team; its agents are untouched. */
   removeTeam(id: string): Promise<void>;
 };
@@ -3694,15 +3698,7 @@ export class AgentsService extends Service implements Agents {
   }: TeamChange) {
     if (!this.native) throw new Error("Agents run only in the desktop app");
     if (!name.trim()) throw new Error("Name the team");
-    const synced = id && this.synced().find((entry) => entry.team.id === id);
-    const selected = this.selectedOrigin();
-    // A new team is synced where its community syncs config, and stays in
-    // the community its first Save chose.
-    const home = synced
-      ? synced.community
-      : !id && draft
-        ? (this.teamDrafts.get(draft) ?? this.newTeamHome(selected))
-        : undefined;
+    const home = this.teamHome(id, draft);
     const teamId = id ?? draft;
     if (home && teamId) {
       if (draft) this.teamDrafts.set(draft, home);
@@ -3740,6 +3736,27 @@ export class AgentsService extends Service implements Agents {
     return team;
   }
 
+  teamHere({ id, draft }: Pick<TeamChange, "id" | "draft">) {
+    const selected = this.selectedOrigin();
+    try {
+      return !!selected && this.teamHome(id, draft) === selected;
+    } catch {
+      // Save refuses a new team while it can't tell where that syncs.
+      return false;
+    }
+  }
+
+  /** Where Save puts the team with `id`, or the new team `draft`: a synced
+   * team's home, or where a new one syncs, staying in the community its
+   * first Save chose. Undefined keeps the team on this device. */
+  private teamHome(id: string | undefined, draft: string | undefined) {
+    if (id)
+      return this.synced().find((entry) => entry.team.id === id)?.community;
+    return draft
+      ? (this.teamDrafts.get(draft) ?? this.newTeamHome(this.selectedOrigin()))
+      : undefined;
+  }
+
   /** Where a new team made with `selected` selected syncs: nowhere only
    * when its relay is known to have no config channels. */
   private newTeamHome(selected: string | undefined) {

From 75cdd96459975fa0111a8d4d5d6bc57dda9d9c9e Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 19:06:33 +1100
Subject: [PATCH 08/13] fix(agents): keep a synced team listed in its home
 community

A synced team showed only where one of its members was listed. One
whose members were all unlisted, as when its last member was deleted
but leaving the team's channel failed, vanished from every community,
its home included, so it couldn't be opened, edited or deleted though
its config channel remained.

The Teams list now always shows a synced team in its home, asking the
service where Save puts it. Elsewhere it still shows only with a member
listed there, or while it has no members.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 docs/agents.md                         |  7 ++++---
 src/bundled/agents/AgentsPage.test.tsx | 24 +++++++++++++++++++++++-
 src/bundled/agents/AgentsPage.tsx      |  6 +++---
 3 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/docs/agents.md b/docs/agents.md
index ff010ca17b..60a91cf29b 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -679,9 +679,10 @@ in its home record and applies everywhere.
   agent's memory in that community stay, so they come back if it is added again;
   its attention there does not.
 - **Teams** work like agents: a team shows in every community where it has a
-  member (or in all of them while it has none), but has one home community. A
-  local team is shared by every community; a member's roster lists only teammates
-  in the same community, and the editor keeps members that are only elsewhere.
+  member (or in all of them while it has none), and a synced team always shows
+  in its one home community. A local team is shared by every community; a
+  member's roster lists only teammates in the same community, and the editor
+  keeps members that are only elsewhere.
   Where the community's relay supports config channels, a new team, or one
   imported from old Buzz, is synced: its NIP-AP config channel (name and
   instructions) is created only in the community it was made in, and its members
diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index 1cc018f419..86768d31a7 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -2605,7 +2605,7 @@ it("explains an unavailable harness without claiming the key is on another devic
 it("shows a synced team only where its members are, after switching communities", async () => {
   const user = userEvent.setup();
   const sky: Agent = { ...agent("Sky", 2), place: "hosted" };
-  const { show } = setup([agent("Ada", 1), sky], {
+  const { agents, show } = setup([agent("Ada", 1), sky], {
     teams: [
       {
         id: "sky",
@@ -2639,6 +2639,8 @@ it("shows a synced team only where its members are, after switching communities"
   expect(
     screen.getByRole("form", { name: "Edit Sky crew" }),
   ).toBeInTheDocument();
+  // Bo's community is no synced team's home.
+  agents.teamHere.mockReturnValue(false);
   act(() => show([agent("Bo", 3)]));
   expect(
     screen.queryByRole("form", { name: "Edit Sky crew" }),
@@ -2646,6 +2648,26 @@ it("shows a synced team only where its members are, after switching communities"
   expect(listed()).toEqual(["Empty", "Stale"]);
 });
 
+it("keeps a synced team in its home while none of its members is listed", async () => {
+  const user = userEvent.setup();
+  const { agents } = setup([agent("Ada", 1)], {
+    teams: [
+      {
+        id: "gone",
+        name: "Gone",
+        instructions: "",
+        members: ["9".repeat(64)],
+        revision: "1",
+      },
+    ],
+  });
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  expect(agents.teamHere).toHaveBeenCalledWith({ id: "gone" });
+  await user.click(screen.getByRole("button", { name: "Gone" }));
+  await user.click(screen.getByRole("button", { name: "Delete team" }));
+  expect(agents.removeTeam).toHaveBeenCalledWith("gone");
+});
+
 it("shows an agent on another device read-only, and offers only Finish setup and Delete for an unfinished hosted one", async () => {
   const user = userEvent.setup();
   const far: Agent = {
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index f13163073b..596ec4a1fe 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -274,14 +274,14 @@ export function AgentsPage({
   // Importing gives an agent a key here, so a hosted type cannot take one.
   const runnable = types.filter((type) => !type.remote);
   // Teams are shared by every community; this one shows each with a member
-  // here, or with none in any community. A synced team's members are all in
-  // its home, so it shows elsewhere only while it has none.
+  // here, or with none in any community. A synced team always shows in its
+  // home, and elsewhere only with a member there or while it has none.
   const members = new Set(snapshot.agents.map((agent) => agent.pubkey));
   const teams = snapshot.teams.filter(
     (team) =>
       team.members.some((pubkey) => members.has(pubkey)) ||
       (team.revision
-        ? !team.members.length
+        ? !team.members.length || agents.teamHere({ id: team.id })
         : !team.members.some((pubkey) => agents.memberships(pubkey).length)),
   );
   // Only a team still saved, or one being made, keeps its editor open.

From 8bc7fbefee53fadb06f4681a2f2ef3f9de8f774d Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 20:42:40 +1100
Subject: [PATCH 09/13] fix(agents): leave off a hosted member picked in
 another community

A new team's editor stays open when the selected community changes, and
its choices become that community's agents. A hosted agent picked before
the switch was hidden, so it couldn't be unchecked, and left out of the
warning and the away count, but Create still submitted it and Save
refused it with "Add <agent> to <community> first".

Save now gets only the members the editor accounts for: ones among its
choices, ones the team already has, and agents on this device in other
communities. A hosted agent picked elsewhere is left off, and shows
checked again if its community is selected again.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 docs/agents.md                         |  5 ++-
 src/bundled/agents/AgentsPage.test.tsx | 58 ++++++++++++++++++++++++++
 src/bundled/agents/AgentsPage.tsx      | 11 ++++-
 3 files changed, 71 insertions(+), 3 deletions(-)

diff --git a/docs/agents.md b/docs/agents.md
index 60a91cf29b..2f2a555ff6 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -697,8 +697,9 @@ in its home record and applies everywhere.
   teams are not migrated.
 - **Hosted agents** stay in one community, as their provider holds the key.
   Only a synced team homed there can have them as members, so the team editor
-  offers them only for such a team, or for a new one that will sync there. They
-  do not get its instructions.
+  offers them only for such a team, or for a new one that will sync there. One
+  picked before another community was selected is left off unless the team
+  already has it. They do not get its instructions.
 
 `removeRelayAgent` applies the same steps to a relay-only agent: archive when
 consent exists, delete the owner's kind 30177 record (NIP-09), then remove it from
diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index 86768d31a7..c71f5bd1d2 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -2537,6 +2537,64 @@ it("offers hosted agents only to a team Save puts in this community", async () =
   expect(sky()).not.toBeInTheDocument();
 });
 
+it("leaves a hosted agent picked in another community off a new team, keeping the rest", async () => {
+  const user = userEvent.setup();
+  const ada = agent("Ada", 1);
+  const sky: Agent = { ...agent("Sky", 2), place: "hosted" };
+  const { agents, show } = setup([ada, sky], {
+    teams: [
+      {
+        id: "sky",
+        name: "Sky crew",
+        instructions: "",
+        members: [sky.pubkey],
+        revision: "1",
+      },
+    ],
+  });
+  // Ada runs on this device, in the first community only.
+  agents.memberships.mockImplementation((pubkey) =>
+    pubkey === ada.pubkey
+      ? [{ key: ada.key, origin: "https://relay.example", connected: true }]
+      : [],
+  );
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  await user.click(screen.getByRole("button", { name: "New team" }));
+  await user.click(
+    await screen.findByRole("menuitem", { name: "Create a new team" }),
+  );
+  await user.type(screen.getByRole("textbox", { name: "Name" }), "Crew");
+  await user.click(screen.getByRole("checkbox", { name: "Ada" }));
+  await user.click(screen.getByRole("checkbox", { name: "Sky" }));
+  // Another community that syncs teams, with its own hosted agent.
+  act(() => show([agent("Bo", 3), { ...agent("Kai", 5), place: "hosted" }]));
+  expect(screen.getByRole("form", { name: "New team" })).toBeInTheDocument();
+  expect(
+    screen.queryByRole("checkbox", { name: "Sky" }),
+  ).not.toBeInTheDocument();
+  expect(screen.getByRole("checkbox", { name: "Kai" })).not.toBeChecked();
+  expect(
+    screen.getByText("+1 in your other communities, who stay on the team."),
+  ).toBeInTheDocument();
+  const instructions = screen.getByRole("textbox", { name: "Instructions" });
+  expect(instructions).toHaveAccessibleDescription(
+    "Every member follows these after its own instructions.",
+  );
+  await user.click(screen.getByRole("button", { name: "Create team" }));
+  expect(agents.saveTeam).toHaveBeenLastCalledWith({
+    draft: expect.any(String),
+    name: "Crew",
+    instructions: "",
+    members: [ada.pubkey],
+  });
+  // A hosted member the team already has stays, though not listed here.
+  await user.click(screen.getByRole("button", { name: "Sky crew" }));
+  await user.click(screen.getByRole("button", { name: "Save" }));
+  expect(agents.saveTeam).toHaveBeenLastCalledWith(
+    expect.objectContaining({ id: "sky", members: [sky.pubkey] }),
+  );
+});
+
 it("closes the team editor when leaving Your teams", async () => {
   const user = userEvent.setup();
   const { agents } = setup([agent("Ada", 1)]);
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index 596ec4a1fe..dcf46231f9 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -2150,6 +2150,15 @@ function TeamEditor({
   const choices = agents.teamHere(opened ? { id: opened.id } : { draft })
     ? saved
     : saved.filter((agent) => agent.place === "here");
+  // What Save gets: members among these choices, ones the team already has,
+  // and agents here in other communities. Not a hosted agent picked while
+  // another community was selected, which this one can't have.
+  const kept = members.filter(
+    (pubkey) =>
+      choices.some((agent) => agent.pubkey === pubkey) ||
+      opened?.members.includes(pubkey) ||
+      agents.memberships(pubkey).length > 0,
+  );
   // Members not in this community, which it doesn't list but keeps.
   const away = members.filter(
     (pubkey) =>
@@ -2178,7 +2187,7 @@ function TeamEditor({
         ...(opened ? { id: opened.id, opened } : { draft }),
         name: name.trim(),
         instructions,
-        members,
+        members: kept,
       }),
     );
   return (

From ca8eb347f43617beb5a69f0737163eecbfc5f009 Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 20:45:01 +1100
Subject: [PATCH 10/13] fix(agents): show hosted members once a new team is
 known to sync

When a community's config channels came up after its agents were
listed, nothing in the snapshot changed, so subscribers weren't told. A
new team's editor already open kept hiding the hosted agents, which
Save would now accept, until something else made the page render.

The snapshot now has `syncsTeams`, whether the selected community's
config channels are up. What `teamHere` says of a new team changes with
it, so the open editor asks again and offers them.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 src/bundled/agents/AgentsPage.test.tsx | 32 +++++++++++++++++++++++++-
 src/features/agents/service.test.ts    | 25 ++++++++++++++++++++
 src/features/agents/service.ts         |  9 +++++++-
 3 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index c71f5bd1d2..171212fa64 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -403,7 +403,11 @@ function setup(
     snapshot = { ...snapshot, agents: next };
     for (const listener of listeners) listener();
   };
-  return { agents, echoProvider, types, show, relay, ...view };
+  const change = (patch: Partial<AgentsSnapshot>) => {
+    snapshot = { ...snapshot, ...patch };
+    for (const listener of listeners) listener();
+  };
+  return { agents, echoProvider, types, show, change, relay, ...view };
 }
 
 it("opens settings for a selected agent beside the grid and follows the arrow keys", async () => {
@@ -2595,6 +2599,32 @@ it("leaves a hosted agent picked in another community off a new team, keeping th
   );
 });
 
+it("offers an open new team hosted agents once its community is known to sync teams", async () => {
+  const user = userEvent.setup();
+  const { agents, change } = setup([
+    agent("Ada", 1),
+    { ...agent("Sky", 2), place: "hosted" },
+  ]);
+  // A new team syncs here once the community's config channels are up.
+  agents.teamHere.mockImplementation(
+    ({ id }) => !id && !!agents.snapshot().syncsTeams,
+  );
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  await user.click(screen.getByRole("button", { name: "New team" }));
+  await user.click(
+    await screen.findByRole("menuitem", { name: "Create a new team" }),
+  );
+  await user.type(screen.getByRole("textbox", { name: "Name" }), "Crew");
+  await user.click(screen.getByRole("checkbox", { name: "Ada" }));
+  expect(
+    screen.queryByRole("checkbox", { name: "Sky" }),
+  ).not.toBeInTheDocument();
+  act(() => change({ syncsTeams: true }));
+  expect(screen.getByRole("checkbox", { name: "Sky" })).not.toBeChecked();
+  expect(screen.getByRole("checkbox", { name: "Ada" })).toBeChecked();
+  expect(screen.getByRole("textbox", { name: "Name" })).toHaveValue("Crew");
+});
+
 it("closes the team editor when leaving Your teams", async () => {
   const user = userEvent.setup();
   const { agents } = setup([agent("Ada", 1)]);
diff --git a/src/features/agents/service.test.ts b/src/features/agents/service.test.ts
index cec6328b08..c1c8f72a09 100644
--- a/src/features/agents/service.test.ts
+++ b/src/features/agents/service.test.ts
@@ -11826,6 +11826,31 @@ describe("synced teams", () => {
     expect(channels.saveTeam).toHaveBeenCalledOnce();
   });
 
+  it("tells subscribers when a new team made here starts to sync", async () => {
+    const channels = teamChannels();
+    const make = coordinators.make;
+    let discover = () => {};
+    coordinators.make = (community, store) =>
+      new Promise((resolve) => {
+        discover = () => resolve(make?.(community, store));
+      });
+    const f = await setup();
+    f.plugin.agents.register(cloud().type);
+    // Its hosted agent is listed while the support check is still running.
+    await f.service.create({ type: "example/cloud", name: "Sky" });
+    expect(f.service.find(hostedKey)?.place).toBe("hosted");
+    await settle();
+    expect(f.service.snapshot().syncsTeams).toBeFalsy();
+    expect(f.service.teamHere({ draft })).toBe(false);
+    const changed = vi.fn();
+    f.service.subscribe(changed);
+    discover();
+    await vi.waitFor(() => expect(channels.made.has(home)).toBe(true));
+    await vi.waitFor(() => expect(changed).toHaveBeenCalled());
+    expect(f.service.snapshot().syncsTeams).toBe(true);
+    expect(f.service.teamHere({ draft })).toBe(true);
+  });
+
   it("refuses Import until a failed support check succeeds again", async () => {
     coordinators.make = () => Promise.reject(new Error("discovery failed"));
     const f = await setup({ identities: [here(alder)] });
diff --git a/src/features/agents/service.ts b/src/features/agents/service.ts
index f1e41795b9..fc28d249e4 100644
--- a/src/features/agents/service.ts
+++ b/src/features/agents/service.ts
@@ -887,6 +887,9 @@ export type AgentsSnapshot = Readonly<{
   /** The owner's teams on this device, which every community shares, and
    * each synced team with a confirmed copy. */
   teams: readonly Team[];
+  /** Whether the selected community's config channels are up, so a new team
+   * made there syncs. What `teamHere` says of a new team changes with it. */
+  syncsTeams?: boolean;
   error?: string;
 }>;
 export type { Carry, Team };
@@ -1863,6 +1866,7 @@ export class AgentsService extends Service implements Agents {
           agents: Object.freeze([]),
           running: Object.freeze([]),
           interrupted: Object.freeze([]),
+          syncsTeams: false,
         });
         this.notify();
       };
@@ -4980,16 +4984,19 @@ export class AgentsService extends Service implements Agents {
     const same = (next: readonly Agent[], prior: readonly Agent[]) =>
       next.length === prior.length &&
       next.every((agent, index) => agent === prior[index]);
+    const syncsTeams = !!selected && this.communityConfigs.has(selected);
     if (
       !same(agents, this.state.agents) ||
       !same(running, this.state.running) ||
-      !same(interrupted, this.state.interrupted)
+      !same(interrupted, this.state.interrupted) ||
+      syncsTeams !== !!this.state.syncsTeams
     ) {
       this.state = Object.freeze({
         ...this.state,
         agents: Object.freeze(agents),
         running: Object.freeze(running),
         interrupted: Object.freeze(interrupted),
+        syncsTeams,
       });
       this.notify();
     }

From 60348bad4af5412dc64497d86aa4318b26089112 Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 20:50:36 +1100
Subject: [PATCH 11/13] fix(agents): keep hosted teammates in rosters while
 listings load

A community's agent records are read in the background after each
restart or reconnect, and a failed read leaves them unread until a
later one succeeds. Until then a turn could start from the persisted
team, and its roster dropped every hosted teammate, name and npub, as
nothing yet said they were hosted.

While the community's records are unread, a synced team homed there now
names each member not on this device by npub alone, since a hosted one
can't yet be told from one on another device. Once they are read, hosted
members get their names again and the others leave, as before.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 docs/agents.md                      |  5 ++-
 src/features/agents/service.test.ts | 63 +++++++++++++++++++++++++++++
 src/features/agents/service.ts      | 37 +++++++++++++----
 3 files changed, 96 insertions(+), 9 deletions(-)

diff --git a/docs/agents.md b/docs/agents.md
index 2f2a555ff6..c2490c6421 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -699,7 +699,10 @@ in its home record and applies everywhere.
   Only a synced team homed there can have them as members, so the team editor
   offers them only for such a team, or for a new one that will sync there. One
   picked before another community was selected is left off unless the team
-  already has it. They do not get its instructions.
+  already has it. They do not get its instructions, but rosters name them.
+  Until the community's agent list is read, which tells hosted agents from
+  ones on other devices, the team's roster there names each member not on this
+  device by npub alone.
 
 `removeRelayAgent` applies the same steps to a relay-only agent: archive when
 consent exists, delete the owner's kind 30177 record (NIP-09), then remove it from
diff --git a/src/features/agents/service.test.ts b/src/features/agents/service.test.ts
index c1c8f72a09..85baa6cdb7 100644
--- a/src/features/agents/service.test.ts
+++ b/src/features/agents/service.test.ts
@@ -11766,6 +11766,69 @@ describe("synced teams", () => {
     expect(roster).not.toContain(npubEncode(sibling));
   });
 
+  it("names a hosted teammate by npub while the community's agent list is unread", async () => {
+    const team = stored(viewer, [bot, hostedKey]);
+    const sky = record(hostedKey, {
+      content: JSON.stringify({ name: "Sky" }),
+      tags: [
+        ["d", hostedKey],
+        ["runtime", "example/cloud"],
+      ],
+    });
+    const f = await ready([], team.storage, [sky]);
+    f.plugin.agents.register(cloud().type);
+    await f.service.create({ type: "example/echo", name: "Echo" });
+    team.confirm(f.stores.get(home));
+    await vi.waitFor(() =>
+      expect(f.service.find(hostedKey)?.place).toBe("hosted"),
+    );
+    const roster = async (id: string) => {
+      const runs = f.run.mock.calls.length;
+      f.emit({
+        events: [
+          event(id, {
+            tags: [
+              ["h", channel],
+              ["p", bot],
+            ],
+          }),
+        ],
+      });
+      await vi.waitFor(() => expect(f.run).toHaveBeenCalledTimes(runs + 1));
+      return f.run.mock.calls.at(-1)?.[0].team;
+    };
+    const echo = `- Echo (${npubEncode(bot)}), you\n`;
+    expect(await roster("listed")).toContain(
+      `${echo}- Sky (${npubEncode(hostedKey)})\n`,
+    );
+    // As after a restart, its agent list is read again, and the read is held.
+    const read = vi.mocked(f.session.read);
+    const answer = read.getMockImplementation() as NonNullable<
+      ReturnType<typeof read.getMockImplementation>
+    >;
+    let fail = () => {};
+    const listing = new Promise<never>((_, reject) => {
+      fail = () => reject(new Error("offline"));
+    });
+    let held = 0;
+    read.mockImplementation((filters, settings) => {
+      if (filters[0]?.kinds?.includes(30177)) {
+        held++;
+        return listing;
+      }
+      return answer(filters, settings);
+    });
+    f.connect(false);
+    f.connect(true);
+    await vi.waitFor(() => expect(held).toBe(1));
+    expect(f.service.find(hostedKey)).toBeUndefined();
+    const unread = `${echo}- ${npubEncode(hostedKey)}\n`;
+    expect(await roster("held")).toContain(unread);
+    fail();
+    await settle();
+    expect(await roster("failed")).toContain(unread);
+  });
+
   it("keeps a new team, hosted agents and all, off a relay without config channels", async () => {
     const make = vi.fn((_community: string) => null);
     coordinators.make = make;
diff --git a/src/features/agents/service.ts b/src/features/agents/service.ts
index fc28d249e4..03d9b8761d 100644
--- a/src/features/agents/service.ts
+++ b/src/features/agents/service.ts
@@ -1279,10 +1279,11 @@ const PARENT_LOOKUP_MS = 5_000;
 const message = (error: unknown) =>
   String(error instanceof Error ? error.message : error);
 /** The team sections for agent `self`: each team it is on, its members that
- * still exist by name and npub, and the team's instructions. */
+ * still exist by name and npub (by npub alone where `agents` has no name),
+ * and the team's instructions. */
 export function teamPrompt(
   teams: readonly Team[],
-  agents: readonly Pick<AgentIdentity, "pubkey" | "name">[],
+  agents: readonly Readonly<{ pubkey: string; name?: string }>[],
   self: string,
 ) {
   const names = new Map(agents.map((agent) => [agent.pubkey, agent.name]));
@@ -1290,12 +1291,12 @@ export function teamPrompt(
     .filter((team) => team.members.includes(self))
     .map((team) => {
       const roster = team.members.flatMap((pubkey) => {
+        if (!names.has(pubkey)) return [];
         const name = names.get(pubkey);
-        return name === undefined
-          ? []
-          : [
-              `- ${name} (${npubEncode(pubkey)})${pubkey === self ? ", you" : ""}`,
-            ];
+        const npub = npubEncode(pubkey);
+        return [
+          `- ${name === undefined ? npub : `${name} (${npub})`}${pubkey === self ? ", you" : ""}`,
+        ];
       });
       return [
         "<team>",
@@ -1645,7 +1646,7 @@ export class AgentsService extends Service implements Agents {
         const origin = member && originOf(member.relay);
         // Only teammates in the same community, where it can reach them.
         return member && origin
-          ? teamPrompt(this.allTeams(), this.teamAgents(origin), member.pubkey)
+          ? teamPrompt(this.allTeams(), this.teammates(origin), member.pubkey)
           : "";
       },
       agentTypes: () =>
@@ -4278,6 +4279,26 @@ export class AgentsService extends Service implements Agents {
       ),
     ];
   }
+  /** Who rosters in `origin` name: the agents a team there can have. Until
+   * its agent records are read, which tell a hosted agent from one on another
+   * device, a synced team homed there names its other members by npub. */
+  private teammates(origin: string) {
+    const agents = this.teamAgents(origin);
+    if (this.listings.has(origin)) return agents;
+    const known = new Set(
+      [...this.identities, ...this.listedAgents(origin)].map(
+        (agent) => agent.pubkey,
+      ),
+    );
+    const unnamed = new Set(
+      this.synced().flatMap(({ community, team }) =>
+        community === origin
+          ? team.members.filter((pubkey) => !known.has(pubkey))
+          : [],
+      ),
+    );
+    return [...agents, ...[...unnamed].map((pubkey) => ({ pubkey }))];
+  }
   /** The membership of this key, unless it was deleted. */
   private liveMember(key: AgentKey) {
     return this.identities.find(

From b4c9ad5913b64e4c4746fb277fc7bdf48d8cf3bd Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Thu, 29 Oct 2026 23:06:38 +1100
Subject: [PATCH 12/13] fix(agents): keep a hosted pick while its community
 lists agents again

A new team's editor left off any hosted member it no longer listed,
which included one picked in the selected community while that
community's agent records were read again after a reconnect, or while
that read failed. Once the config channels were back, Create could save
the team without it, where Save used to refuse it and keep the draft.

The editor now remembers where each hosted member was picked, and
leaves one off only if Save doesn't put the team in that community.
Save refuses a member it can't find while the home's agent list is
unread with "Can't tell yet whether <agent> is in <community>; try
again shortly", not "Add <agent> to <community> first". The same rule
keeps a hosted pick for an existing synced team, or for a new team
whose first Save failed, after another community is selected.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 docs/agents.md                         |  7 ++-
 src/bundled/agents/AgentsPage.test.tsx | 62 ++++++++++++++++++++++++--
 src/bundled/agents/AgentsPage.tsx      | 33 +++++++++-----
 src/features/agents/service.test.ts    | 61 +++++++++++++++++++++++++
 src/features/agents/service.ts         | 27 +++++++----
 5 files changed, 167 insertions(+), 23 deletions(-)

diff --git a/docs/agents.md b/docs/agents.md
index c2490c6421..ef07d1f7eb 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -698,8 +698,11 @@ in its home record and applies everywhere.
 - **Hosted agents** stay in one community, as their provider holds the key.
   Only a synced team homed there can have them as members, so the team editor
   offers them only for such a team, or for a new one that will sync there. One
-  picked before another community was selected is left off unless the team
-  already has it. They do not get its instructions, but rosters name them.
+  picked in a community Save doesn't put the team in, as when another is
+  selected before a new team's first Save, is left off unless the team already
+  has it. One picked where Save puts the team stays while that community's
+  agent list is read again, but Save refuses it until the list is read. They
+  do not get its instructions, but rosters name them.
   Until the community's agent list is read, which tells hosted agents from
   ones on other devices, the team's roster there names each member not on this
   device by npub alone.
diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index 171212fa64..f432ea8a9e 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -357,9 +357,10 @@ function setup(
       for (const listener of listeners) listener();
       return team;
     }),
-    // The selected community syncs teams and is every synced team's home.
+    // The selected community, where each hosted agent was picked, syncs teams
+    // and is every synced team's home.
     teamHere: vi.fn(
-      ({ id }: Pick<TeamChange, "id" | "draft">) =>
+      ({ id }: Pick<TeamChange, "id" | "draft">, _community?: string) =>
         !id || !!snapshot.teams.find((team) => team.id === id)?.revision,
     ),
     core: vi.fn(async () => undefined),
@@ -2562,6 +2563,11 @@ it("leaves a hosted agent picked in another community off a new team, keeping th
       ? [{ key: ada.key, origin: "https://relay.example", connected: true }]
       : [],
   );
+  // A new team syncs in the selected community.
+  let selected = ada.relay;
+  agents.teamHere.mockImplementation(
+    ({ id }, community = selected) => !!id || community === selected,
+  );
   await user.click(screen.getByRole("tab", { name: "Your teams" }));
   await user.click(screen.getByRole("button", { name: "New team" }));
   await user.click(
@@ -2571,7 +2577,14 @@ it("leaves a hosted agent picked in another community off a new team, keeping th
   await user.click(screen.getByRole("checkbox", { name: "Ada" }));
   await user.click(screen.getByRole("checkbox", { name: "Sky" }));
   // Another community that syncs teams, with its own hosted agent.
-  act(() => show([agent("Bo", 3), { ...agent("Kai", 5), place: "hosted" }]));
+  const other = "wss://other.example";
+  act(() => {
+    selected = other;
+    show([
+      { ...agent("Bo", 3), relay: other },
+      { ...agent("Kai", 5), place: "hosted", relay: other },
+    ]);
+  });
   expect(screen.getByRole("form", { name: "New team" })).toBeInTheDocument();
   expect(
     screen.queryByRole("checkbox", { name: "Sky" }),
@@ -2599,6 +2612,49 @@ it("leaves a hosted agent picked in another community off a new team, keeping th
   );
 });
 
+it("keeps a hosted agent picked for a new team while its community lists agents again", async () => {
+  const user = userEvent.setup();
+  const ada = agent("Ada", 1);
+  const sky: Agent = { ...agent("Sky", 2), place: "hosted" };
+  const { agents, show } = setup([ada, sky]);
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  await user.click(screen.getByRole("button", { name: "New team" }));
+  await user.click(
+    await screen.findByRole("menuitem", { name: "Create a new team" }),
+  );
+  await user.type(screen.getByRole("textbox", { name: "Name" }), "Crew");
+  await user.click(screen.getByRole("checkbox", { name: "Ada" }));
+  await user.click(screen.getByRole("checkbox", { name: "Sky" }));
+  // The community reconnects and still syncs teams, but its hosted agents
+  // are unlisted until their records are read again, so Save refuses Sky.
+  act(() => show([ada]));
+  expect(
+    screen.queryByRole("checkbox", { name: "Sky" }),
+  ).not.toBeInTheDocument();
+  const refusal = "Can't tell yet whether Sky is in relay.example";
+  agents.saveTeam.mockRejectedValueOnce(new Error(refusal));
+  await user.click(screen.getByRole("button", { name: "Create team" }));
+  const form = screen.getByRole("form", { name: "New team" });
+  expect(await within(form).findByRole("alert")).toHaveTextContent(refusal);
+  const draft = agents.saveTeam.mock.calls.at(-1)?.[0].draft;
+  expect(agents.saveTeam).toHaveBeenLastCalledWith({
+    draft: expect.any(String),
+    name: "Crew",
+    instructions: "",
+    members: [ada.pubkey, sky.pubkey],
+  });
+  // Once they are, Sky shows checked again, and Create keeps the draft.
+  act(() => show([ada, sky]));
+  expect(screen.getByRole("checkbox", { name: "Sky" })).toBeChecked();
+  await user.click(screen.getByRole("button", { name: "Create team" }));
+  expect(agents.saveTeam).toHaveBeenLastCalledWith({
+    draft,
+    name: "Crew",
+    instructions: "",
+    members: [ada.pubkey, sky.pubkey],
+  });
+});
+
 it("offers an open new team hosted agents once its community is known to sync teams", async () => {
   const user = userEvent.setup();
   const { agents, change } = setup([
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index dcf46231f9..8d1fc9aa19 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -2146,19 +2146,28 @@ function TeamEditor({
   // What a synced Save revises, and a new team's id for every retry.
   const [opened] = useState(team);
   const [draft] = useState(() => crypto.randomUUID());
+  const which = opened ? { id: opened.id } : { draft };
+  // The community each hosted member was picked in, the only one with it.
+  const [picked, setPicked] = useState<ReadonlyMap<string, string>>(
+    () => new Map(),
+  );
   // Only a team Save puts in this community can have its hosted agents.
-  const choices = agents.teamHere(opened ? { id: opened.id } : { draft })
+  const choices = agents.teamHere(which)
     ? saved
     : saved.filter((agent) => agent.place === "here");
   // What Save gets: members among these choices, ones the team already has,
-  // and agents here in other communities. Not a hosted agent picked while
-  // another community was selected, which this one can't have.
-  const kept = members.filter(
-    (pubkey) =>
+  // agents here in other communities, and hosted agents picked where Save
+  // puts the team, which may not be listed again yet. Not one picked in
+  // another community, as before selecting this one, which can't have it.
+  const kept = members.filter((pubkey) => {
+    const from = picked.get(pubkey);
+    return (
       choices.some((agent) => agent.pubkey === pubkey) ||
       opened?.members.includes(pubkey) ||
-      agents.memberships(pubkey).length > 0,
-  );
+      agents.memberships(pubkey).length > 0 ||
+      (from !== undefined && agents.teamHere(which, from))
+    );
+  });
   // Members not in this community, which it doesn't list but keeps.
   const away = members.filter(
     (pubkey) =>
@@ -2253,13 +2262,17 @@ function TeamEditor({
                 label={agent.name}
                 checked={members.includes(agent.pubkey)}
                 disabled={pending}
-                onCheckedChange={(checked) =>
+                onCheckedChange={(checked) => {
+                  if (agent.place === "hosted")
+                    setPicked((last) =>
+                      new Map(last).set(agent.pubkey, agent.relay),
+                    );
                   setMembers((last) =>
                     checked
                       ? [...last, agent.pubkey]
                       : last.filter((pubkey) => pubkey !== agent.pubkey),
-                  )
-                }
+                  );
+                }}
               />
             ))}
           </div>
diff --git a/src/features/agents/service.test.ts b/src/features/agents/service.test.ts
index 85baa6cdb7..1926918911 100644
--- a/src/features/agents/service.test.ts
+++ b/src/features/agents/service.test.ts
@@ -11829,6 +11829,67 @@ describe("synced teams", () => {
     expect(await roster("failed")).toContain(unread);
   });
 
+  it("refuses a hosted member until the community's agent list is read again", async () => {
+    const sky = record(hostedKey, {
+      content: JSON.stringify({ name: "Sky" }),
+      tags: [
+        ["d", hostedKey],
+        ["runtime", "example/cloud"],
+      ],
+    });
+    const f = await ready([], undefined, [sky]);
+    f.plugin.agents.register(cloud().type);
+    await f.service.create({ type: "example/echo", name: "Echo" });
+    await vi.waitFor(() =>
+      expect(f.service.find(hostedKey)?.place).toBe("hosted"),
+    );
+    // A reconnect reads its agent list again; the read is held, then fails.
+    const read = vi.mocked(f.session.read);
+    const answer = read.getMockImplementation() as NonNullable<
+      ReturnType<typeof read.getMockImplementation>
+    >;
+    let fail = () => {};
+    const listing = new Promise<never>((_, reject) => {
+      fail = () => reject(new Error("offline"));
+    });
+    let held = 0;
+    read.mockImplementation((filters, settings) => {
+      if (filters[0]?.kinds?.includes(30177)) {
+        held++;
+        return listing;
+      }
+      return answer(filters, settings);
+    });
+    f.connect(false);
+    f.connect(true);
+    await vi.waitFor(() => expect(held).toBe(1));
+    // Its config channels are up again first.
+    await vi.waitFor(() => expect(f.service.snapshot().syncsTeams).toBe(true));
+    const unread =
+      /^Can't tell yet whether npub…\w+ is in relay\.example\.test; try again shortly$/;
+    await expect(f.service.saveTeam(crew([bot, hostedKey]))).rejects.toThrow(
+      unread,
+    );
+    fail();
+    await settle();
+    await expect(f.service.saveTeam(crew([bot, hostedKey]))).rejects.toThrow(
+      unread,
+    );
+    expect(f.saveTeam).not.toHaveBeenCalled();
+    // Once a later read succeeds, the same draft takes it.
+    read.mockImplementation(answer);
+    f.connect(false);
+    f.connect(true);
+    await vi.waitFor(() => {
+      expect(f.service.find(hostedKey)?.place).toBe("hosted");
+      expect(f.service.snapshot().syncsTeams).toBe(true);
+    });
+    await f.service.saveTeam(crew([bot, hostedKey]));
+    expect(f.saveTeam).toHaveBeenCalledWith(
+      expect.objectContaining({ members: [bot, hostedKey] }),
+    );
+  });
+
   it("keeps a new team, hosted agents and all, off a relay without config channels", async () => {
     const make = vi.fn((_community: string) => null);
     coordinators.make = make;
diff --git a/src/features/agents/service.ts b/src/features/agents/service.ts
index 03d9b8761d..b3846fed15 100644
--- a/src/features/agents/service.ts
+++ b/src/features/agents/service.ts
@@ -1150,10 +1150,11 @@ export type Agents = {
    * hosted agents whose setup finished. Each community has the members that
    * are in it. */
   saveTeam(team: TeamChange): Promise<Team>;
-  /** Whether Save puts the team with `id`, or the new team `draft`, in the
-   * selected community: a synced team homed there, or a new team where it
-   * syncs. Only such a team can have that community's hosted agents. */
-  teamHere(team: Pick<TeamChange, "id" | "draft">): boolean;
+  /** Whether Save puts the team with `id`, or the new team `draft`, in
+   * `community`, by default the selected one: a synced team homed there, or a
+   * new team where it syncs. Only such a team can have that community's
+   * hosted agents. */
+  teamHere(team: Pick<TeamChange, "id" | "draft">, community?: string): boolean;
   /** Deletes the team; its agents are untouched. */
   removeTeam(id: string): Promise<void>;
 };
@@ -3741,10 +3742,14 @@ export class AgentsService extends Service implements Agents {
     return team;
   }
 
-  teamHere({ id, draft }: Pick<TeamChange, "id" | "draft">) {
-    const selected = this.selectedOrigin();
+  teamHere(
+    { id, draft }: Pick<TeamChange, "id" | "draft">,
+    community?: string,
+  ) {
+    const origin =
+      community === undefined ? this.selectedOrigin() : originOf(community);
     try {
-      return !!selected && this.teamHome(id, draft) === selected;
+      return !!origin && this.teamHome(id, draft) === origin;
     } catch {
       // Save refuses a new team while it can't tell where that syncs.
       return false;
@@ -3883,7 +3888,13 @@ export class AgentsService extends Service implements Agents {
     const outside = team.members.find(
       (pubkey) => !opened.includes(pubkey) && !members.has(pubkey),
     );
-    if (outside) throw new Error(`Add ${name(outside)} to ${host} first`);
+    // Until its agent records are read, a hosted one there isn't known.
+    if (outside)
+      throw new Error(
+        this.listings.has(home)
+          ? `Add ${name(outside)} to ${host} first`
+          : `Can't tell yet whether ${name(outside)} is in ${host}; try again shortly`,
+      );
     const config = this.communityConfigs.get(home);
     if (!config) throw new Error(`Connect to ${host} to change this team`);
     const result = await config.saveTeam({ ...team, ...extra });

From e54a39ccb2b0e85e980b82343dd66a355f22284b Mon Sep 17 00:00:00 2001
From: Matt Toohey <contact@matttoohey.com>
Date: Fri, 30 Oct 2026 00:05:27 +1100
Subject: [PATCH 13/13] fix(agents): let a hosted pick no longer listed be
 unchecked

A new team's editor kept a hosted member picked where Save puts the
team, so it wasn't lost while that community's agent records were read
again, but hid its checkbox while the agent was unlisted. Once a read
established it was gone, as when it was deleted from another device,
Save refused it with "Add <agent> to <community> first" on every try,
and nothing on the form could take it off, so the draft had to be
discarded.

The editor now remembers each hosted agent it picks, and keeps one
picked where Save puts the team among its choices while it isn't
listed. It stays checked and named in the warning, and unchecking it
leaves it off, keeping the draft. One picked in another community is
still hidden and left off.

Co-authored-by: Jitter <2b2e6415e748c35180847a37aadae06a11e30dddc76b784e7fd9354c4eb42e7a@buzz.block.builderlab.xyz>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Signed-off-by: Matt Toohey <contact@matttoohey.com>
---
 docs/agents.md                         |  7 ++--
 src/bundled/agents/AgentsPage.test.tsx | 49 +++++++++++++++++++++++---
 src/bundled/agents/AgentsPage.tsx      | 37 ++++++++++---------
 3 files changed, 69 insertions(+), 24 deletions(-)

diff --git a/docs/agents.md b/docs/agents.md
index ef07d1f7eb..5f90e3a386 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -700,9 +700,10 @@ in its home record and applies everywhere.
   offers them only for such a team, or for a new one that will sync there. One
   picked in a community Save doesn't put the team in, as when another is
   selected before a new team's first Save, is left off unless the team already
-  has it. One picked where Save puts the team stays while that community's
-  agent list is read again, but Save refuses it until the list is read. They
-  do not get its instructions, but rosters name them.
+  has it. One picked where Save puts the team stays, shown checked, while that
+  community's agent list is read again, but Save refuses it until the list is
+  read, and refuses it once the list is read without it. Unchecking it leaves
+  it off. They do not get its instructions, but rosters name them.
   Until the community's agent list is read, which tells hosted agents from
   ones on other devices, the team's roster there names each member not on this
   device by npub alone.
diff --git a/src/bundled/agents/AgentsPage.test.tsx b/src/bundled/agents/AgentsPage.test.tsx
index f432ea8a9e..2425091f83 100644
--- a/src/bundled/agents/AgentsPage.test.tsx
+++ b/src/bundled/agents/AgentsPage.test.tsx
@@ -2626,11 +2626,10 @@ it("keeps a hosted agent picked for a new team while its community lists agents
   await user.click(screen.getByRole("checkbox", { name: "Ada" }));
   await user.click(screen.getByRole("checkbox", { name: "Sky" }));
   // The community reconnects and still syncs teams, but its hosted agents
-  // are unlisted until their records are read again, so Save refuses Sky.
+  // are unlisted until their records are read again, so Save refuses Sky,
+  // which still shows checked.
   act(() => show([ada]));
-  expect(
-    screen.queryByRole("checkbox", { name: "Sky" }),
-  ).not.toBeInTheDocument();
+  expect(screen.getByRole("checkbox", { name: "Sky" })).toBeChecked();
   const refusal = "Can't tell yet whether Sky is in relay.example";
   agents.saveTeam.mockRejectedValueOnce(new Error(refusal));
   await user.click(screen.getByRole("button", { name: "Create team" }));
@@ -2643,8 +2642,9 @@ it("keeps a hosted agent picked for a new team while its community lists agents
     instructions: "",
     members: [ada.pubkey, sky.pubkey],
   });
-  // Once they are, Sky shows checked again, and Create keeps the draft.
+  // Once they are, Sky is listed again, and Create keeps the draft.
   act(() => show([ada, sky]));
+  expect(screen.getAllByRole("checkbox", { name: "Sky" })).toHaveLength(1);
   expect(screen.getByRole("checkbox", { name: "Sky" })).toBeChecked();
   await user.click(screen.getByRole("button", { name: "Create team" }));
   expect(agents.saveTeam).toHaveBeenLastCalledWith({
@@ -2655,6 +2655,45 @@ it("keeps a hosted agent picked for a new team while its community lists agents
   });
 });
 
+it("lets a hosted agent picked for a new team be unchecked once it is no longer listed", async () => {
+  const user = userEvent.setup();
+  const ada = agent("Ada", 1);
+  const sky: Agent = { ...agent("Sky", 2), place: "hosted" };
+  const { agents, show } = setup([ada, sky]);
+  await user.click(screen.getByRole("tab", { name: "Your teams" }));
+  await user.click(screen.getByRole("button", { name: "New team" }));
+  await user.click(
+    await screen.findByRole("menuitem", { name: "Create a new team" }),
+  );
+  await user.type(screen.getByRole("textbox", { name: "Name" }), "Crew");
+  await user.click(screen.getByRole("checkbox", { name: "Ada" }));
+  await user.click(screen.getByRole("checkbox", { name: "Sky" }));
+  // Sky is deleted from another device, and the community's agent list is
+  // read without it, so Save refuses it. It still shows, named in the warning.
+  act(() => show([ada]));
+  expect(
+    screen.getByRole("textbox", { name: "Instructions" }),
+  ).toHaveAccessibleDescription(
+    /\(Sky\) will not get these team instructions\.$/,
+  );
+  const refusal = "Add Sky to relay.example first";
+  agents.saveTeam.mockRejectedValueOnce(new Error(refusal));
+  await user.click(screen.getByRole("button", { name: "Create team" }));
+  const form = screen.getByRole("form", { name: "New team" });
+  expect(await within(form).findByRole("alert")).toHaveTextContent(refusal);
+  const draft = agents.saveTeam.mock.calls.at(-1)?.[0].draft;
+  // Unchecking it keeps the draft, and Create leaves it off.
+  await user.click(screen.getByRole("checkbox", { name: "Sky" }));
+  expect(screen.getByRole("checkbox", { name: "Sky" })).not.toBeChecked();
+  await user.click(screen.getByRole("button", { name: "Create team" }));
+  expect(agents.saveTeam).toHaveBeenLastCalledWith({
+    draft,
+    name: "Crew",
+    instructions: "",
+    members: [ada.pubkey],
+  });
+});
+
 it("offers an open new team hosted agents once its community is known to sync teams", async () => {
   const user = userEvent.setup();
   const { agents, change } = setup([
diff --git a/src/bundled/agents/AgentsPage.tsx b/src/bundled/agents/AgentsPage.tsx
index 8d1fc9aa19..4860d445e9 100644
--- a/src/bundled/agents/AgentsPage.tsx
+++ b/src/bundled/agents/AgentsPage.tsx
@@ -2147,27 +2147,34 @@ function TeamEditor({
   const [opened] = useState(team);
   const [draft] = useState(() => crypto.randomUUID());
   const which = opened ? { id: opened.id } : { draft };
-  // The community each hosted member was picked in, the only one with it.
-  const [picked, setPicked] = useState<ReadonlyMap<string, string>>(
+  // Each hosted agent picked, as listed then in the only community with it.
+  const [picked, setPicked] = useState<ReadonlyMap<string, Agent>>(
     () => new Map(),
   );
   // Only a team Save puts in this community can have its hosted agents.
-  const choices = agents.teamHere(which)
+  const listed = agents.teamHere(which)
     ? saved
     : saved.filter((agent) => agent.place === "here");
+  // Hosted agents picked where Save puts the team stay choices while not
+  // listed, as while its agent list is read again or once one is deleted, so
+  // each can be unchecked. Not one picked in another community, as before
+  // selecting this one, which can't have it.
+  const choices = [
+    ...listed,
+    ...[...picked.values()].filter(
+      (agent) =>
+        agents.teamHere(which, agent.relay) &&
+        !listed.some((item) => item.pubkey === agent.pubkey),
+    ),
+  ];
   // What Save gets: members among these choices, ones the team already has,
-  // agents here in other communities, and hosted agents picked where Save
-  // puts the team, which may not be listed again yet. Not one picked in
-  // another community, as before selecting this one, which can't have it.
-  const kept = members.filter((pubkey) => {
-    const from = picked.get(pubkey);
-    return (
+  // and agents here in other communities.
+  const kept = members.filter(
+    (pubkey) =>
       choices.some((agent) => agent.pubkey === pubkey) ||
       opened?.members.includes(pubkey) ||
-      agents.memberships(pubkey).length > 0 ||
-      (from !== undefined && agents.teamHere(which, from))
-    );
-  });
+      agents.memberships(pubkey).length > 0,
+  );
   // Members not in this community, which it doesn't list but keeps.
   const away = members.filter(
     (pubkey) =>
@@ -2264,9 +2271,7 @@ function TeamEditor({
                 disabled={pending}
                 onCheckedChange={(checked) => {
                   if (agent.place === "hosted")
-                    setPicked((last) =>
-                      new Map(last).set(agent.pubkey, agent.relay),
-                    );
+                    setPicked((last) => new Map(last).set(agent.pubkey, agent));
                   setMembers((last) =>
                     checked
                       ? [...last, agent.pubkey]