From 6165f8e5a421c6635315ff627fc0896916bcd1a2 Mon Sep 17 00:00:00 2001
From: Abel Dantas <abel.dantas@sbt-ext.com>
Date: Tue, 8 Sep 2026 22:03:45 +0000
Subject: [PATCH 1/5] feat(rooms-yaml): wire aliases through RoomSpec provision
 and export
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

RoomSpec gains an `aliases` field (agent name → room-scoped alias) and
provision() passes it to RoomCreateConfig so aliases are seeded at
room creation.  Export reads aliases back from the room_agents table
and emits them keyed by agent name.

CHOO-2657
---
 core/switch_core/rooms_yaml.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/core/switch_core/rooms_yaml.py b/core/switch_core/rooms_yaml.py
index 2ef5eb0da..fbb7eaa76 100644
--- a/core/switch_core/rooms_yaml.py
+++ b/core/switch_core/rooms_yaml.py
@@ -221,6 +221,7 @@ class RoomSpec(BaseModel):
     roles: list[RoleSpec] = []
     references: list[ExternalReferenceEntry] = []
     docs: list[DocSpec] = []
+    aliases: dict[str, str] | None = None
 
 
 class ProvisionResult(BaseModel):
@@ -354,6 +355,7 @@ async def provision(
             write_visibility=spec.write_visibility,
             roles=spec.roles or None,
             reference_ids=attached_ref_ids or None,
+            aliases=spec.aliases,
         )
         result = await self._rooms.create_room(config)
         room_id = result.room.id
@@ -544,13 +546,20 @@ async def export(
 
             if agents:
                 agent_ids = await self._room_store.get_agent_ids(session, room.id)
-                names: list[str] = []
+                id_to_name: dict[str, str] = {}
                 for aid in agent_ids:
                     agent = await self._agent_store.get(session, aid)
                     if agent is not None:
-                        names.append(agent.name)
-                if names:
-                    data["agents"] = sorted(names)
+                        id_to_name[aid] = agent.name
+                if id_to_name:
+                    data["agents"] = sorted(id_to_name.values())
+                alias_map = await self._room_store.list_aliases(session, room.id)
+                if alias_map:
+                    data["aliases"] = {
+                        id_to_name[aid]: alias
+                        for aid, alias in alias_map.items()
+                        if aid in id_to_name
+                    }
 
             if users and room.bridge_id:
                 client_ids = await self._room_store.get_client_ids(session, room.id)

From 27868db316456fc38aa9a273dc7974cd48d79490 Mon Sep 17 00:00:00 2001
From: Abel Dantas <abel.dantas@sbt-ext.com>
Date: Tue, 8 Sep 2026 22:09:27 +0000
Subject: [PATCH 2/5] feat(rooms-yaml): add group document shape and
 provision_group

Introduces a second document shape discriminated by a top-level `group:`
key (vs `room:` for single-room). A group document declares a room group
(name, description, optional color), a list of rooms (`rooms:`), and
optional directed links between them (`links:`). Params are interpolated
across the entire document before validation.

`provision_group()` creates the group row first, then each room with
`group_id` set, then resolves intra-document links by room name. Partial
failure on a room is reported (not rolled back), matching the existing
single-room precedent.

The `/rooms/from-yaml` endpoint accepts either shape and returns
`ProvisionResult` or `GroupProvisionResult` accordingly.

CHOO-2657
---
 core/switch_core/gateway/dependencies.py  |   1 +
 core/switch_core/gateway/rooms.py         |  25 +-
 core/switch_core/rooms_yaml.py            | 289 ++++++++++++++++++++--
 core/tests/switch_core/test_rooms_yaml.py |   2 +
 4 files changed, 288 insertions(+), 29 deletions(-)

diff --git a/core/switch_core/gateway/dependencies.py b/core/switch_core/gateway/dependencies.py
index 5858cdab3..19d6e1681 100644
--- a/core/switch_core/gateway/dependencies.py
+++ b/core/switch_core/gateway/dependencies.py
@@ -87,6 +87,7 @@ def get_room_yaml_service() -> RoomYamlService:
         agent_store=_state["agent_store"],
         bridge_store=_state["bridge_store"],
         external_user_store=_state["external_user_store"],
+        room_group_store=_state["room_group_store"],
         room_role_store=protocol.room_role_store,
         session_factory=_state["session_factory"],
     )
diff --git a/core/switch_core/gateway/rooms.py b/core/switch_core/gateway/rooms.py
index 061b6faeb..33f7e25ea 100644
--- a/core/switch_core/gateway/rooms.py
+++ b/core/switch_core/gateway/rooms.py
@@ -52,7 +52,12 @@
     RoomUsersRequest,
 )
 from switch_core.room_service import RoleSpec, RoomCreateConfig, RoomService
-from switch_core.rooms_yaml import ProvisionResult, RoomYamlService
+from switch_core.rooms_yaml import (
+    GroupProvisionResult,
+    GroupSpec,
+    ProvisionResult,
+    RoomYamlService,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -373,8 +378,13 @@ async def create_room_from_yaml(
     request: Request,
     rooms_yaml: Annotated[RoomYamlService, Depends(get_room_yaml_service)],
     user: Annotated[User, Depends(get_current_user)],
-) -> ProvisionResult:
-    """Provision a single room and its attachments from a YAML spec.
+) -> ProvisionResult | GroupProvisionResult:
+    """Provision room(s) from a YAML spec.
+
+    The document shape determines the result: a ``room:`` document provisions
+    a single room (returns ``ProvisionResult``); a ``group:`` + ``rooms:``
+    document provisions a room group with its rooms and links (returns
+    ``GroupProvisionResult``).
 
     Two content types are accepted:
 
@@ -399,9 +409,12 @@ async def create_room_from_yaml(
             text = (await request.body()).decode("utf-8")
             inputs = None
         spec = rooms_yaml.parse(text, inputs=inputs)
-        return await rooms_yaml.provision(
-            spec, user_id=user.id, is_admin=user.role == "admin"
-        )
+        is_admin = user.role == "admin"
+        if isinstance(spec, GroupSpec):
+            return await rooms_yaml.provision_group(
+                spec, user_id=user.id, is_admin=is_admin
+            )
+        return await rooms_yaml.provision(spec, user_id=user.id, is_admin=is_admin)
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e)) from e
     except PermissionError as e:
diff --git a/core/switch_core/rooms_yaml.py b/core/switch_core/rooms_yaml.py
index fbb7eaa76..9fbbc02d9 100644
--- a/core/switch_core/rooms_yaml.py
+++ b/core/switch_core/rooms_yaml.py
@@ -1,19 +1,19 @@
-"""Declarative provisioning of a single room from YAML, and export back.
+"""Declarative provisioning of rooms from YAML, and export back.
 
-v0 supports a ``params:`` block beside ``room:`` that declares typed,
-defaultable placeholders. ``parse(text, inputs)`` resolves them and
-interpolates ``{name}`` throughout the ``room:`` tree before validation, so
-one file can stamp out many rooms with different inputs.  A literal
-``{word}`` that collides with a declared param name *is* substituted — this
-is accepted for v0; ``sensitive: true`` is deferred to a later version.
+Two document shapes are supported, discriminated by top-level key:
 
-An optional top-level ``version:`` key (default ``0``) is accepted and
-validated as an integer, but not acted on yet.
+* **Single-room** (``room:`` key): provisions one room with its attachments.
+* **Group** (``group:`` + ``rooms:`` keys): provisions a room group, several
+  rooms filed under it, and optional directed links between them.
 
-Provisioning is room-first and best-effort: the room is created first (which
-fails loud on bad agents / refs / config), then inline references and docs are
-attached, with any post-creation failures collected into ``failed_attachments``
-rather than silently dropped.
+Both shapes accept a ``params:`` block and an optional ``version:`` key.
+``parse(text, inputs)`` resolves params and interpolates ``{name}``
+throughout the document tree before validation.  A literal ``{word}`` that
+collides with a declared param name *is* substituted — this is accepted for
+v0; ``sensitive: true`` is deferred to a later version.
+
+Provisioning is best-effort: rooms are created in order, and a failure on one
+room does not roll back earlier ones — partial results are reported honestly.
 
 Export emits resolved rooms and never emits ``params:``.
 """
@@ -40,6 +40,7 @@
         CollaborationBridgeStore,
     )
     from switch_core.db.stores.external_user_store import ExternalUserStore
+    from switch_core.db.stores.room_group_store import RoomGroupStore
     from switch_core.db.stores.room_role_store import RoomRoleStore
     from switch_core.db.stores.room_store import RoomStore
     from switch_core.room_service import RoomService
@@ -234,6 +235,44 @@ class ProvisionResult(BaseModel):
     failed_attachments: list[dict[str, Any]] = []
 
 
+# ── Group document models ────────────────────────────────────────────────
+
+
+class GroupLinkSpec(BaseModel):
+    model_config = {"extra": "forbid"}
+    from_: str  # room name within the document
+    to: str
+    label: str
+
+    @model_validator(mode="before")
+    @classmethod
+    def _rename_from(cls, data: Any) -> Any:
+        """Accept ``from`` in YAML (a Python keyword) as ``from_``."""
+        if isinstance(data, dict) and "from" in data:
+            data = {**data, "from_": data.pop("from")}
+        return data
+
+
+class GroupMeta(BaseModel):
+    model_config = {"extra": "forbid"}
+    name: str
+    description: str | None = None
+    color: str | None = None
+
+
+class GroupSpec(BaseModel):
+    group: GroupMeta
+    rooms: list[RoomSpec]
+    links: list[GroupLinkSpec] = []
+
+
+class GroupProvisionResult(BaseModel):
+    group_id: str
+    group_name: str
+    rooms: list[ProvisionResult] = []
+    errors: list[dict[str, Any]] = []
+
+
 # ── YAML literal-block dumper (keeps multiline doc content readable) ────────
 
 
@@ -250,7 +289,7 @@ def _str_representer(dumper: yaml.SafeDumper, data: str) -> Any:
 
 
 class RoomYamlService:
-    """Parse / provision / export a single room as YAML. Free of HTTP concerns
+    """Parse / provision / export rooms from YAML. Free of HTTP concerns
     so it is unit-testable and reusable for future MCP / CLI surfaces."""
 
     def __init__(
@@ -262,6 +301,7 @@ def __init__(
         agent_store: AgentStore,
         bridge_store: CollaborationBridgeStore,
         external_user_store: ExternalUserStore,
+        room_group_store: RoomGroupStore,
         room_role_store: RoomRoleStore,
         session_factory: async_sessionmaker[AsyncSession],
     ) -> None:
@@ -271,25 +311,33 @@ def __init__(
         self._agent_store = agent_store
         self._bridge_store = bridge_store
         self._external_users = external_user_store
+        self._room_groups = room_group_store
         self._room_roles = room_role_store
         self._session_factory = session_factory
 
     # ── Parse ─────────────────────────────────────────────────────────────
 
-    def parse(self, text: str, inputs: dict[str, Any] | None = None) -> RoomSpec:
+    @staticmethod
+    def _load_and_resolve(
+        text: str,
+        inputs: dict[str, Any] | None,
+        allowed_keys: set[str],
+    ) -> dict[str, Any]:
+        """YAML load → version check → params resolution → interpolation.
+
+        Returns the top-level dict with string values already interpolated.
+        """
         try:
             data = yaml.safe_load(text)
         except yaml.YAMLError as e:
             raise ValueError(f"Invalid YAML: {e}") from e
-        if not isinstance(data, dict) or "room" not in data:
-            raise ValueError("YAML must have a single top-level 'room:' mapping")
+        if not isinstance(data, dict):
+            raise ValueError("YAML document must be a mapping")
 
-        allowed_keys = {"room", "params", "version"}
         extra = set(data) - allowed_keys
         if extra:
             raise ValueError(f"Unknown top-level key(s): {', '.join(sorted(extra))}")
 
-        # version: accepted, not acted on yet.
         version = data.get("version", 0)
         if not isinstance(version, int):
             raise ValueError(
@@ -314,15 +362,76 @@ def parse(self, text: str, inputs: dict[str, Any] | None = None) -> RoomSpec:
 
         if declared:
             values = resolve_params(declared, inputs)
-            room_data = interpolate(data["room"], values)
-        else:
-            room_data = data["room"]
+            return {k: interpolate(v, values) for k, v in data.items()}
+        return data
+
+    def parse(
+        self, text: str, inputs: dict[str, Any] | None = None
+    ) -> RoomSpec | GroupSpec:
+        """Parse a YAML template into a RoomSpec (single room) or GroupSpec.
+
+        The top-level key discriminates: ``room:`` → RoomSpec, ``group:`` +
+        ``rooms:`` → GroupSpec.
+        """
+        try:
+            raw = yaml.safe_load(text)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML: {e}") from e
+        if not isinstance(raw, dict):
+            raise ValueError("YAML document must be a mapping")
 
+        if "group" in raw:
+            return self._parse_group(text, inputs)
+        if "room" in raw:
+            return self._parse_room(text, inputs)
+        raise ValueError("YAML must have a top-level 'room:' or 'group:' mapping")
+
+    def _parse_room(self, text: str, inputs: dict[str, Any] | None = None) -> RoomSpec:
+        data = self._load_and_resolve(text, inputs, {"room", "params", "version"})
         try:
-            return RoomSpec.model_validate(room_data)
+            return RoomSpec.model_validate(data["room"])
         except ValidationError as e:
             raise ValueError(f"Invalid room spec: {e}") from e
 
+    def _parse_group(
+        self, text: str, inputs: dict[str, Any] | None = None
+    ) -> GroupSpec:
+        data = self._load_and_resolve(
+            text, inputs, {"group", "rooms", "links", "params", "version"}
+        )
+        if "rooms" not in data:
+            raise ValueError("Group document requires a 'rooms:' list")
+        try:
+            group_meta = GroupMeta.model_validate(data["group"])
+        except ValidationError as e:
+            raise ValueError(f"Invalid group spec: {e}") from e
+        raw_rooms = data["rooms"]
+        if not isinstance(raw_rooms, list) or not raw_rooms:
+            raise ValueError("'rooms:' must be a non-empty list")
+        rooms: list[RoomSpec] = []
+        for i, entry in enumerate(raw_rooms):
+            try:
+                rooms.append(RoomSpec.model_validate(entry))
+            except ValidationError as e:
+                raise ValueError(f"Invalid room spec at index {i}: {e}") from e
+        raw_links = data.get("links", [])
+        if not isinstance(raw_links, list):
+            raise ValueError("'links:' must be a list")
+        links: list[GroupLinkSpec] = []
+        for i, entry in enumerate(raw_links):
+            try:
+                links.append(GroupLinkSpec.model_validate(entry))
+            except ValidationError as e:
+                raise ValueError(f"Invalid link spec at index {i}: {e}") from e
+        room_names = {r.name for r in rooms}
+        for link in links:
+            for end, name in [("from", link.from_), ("to", link.to)]:
+                if name not in room_names:
+                    raise ValueError(
+                        f"Link {end} {name!r} does not match any room name"
+                    )
+        return GroupSpec(group=group_meta, rooms=rooms, links=links)
+
     # ── Provision ───────────────────────────────────────────────────────────
 
     async def provision(
@@ -378,6 +487,140 @@ async def provision(
             failed_attachments=failures,
         )
 
+    async def provision_group(
+        self, spec: GroupSpec, *, user_id: str, is_admin: bool
+    ) -> GroupProvisionResult:
+        """Provision a room group, its rooms, and resolve intra-document links.
+
+        Order: group row → each room with ``group_id`` → links by name.
+        Partial failure on a room is reported, not rolled back.
+        """
+        async with self._session_factory() as session:
+            group = await self._room_groups.create(
+                session,
+                name=spec.group.name,
+                description=spec.group.description,
+                color=spec.group.color,
+                parent_group_id=None,
+            )
+            await session.commit()
+            group_id = group.id
+
+        room_results: list[ProvisionResult] = []
+        errors: list[dict[str, Any]] = []
+        name_to_room_id: dict[str, str] = {}
+
+        for i, room_spec in enumerate(spec.rooms):
+            try:
+                result = await self._provision_room_in_group(
+                    room_spec, group_id=group_id, user_id=user_id, is_admin=is_admin
+                )
+                room_results.append(result)
+                name_to_room_id[room_spec.name] = result.room_id
+            except Exception as e:
+                errors.append(
+                    {"room_index": i, "room_name": room_spec.name, "error": str(e)}
+                )
+
+        for link in spec.links:
+            from_id = name_to_room_id.get(link.from_)
+            to_id = name_to_room_id.get(link.to)
+            if from_id is None or to_id is None:
+                errors.append(
+                    {
+                        "kind": "link",
+                        "from": link.from_,
+                        "to": link.to,
+                        "error": "one or both rooms were not created",
+                    }
+                )
+                continue
+            try:
+                async with self._session_factory() as session:
+                    await self._resources.attach_linked_room(
+                        session,
+                        source_room_id=from_id,
+                        target_room_id=to_id,
+                        label=link.label,
+                    )
+                    await session.commit()
+            except Exception as e:
+                errors.append(
+                    {
+                        "kind": "link",
+                        "from": link.from_,
+                        "to": link.to,
+                        "error": str(e),
+                    }
+                )
+
+        return GroupProvisionResult(
+            group_id=group_id,
+            group_name=spec.group.name,
+            rooms=room_results,
+            errors=errors,
+        )
+
+    async def _provision_room_in_group(
+        self,
+        spec: RoomSpec,
+        *,
+        group_id: str,
+        user_id: str,
+        is_admin: bool,
+    ) -> ProvisionResult:
+        """Provision a single room with ``group_id`` set."""
+        bridge_id = await self._resolve_bridge_id(spec.bridge)
+        if spec.users and bridge_id is None:
+            raise ValueError(
+                "Cannot attach users to a room with no bridge "
+                "(users live on a collaboration bridge)"
+            )
+
+        attached_ref_ids, inline_refs = await self._resolve_references(
+            spec.references, user_id=user_id, is_admin=is_admin
+        )
+
+        config = RoomCreateConfig(
+            name=spec.name,
+            description=spec.description,
+            instructions=spec.instructions,
+            channel_type=cast(ChannelType, spec.channel_type),
+            agent_names=spec.agents or None,
+            user_names=spec.users or None,
+            bridge_id=bridge_id,
+            group_id=group_id,
+            created_by=user_id,
+            owner_id=user_id,
+            acting_user_id=user_id,
+            acting_is_admin=is_admin,
+            read_visibility=spec.read_visibility,
+            write_visibility=spec.write_visibility,
+            roles=spec.roles or None,
+            reference_ids=attached_ref_ids or None,
+            aliases=spec.aliases,
+        )
+        result = await self._rooms.create_room(config)
+        room_id = result.room.id
+        failures: list[dict[str, Any]] = list(result.failed_attachments)
+
+        created_ref_ids = await self._create_inline_references(
+            room_id, inline_refs, user_id=user_id, is_admin=is_admin, failures=failures
+        )
+        created_doc_ids = await self._create_inline_docs(
+            room_id, spec.docs, user_id=user_id, failures=failures
+        )
+
+        return ProvisionResult(
+            room_id=room_id,
+            room_name=result.room.name,
+            attached_reference_ids=attached_ref_ids,
+            created_reference_ids=created_ref_ids,
+            created_document_ids=created_doc_ids,
+            role_names=[r.name for r in spec.roles],
+            failed_attachments=failures,
+        )
+
     async def _resolve_bridge_id(self, bridge_name: str | None) -> str | None:
         if bridge_name is None:
             return None
diff --git a/core/tests/switch_core/test_rooms_yaml.py b/core/tests/switch_core/test_rooms_yaml.py
index 064c5f461..355ea94d7 100644
--- a/core/tests/switch_core/test_rooms_yaml.py
+++ b/core/tests/switch_core/test_rooms_yaml.py
@@ -40,6 +40,7 @@
 from switch_core.db.stores.package_store import PackageStore
 from switch_core.db.stores.reference_store import ReferenceStore
 from switch_core.db.stores.reference_type_store import ReferenceTypeStore
+from switch_core.db.stores.room_group_store import RoomGroupStore
 from switch_core.db.stores.room_link_store import RoomLinkStore
 from switch_core.db.stores.room_role_store import RoomRoleStore
 from switch_core.db.stores.room_store import RoomStore
@@ -163,6 +164,7 @@ async def env(session_factory: async_sessionmaker[AsyncSession]):
         agent_store=agent_store,
         bridge_store=CollaborationBridgeStore(),
         external_user_store=ExternalUserStore(),
+        room_group_store=RoomGroupStore(),
         room_role_store=RoomRoleStore(),
         session_factory=session_factory,
     )

From e2302e918656c903a3369a19a1e36e782759cb42 Mon Sep 17 00:00:00 2001
From: Abel Dantas <abel.dantas@sbt-ext.com>
Date: Tue, 8 Sep 2026 22:14:26 +0000
Subject: [PATCH 3/5] feat(rooms-yaml): interpolate dict keys, tests for group
 templates
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extend `interpolate()` to substitute placeholders in dict keys (not
just values), so alias maps like `{bot}: greeter` resolve when the
agent name comes from a param — the onboarder's actual need.

Adds 12 tests covering group parsing (shape, params across rooms,
alias key interpolation, validation errors), group provisioning
(two-room linked group, params across rooms, partial failure on bad
agent), single-room regression, and the /from-yaml endpoint handling
a group document.

CHOO-2657
---
 core/switch_core/rooms_yaml.py            |  16 +-
 core/tests/switch_core/test_rooms_yaml.py | 276 ++++++++++++++++++++++
 2 files changed, 280 insertions(+), 12 deletions(-)

diff --git a/core/switch_core/rooms_yaml.py b/core/switch_core/rooms_yaml.py
index 9fbbc02d9..b268fcbc8 100644
--- a/core/switch_core/rooms_yaml.py
+++ b/core/switch_core/rooms_yaml.py
@@ -25,7 +25,7 @@
 from typing import TYPE_CHECKING, Any, Literal, cast
 
 import yaml
-from pydantic import BaseModel, ValidationError, model_validator
+from pydantic import BaseModel, Field, ValidationError, model_validator
 
 from switch_core.bridges.collaboration.models import ChannelType
 from switch_core.bridges.resource.registry import validate_reference_value
@@ -144,7 +144,7 @@ def _replace(m: re.Match[str]) -> str:
 
         return PLACEHOLDER_RE.sub(_replace, node)
     if isinstance(node, dict):
-        return {k: interpolate(v, values) for k, v in node.items()}
+        return {interpolate(k, values): interpolate(v, values) for k, v in node.items()}
     if isinstance(node, list):
         return [interpolate(item, values) for item in node]
     return node
@@ -239,19 +239,11 @@ class ProvisionResult(BaseModel):
 
 
 class GroupLinkSpec(BaseModel):
-    model_config = {"extra": "forbid"}
-    from_: str  # room name within the document
+    model_config = {"extra": "forbid", "populate_by_name": True}
+    from_: str = Field(alias="from")
     to: str
     label: str
 
-    @model_validator(mode="before")
-    @classmethod
-    def _rename_from(cls, data: Any) -> Any:
-        """Accept ``from`` in YAML (a Python keyword) as ``from_``."""
-        if isinstance(data, dict) and "from" in data:
-            data = {**data, "from_": data.pop("from")}
-        return data
-
 
 class GroupMeta(BaseModel):
     model_config = {"extra": "forbid"}
diff --git a/core/tests/switch_core/test_rooms_yaml.py b/core/tests/switch_core/test_rooms_yaml.py
index 355ea94d7..67a1e7d07 100644
--- a/core/tests/switch_core/test_rooms_yaml.py
+++ b/core/tests/switch_core/test_rooms_yaml.py
@@ -28,6 +28,8 @@
     Reference,
     ReferenceType,
     Room,
+    RoomGroup,
+    RoomLink,
     RoomRole,
     User,
     room_agents,
@@ -47,6 +49,7 @@
 from switch_core.room_service import RoomCreateConfig, RoomCreateResult
 from switch_core.rooms_yaml import (
     ExistingReferenceById,
+    GroupSpec,
     ParamSpec,
     RoomYamlService,
     interpolate,
@@ -92,6 +95,7 @@ async def create_room(self, config: RoomCreateConfig) -> RoomCreateResult:
                 owner_id=config.owner_id,
                 read_visibility=config.read_visibility,
                 write_visibility=config.write_visibility,
+                group_id=config.group_id,
             )
             session.add(room)
             await session.flush()
@@ -1082,3 +1086,275 @@ async def test_endpoint_json_body(env):
     with pytest.raises(HTTPException) as exc_info:
         await create_room_from_yaml(request, svc, user)
     assert exc_info.value.status_code == 400
+
+
+# ── group parse ─────────────────────────────────────────────────────────────
+
+
+GROUP_TEMPLATE = """\
+version: 0
+params:
+  newcomer:
+    type: string
+group:
+  name: "Onboarding"
+  description: "Lobby + per-person workroom"
+  color: "#3b82f6"
+rooms:
+  - name: "{newcomer} lobby"
+    description: "Welcome room for {newcomer}"
+    agents: ["claude-code.alice"]
+    aliases:
+      claude-code.alice: greeter
+  - name: "{newcomer} workroom"
+    description: "Work room for {newcomer}"
+    agents: ["claude-code.bob"]
+links:
+  - from: "{newcomer} lobby"
+    to: "{newcomer} workroom"
+    label: workroom
+"""
+
+
+def test_parse_group_returns_group_spec(env):
+    spec = _svc(env).parse(GROUP_TEMPLATE, inputs={"newcomer": "dana"})
+    assert isinstance(spec, GroupSpec)
+    assert spec.group.name == "Onboarding"
+    assert spec.group.color == "#3b82f6"
+    assert len(spec.rooms) == 2
+    assert spec.rooms[0].name == "dana lobby"
+    assert spec.rooms[1].name == "dana workroom"
+    assert len(spec.links) == 1
+    assert spec.links[0].from_ == "dana lobby"
+    assert spec.links[0].to == "dana workroom"
+
+
+def test_parse_group_params_interpolate_aliases(env):
+    template = """\
+params:
+  bot:
+    type: string
+group:
+  name: "G"
+rooms:
+  - name: "R"
+    description: "d"
+    agents: ["{bot}"]
+    aliases:
+      "{bot}": helper
+"""
+    spec = _svc(env).parse(template, inputs={"bot": "claude-code.alice"})
+    assert isinstance(spec, GroupSpec)
+    assert spec.rooms[0].aliases == {"claude-code.alice": "helper"}
+
+
+def test_parse_group_missing_rooms_key(env):
+    with pytest.raises(ValueError, match="'rooms:'"):
+        _svc(env).parse(
+            """
+            group:
+              name: "G"
+            """
+        )
+
+
+def test_parse_group_empty_rooms_list(env):
+    with pytest.raises(ValueError, match="non-empty"):
+        _svc(env).parse(
+            """
+            group:
+              name: "G"
+            rooms: []
+            """
+        )
+
+
+def test_parse_group_link_bad_name(env):
+    with pytest.raises(ValueError, match="does not match"):
+        _svc(env).parse(
+            """
+            group:
+              name: "G"
+            rooms:
+              - name: "A"
+                description: "d"
+            links:
+              - from: "A"
+                to: "B"
+                label: "x"
+            """
+        )
+
+
+def test_parse_group_unknown_top_level_key(env):
+    with pytest.raises(ValueError, match="Unknown top-level"):
+        _svc(env).parse(
+            """
+            group:
+              name: "G"
+            rooms:
+              - name: "A"
+                description: "d"
+            extra: bad
+            """
+        )
+
+
+# ── group provision ──────────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_provision_group_two_rooms_linked(env):
+    """The onboarder-shaped template imports in one call: both rooms exist,
+    grouped together, linked to each other."""
+    svc = _svc(env)
+    spec = svc.parse(GROUP_TEMPLATE, inputs={"newcomer": "dana"})
+    assert isinstance(spec, GroupSpec)
+
+    result = await svc.provision_group(spec, user_id=env["user_id"], is_admin=False)
+
+    assert result.group_name == "Onboarding"
+    assert len(result.rooms) == 2
+    assert result.rooms[0].room_name == "dana lobby"
+    assert result.rooms[1].room_name == "dana workroom"
+    assert result.errors == []
+
+    # Both rooms filed under the same group.
+    sf = env["session_factory"]
+    async with sf() as session:
+        group = await session.get(RoomGroup, result.group_id)
+        assert group is not None
+        assert group.name == "Onboarding"
+        assert group.color == "#3b82f6"
+
+        for rr in result.rooms:
+            room = await session.get(Room, rr.room_id)
+            assert room is not None
+            assert room.group_id == result.group_id
+
+        # Link exists from lobby → workroom.
+        link = await session.get(
+            RoomLink,
+            (result.rooms[0].room_id, result.rooms[1].room_id),
+        )
+        assert link is not None
+        assert link.label == "workroom"
+
+
+@pytest.mark.asyncio
+async def test_provision_group_params_across_rooms(env):
+    """Params interpolate across the whole document from one inputs dict."""
+    svc = _svc(env)
+    spec = svc.parse(GROUP_TEMPLATE, inputs={"newcomer": "eve"})
+    assert isinstance(spec, GroupSpec)
+    result = await svc.provision_group(spec, user_id=env["user_id"], is_admin=False)
+
+    assert result.rooms[0].room_name == "eve lobby"
+    assert result.rooms[1].room_name == "eve workroom"
+
+
+@pytest.mark.asyncio
+async def test_provision_group_partial_failure_collision(env):
+    """When the second room name collides, group + first room exist and the
+    error names the collision."""
+    svc = _svc(env)
+
+    # Provision once to create "dana lobby".
+    spec1 = svc.parse(GROUP_TEMPLATE, inputs={"newcomer": "dana"})
+    assert isinstance(spec1, GroupSpec)
+    await svc.provision_group(spec1, user_id=env["user_id"], is_admin=False)
+
+    # Build a group whose second room collides with an existing name.
+    collision_template = """\
+group:
+  name: "Collider"
+rooms:
+  - name: "safe room"
+    description: "d"
+    agents: ["claude-code.alice"]
+  - name: "dana lobby"
+    description: "d"
+    agents: ["claude-code.bob"]
+"""
+    spec2 = svc.parse(collision_template)
+    assert isinstance(spec2, GroupSpec)
+
+    # FakeRoomService doesn't enforce unique names, so we need to pre-create
+    # the collision. Instead, make the second room reference an unknown agent.
+    collision_template_bad_agent = """\
+group:
+  name: "Collider"
+rooms:
+  - name: "safe room"
+    description: "d"
+    agents: ["claude-code.alice"]
+  - name: "boom room"
+    description: "d"
+    agents: ["does-not-exist"]
+"""
+    spec3 = svc.parse(collision_template_bad_agent)
+    assert isinstance(spec3, GroupSpec)
+    result = await svc.provision_group(spec3, user_id=env["user_id"], is_admin=False)
+
+    # Group + first room exist, second room errored.
+    assert result.group_name == "Collider"
+    assert len(result.rooms) == 1
+    assert result.rooms[0].room_name == "safe room"
+    assert len(result.errors) == 1
+    assert result.errors[0]["room_name"] == "boom room"
+    assert "does-not-exist" in result.errors[0]["error"]
+
+    # Verify the group row was created.
+    sf = env["session_factory"]
+    async with sf() as session:
+        group = await session.get(RoomGroup, result.group_id)
+        assert group is not None
+
+
+# ── single-room regression ──────────────────────────────────────────────────
+
+
+def test_single_room_parse_still_works(env):
+    """Single-room documents keep working unchanged after adding group support."""
+    spec = _svc(env).parse(
+        """
+        room:
+          name: "Room A"
+          description: "desc"
+        """
+    )
+    assert spec.name == "Room A"
+
+
+def test_parse_rejects_neither_room_nor_group(env):
+    with pytest.raises(ValueError, match="'room:' or 'group:'"):
+        _svc(env).parse("name: oops\ndescription: d\n")
+
+
+@pytest.mark.asyncio
+async def test_endpoint_json_body_group(env):
+    """The /from-yaml endpoint handles a group document."""
+    import json
+    from unittest.mock import AsyncMock
+
+    from switch_core.gateway.rooms import create_room_from_yaml
+
+    svc = _svc(env)
+    user_id = env["user_id"]
+    user = User(name="alice", email="alice@example.com", role="member")
+    object.__setattr__(user, "id", user_id)
+
+    body = json.dumps(
+        {
+            "yaml": GROUP_TEMPLATE,
+            "inputs": {"newcomer": "frank"},
+        }
+    ).encode()
+
+    request = AsyncMock()
+    request.headers = {"content-type": "application/json"}
+    request.body.return_value = body
+
+    result = await create_room_from_yaml(request, svc, user)
+    assert result.group_name == "Onboarding"
+    assert len(result.rooms) == 2

From 0fe8785b7971b2d852a850b9e82e7315fe3f015e Mon Sep 17 00:00:00 2001
From: Abel Dantas <abel.dantas@sbt-ext.com>
Date: Tue, 8 Sep 2026 22:31:12 +0000
Subject: [PATCH 4/5] fix(rooms-yaml): reject duplicate room names in group,
 remove provision duplication
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Catch duplicate room names at parse time — a set collision would let
links silently point to the wrong room. Also collapses
_provision_room_in_group into provision() via an optional group_id
parameter, removing ~55 lines of duplication.

CHOO-2657
---
 core/switch_core/rooms_yaml.py            | 79 +++++------------------
 core/tests/switch_core/test_rooms_yaml.py | 15 +++++
 2 files changed, 31 insertions(+), 63 deletions(-)

diff --git a/core/switch_core/rooms_yaml.py b/core/switch_core/rooms_yaml.py
index b268fcbc8..fefe1b8d7 100644
--- a/core/switch_core/rooms_yaml.py
+++ b/core/switch_core/rooms_yaml.py
@@ -416,6 +416,10 @@ def _parse_group(
             except ValidationError as e:
                 raise ValueError(f"Invalid link spec at index {i}: {e}") from e
         room_names = {r.name for r in rooms}
+        if len(room_names) != len(rooms):
+            seen: set[str] = set()
+            dupes = [r.name for r in rooms if r.name in seen or seen.add(r.name)]  # type: ignore[func-returns-value]
+            raise ValueError(f"Duplicate room name(s): {', '.join(dupes)}")
         for link in links:
             for end, name in [("from", link.from_), ("to", link.to)]:
                 if name not in room_names:
@@ -427,7 +431,12 @@ def _parse_group(
     # ── Provision ───────────────────────────────────────────────────────────
 
     async def provision(
-        self, spec: RoomSpec, *, user_id: str, is_admin: bool
+        self,
+        spec: RoomSpec,
+        *,
+        user_id: str,
+        is_admin: bool,
+        group_id: str | None = None,
     ) -> ProvisionResult:
         bridge_id = await self._resolve_bridge_id(spec.bridge)
         if spec.users and bridge_id is None:
@@ -448,6 +457,7 @@ async def provision(
             agent_names=spec.agents or None,
             user_names=spec.users or None,
             bridge_id=bridge_id,
+            group_id=group_id,
             created_by=user_id,
             owner_id=user_id,
             acting_user_id=user_id,
@@ -504,8 +514,11 @@ async def provision_group(
 
         for i, room_spec in enumerate(spec.rooms):
             try:
-                result = await self._provision_room_in_group(
-                    room_spec, group_id=group_id, user_id=user_id, is_admin=is_admin
+                result = await self.provision(
+                    room_spec,
+                    user_id=user_id,
+                    is_admin=is_admin,
+                    group_id=group_id,
                 )
                 room_results.append(result)
                 name_to_room_id[room_spec.name] = result.room_id
@@ -553,66 +566,6 @@ async def provision_group(
             errors=errors,
         )
 
-    async def _provision_room_in_group(
-        self,
-        spec: RoomSpec,
-        *,
-        group_id: str,
-        user_id: str,
-        is_admin: bool,
-    ) -> ProvisionResult:
-        """Provision a single room with ``group_id`` set."""
-        bridge_id = await self._resolve_bridge_id(spec.bridge)
-        if spec.users and bridge_id is None:
-            raise ValueError(
-                "Cannot attach users to a room with no bridge "
-                "(users live on a collaboration bridge)"
-            )
-
-        attached_ref_ids, inline_refs = await self._resolve_references(
-            spec.references, user_id=user_id, is_admin=is_admin
-        )
-
-        config = RoomCreateConfig(
-            name=spec.name,
-            description=spec.description,
-            instructions=spec.instructions,
-            channel_type=cast(ChannelType, spec.channel_type),
-            agent_names=spec.agents or None,
-            user_names=spec.users or None,
-            bridge_id=bridge_id,
-            group_id=group_id,
-            created_by=user_id,
-            owner_id=user_id,
-            acting_user_id=user_id,
-            acting_is_admin=is_admin,
-            read_visibility=spec.read_visibility,
-            write_visibility=spec.write_visibility,
-            roles=spec.roles or None,
-            reference_ids=attached_ref_ids or None,
-            aliases=spec.aliases,
-        )
-        result = await self._rooms.create_room(config)
-        room_id = result.room.id
-        failures: list[dict[str, Any]] = list(result.failed_attachments)
-
-        created_ref_ids = await self._create_inline_references(
-            room_id, inline_refs, user_id=user_id, is_admin=is_admin, failures=failures
-        )
-        created_doc_ids = await self._create_inline_docs(
-            room_id, spec.docs, user_id=user_id, failures=failures
-        )
-
-        return ProvisionResult(
-            room_id=room_id,
-            room_name=result.room.name,
-            attached_reference_ids=attached_ref_ids,
-            created_reference_ids=created_ref_ids,
-            created_document_ids=created_doc_ids,
-            role_names=[r.name for r in spec.roles],
-            failed_attachments=failures,
-        )
-
     async def _resolve_bridge_id(self, bridge_name: str | None) -> str | None:
         if bridge_name is None:
             return None
diff --git a/core/tests/switch_core/test_rooms_yaml.py b/core/tests/switch_core/test_rooms_yaml.py
index 67a1e7d07..dcf0c1fff 100644
--- a/core/tests/switch_core/test_rooms_yaml.py
+++ b/core/tests/switch_core/test_rooms_yaml.py
@@ -1169,6 +1169,21 @@ def test_parse_group_empty_rooms_list(env):
         )
 
 
+def test_parse_group_duplicate_room_names(env):
+    with pytest.raises(ValueError, match="Duplicate room name"):
+        _svc(env).parse(
+            """
+            group:
+              name: "G"
+            rooms:
+              - name: "lobby"
+                description: "d"
+              - name: "lobby"
+                description: "d2"
+            """
+        )
+
+
 def test_parse_group_link_bad_name(env):
     with pytest.raises(ValueError, match="does not match"):
         _svc(env).parse(

From 02e2e0e484f32c7f23194ac949586c4e207ded55 Mon Sep 17 00:00:00 2001
From: Abel Dantas <dantas.abel@gmail.com>
Date: Fri, 11 Sep 2026 15:22:46 +0100
Subject: [PATCH 5/5] feat(agent-ops): add create_room_from_yaml operation
 (#413)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(rooms-yaml): add typed params block and {var} interpolation

Add ParamSpec model, resolve_params() and interpolate() helpers to
rooms_yaml.py.  parse() now accepts an optional `inputs` dict and an
optional top-level `params:` sibling of `room:`.  Declared placeholders
are substituted throughout the room tree before Pydantic validation;
whole-field placeholders preserve the typed value so enum/boolean params
fill non-string fields correctly.  Undeclared {word} patterns are left
intact.

Also accepts an optional top-level `version:` key (default 0).

26 new tests covering resolve_params, interpolate, and parse-with-params
(defaults, overrides, missing required, undeclared input, unknown
placeholder passthrough, whole-field typed substitution, nested
docs/references interpolation, version key).

* feat(gateway): accept JSON body with inputs on /rooms/from-yaml

The endpoint now checks Content-Type: when application/json, it expects
{"yaml": "<template>", "inputs": {...}} and passes inputs through to
parse().  Raw YAML body (any other content type) still works for
defaults-only templates.

Adds integration tests: two-room instantiation with different owners,
missing-required-param rejection, and an endpoint test exercising the
JSON path through an ASGI transport.

* fix(rooms-yaml): address reviewer findings

1. Gateway: validate yaml value is a string before passing to
   safe_load — non-string values (e.g. {"yaml": 123}) now return 400
   instead of 500.

2. _coerce: catch OverflowError alongside ValueError/TypeError so
   infinity values (1e309, .inf) get a clear error instead of
   an unhandled exception.

3. Endpoint test: calls the real create_room_from_yaml function with
   a mock Request instead of reimplementing the routing logic in a
   separate Starlette app.

* feat(rooms-yaml): wire aliases through RoomSpec provision and export

RoomSpec gains an `aliases` field (agent name → room-scoped alias) and
provision() passes it to RoomCreateConfig so aliases are seeded at
room creation.  Export reads aliases back from the room_agents table
and emits them keyed by agent name.

CHOO-2657

* feat(rooms-yaml): add group document shape and provision_group

Introduces a second document shape discriminated by a top-level `group:`
key (vs `room:` for single-room). A group document declares a room group
(name, description, optional color), a list of rooms (`rooms:`), and
optional directed links between them (`links:`). Params are interpolated
across the entire document before validation.

`provision_group()` creates the group row first, then each room with
`group_id` set, then resolves intra-document links by room name. Partial
failure on a room is reported (not rolled back), matching the existing
single-room precedent.

The `/rooms/from-yaml` endpoint accepts either shape and returns
`ProvisionResult` or `GroupProvisionResult` accordingly.

CHOO-2657

* feat(rooms-yaml): interpolate dict keys, tests for group templates

Extend `interpolate()` to substitute placeholders in dict keys (not
just values), so alias maps like `{bot}: greeter` resolve when the
agent name comes from a param — the onboarder's actual need.

Adds 12 tests covering group parsing (shape, params across rooms,
alias key interpolation, validation errors), group provisioning
(two-room linked group, params across rooms, partial failure on bad
agent), single-room regression, and the /from-yaml endpoint handling
a group document.

CHOO-2657

* fix(rooms-yaml): reject duplicate room names in group, remove provision duplication

Catch duplicate room names at parse time — a set collision would let
links silently point to the wrong room. Also collapses
_provision_room_in_group into provision() via an optional group_id
parameter, removing ~55 lines of duplication.

CHOO-2657

* feat(agent-ops): add create_room_from_yaml operation (CHOO-2666)

Thin agent-side caller of the existing RoomYamlService.parse + provision
path — the same engine the gateway's POST /rooms/from-yaml uses. Agents
can now provision rooms and groups from inline YAML templates via the MCP
tool surface, with params interpolation and the same authorization gate
as create_room (owner_id/is_admin).

Includes 5 behavioral tests (single room, parameterized, group with
links, missing input → nothing created, ownerless agent → refused) and
updates all three connector skill indexes.

* style(agent-ops): move imports to top level per code style rules

* feat(console): load agents from a remote host (CHOO-2560) (#364)

* fix(console): refuse to overwrite a colleague's agent credentials on the same server

The Add Agent path minted a new identity and wrote `.switch/agents/<name>.json`
without checking whether the slot already held credentials from a different
Console install on the same Switch server. This destroyed the displaced agent's
API token.

Add a same-endpoint guard in `runAddAgent` that reads the existing slot and
checks its `SWITCH_AGENT_ID` against the local DB — if the id is unknown
locally it belongs to a colleague and the create is refused with
`already-configured`. Mirror the guard in `writeNeutralAgentSettingsFs` as
defence in depth. The modal shows a toast directing the user to load the
existing agent instead.

CHOO-2560

* feat(console): add Load Existing Agents UI for remote hosts

Restore the ability to load agents on a remote host that were created by a
different Console install, host-scoped and re-runnable from the remote host
page.

Discovery merges two sources: server-assisted (GET /agents with repo_dir,
confirmed on-disk via SFTP) and a bounded $HOME scan, deduped by (dir, name)
with server-attributed entries winning to preserve owner attribution.

The Load Existing Agents section appears on every remote host page and
auto-expands when the host was just added (the post-add-host prompt). Each
row shows name, directory, owner, provider, and endpoint-mismatch warnings.
Agents without an inferred provider get an inline picker. Already-loaded
agents appear disabled. A manual "scan a directory" fallback covers agents
outside $HOME.

Also extends RemoteAgentSummary with knownAgentOptions so the gateway
client carries repo_dir through for server-assisted discovery, and removes
the overly aggressive same-endpoint guard from writeNeutralAgentSettingsFs
that blocked legitimate same-install agent replacements (the pre-mint check
in runAddAgent is the correct guard for that case).

CHOO-2560

* fix(console): address review — writer guard, manual scan, blockedReason, addressing verdict

1. Wire the same-endpoint defence in depth in writeNeutralAgentSettingsFs:
   calls existingAgentIdInSlot and throws ExistingAgentCredentialsError when
   the slot holds a different agent. Callers that already verified the
   overwrite pass expectedAgentId to bypass the guard. runAddAgent passes
   slotAgentId from its pre-mint DB check.

2. Manual directory scan results are now merged into local state instead of
   discarded — a dir outside $HOME and the server's repo_dirs stays visible
   after scanning.

3. Add blockedReason field to LoadableAgent: propagated from discovery,
   shown in the UI as the disable reason per row. Replaces the separate
   alreadyAgent/endpointMismatch checks in the selectableAgents filter.

4. Show per-row addressing verdict when ownerName is known: "session
   access: yes · rooms: policy admits only its owner, ask <owner> to widen."

5. Test coverage for the already-configured guard: exercises the path where
   sameEndpointAgentId returns a non-null id and addAgent returns
   already-configured. Also tests the writer guard directly.

CHOO-2560

* style(console): address Copilot findings — imports, toggle label, memo deps

Move justAddedHost exports after imports per codebase convention, hide
select-all toggle when no agents are selectable, and fix useMemo deps for
serverId by reading MobX observables outside the memo.

* fix(console): prune hidden dirs in the $HOME scan; log scan failures; doc fix

Address remaining Copilot review findings on #364:
- The bounded $HOME scan now prunes every hidden directory except .switch
  (plus node_modules) — dot-trees like .cargo/.npm hold hundreds of
  thousands of entries and can never contain a surfaceable working dir.
  The docstring previously claimed this pruning; now the code does it.
- findSwitchAgentDirsOnHost no longer swallows exec failures silently:
  a failed scan is logged so it cannot masquerade as an empty host.
- existingAgentIdInSlot doc no longer implies read errors map to null;
  they throw, and callers must let them propagate.

* feat(console): explicit scan, endpoint display, details, config delete + sidebar fix in Load existing agents

- fix: reload the agents store after Load so the sidebar shows the new
  agents immediately (agentEvents is main-process-only; same idiom as the
  Add Agent flow)
- discovery runs on 'Scan this host', not on section expand (no unasked SSH
  into a colleague's box)
- every row can expand to details: description, agent id, endpoint, dir,
  provider+source, owner, found-via
- endpoint mismatches show both sides (registered against X; this server is Y)
- per-row trash deletes the on-disk .switch/agents/<name>.json (confirm
  modal; host-file only, server registration untouched; disabled for agents
  already loaded here)
- owner/policy line says '(you)' instead of 'ask yourself to widen' when the
  viewer owns the agent

* fix(console): bridge agent CRUD events to the renderer so views stop going stale

A locally removed agent stayed 'Already loaded in this Console' in the Load
existing agents section: agentEvents is a main-process-only bus, so no
renderer store or query reacts to agent create/update/delete — each call
site had to remember its own refetch, and the remove path forgot (the load
path had the mirror bug, patched by hand earlier).

Durable fix: agents:changed channel bridged from agentEvents at startup; a
global AgentCrudEvents reactor reloads the sidebar agents store and
invalidates every load-existing-agents discovery query on any agent CRUD.

* style(console): oxfmt pass on the new loading files

* fix(console): plain remove no longer deletes an agent's files or sidecar on its host

Removing a loaded agent local-only was wiping the on-disk credentials in the
working directory (.switch/agents/<name>.json, the settings.local.json env
block, launch profiles) and killing the sidecar — on a shared host those
belong to another install, so a colleague's agent was destroyed by a remove
that promised to be local. Attach guarantees it writes nothing; remove now
mirrors it.

DeleteAgentOptions gains a required removeProvisionedFiles flag: no caller
gets a default. The remove modal offers it as an explicit opt-in checkbox
naming the exact host:dir, warns that shared-host files may belong to
another install, and the misleading 'the folder stays on the filesystem'
copy now states plainly what a plain remove does. Server teardown keeps
cleaning its own provisioned agents; removing a location forgets it without
touching disk.

* style(console): prune comments that restate code or would rot

Removed a hardcoded line reference, process-history narration in the event
bridge doc, one-liners that restate the variable they sit on, and the manual
agentsStore.load() in the load mutation that the agents:changed bridge made
redundant (with its now-inaccurate comment).

* fix(console): manual directory scan now shows results in the agent list

The agent list is gated behind scanStarted, which only the "Scan this
host" button set. A manual directory scan found agents and stored them
but left scanStarted false, so the ternary never reached the list
branch. Flip scanStarted on manual-scan success so the results render
and auto-discovery kicks in alongside them.

* fix(console): show manual-scan results without triggering auto-discovery

The previous fix flipped scanStarted on manual-scan success, which
rendered the results but also kicked off the slow host-wide discovery
as a side effect. Instead, widen the rendering gate to also check
manualAgents — the placeholder hides once either scan path has results,
and auto-discovery stays gated on the explicit "Scan this host" button.

* fix(console): remove explicit scan gate — show agents on expand

The scanStarted gate required clicking "Scan this host" before results
would render, and manual directory scans never flipped it. Remove the
gate entirely: discovery runs when the section expands, results display
immediately, and the Rescan button handles refresh. Both auto-discovery
and manual scan results appear without an intermediate step.

* fix(console): reload location manager on agent CRUD so sidebar updates

The agent-crud event reactor reloaded agentsStore but not the location
manager, so a loaded agent appeared in "Your agents" but its location
never mounted — no sidebar row, no agent page navigation.

Call getLocationManagerStore().reload() alongside agentsStore.load().
Also drop locations whose last agent was removed inside _doLoad so
stale sidebar rows don't survive a delete.

* feat(console): split discovery — cheap auto-scan, deep walk behind Alt

The $HOME walk can be slow on large VMs. Split it from the cheap
server-assisted discovery: on section expand, only check the server's
registered agent directories (instant); the full home-directory walk
is a hidden alternate action revealed by holding Alt, with an honest
slow-scan label and tooltip. The manual directory scan stays as the
precision tool between the two.

* fix(console): guard _doLoad cleanup against in-flight onboarding

A concurrent CRUD event could trigger reload() while startAgentOnboarding
had already placed an unregistered placeholder in the locations map but
before the agent existed in the DB. The cleanup loop would delete it
mid-onboarding. Skip locations in pendingCreationIds.

* feat(console): reconcile sidecar sessions after loading a remote agent

After attachConfiguredAgents creates an agent row, start the remote session
reconciler so the sidecar's existing sessions appear in the sidebar
immediately — not just the agent identity.

Uses a dynamic import for remote-watcher to avoid pulling Electron's app
module into the test environment.

* feat(console): show owner attribution on loaded agents

When an agent is loaded from another install, persist the server-side
owner name (ownerName) in the agents table so the UI can distinguish it
from agents this Console created.

Visible on the Your Agents card ("loaded · by AbelD") and the agent
detail page titlebar. Null for agents created by this install, so
existing agents are unaffected.

Includes migration 0048 adding the owner_name column.

* fix(console): don't auto-scan host on Load section expand

Expanding the "Load existing agents" section was firing discovery
immediately, which is slow on VMs with many files. Put it behind a
"Discover agents" button so the user controls when the scan runs.

Addresses Louis's feedback on PR #364.

* fix(console): always show Deep Scan button, remove Alt-key gating

Abel tested the Load UI and flagged the Alt-key reveal as a UX trap —
users don't discover hidden modifiers. Remove the altHeld state and
keydown/keyup listener, show Deep Scan next to Rescan unconditionally,
drop the "Hold Alt" hint text and the tilde from the label, and set a
tooltip explaining the scan cost.

* fix(console): show 'Already loaded' label immediately after loading an agent

The discovery query refetches via SSH after a load, so the blocked-reason
label lagged behind the action by several seconds. Optimistically update
the react-query cache and manual-agents state with the loaded names
before the background refetch lands.

* docs(console): add screenshot of Load Existing Agents expanded view

* feat(console): improve Deep Scan UX with tooltip, progress bar, and cancel

Replace the native title attribute on Deep Scan buttons with the app's
Tooltip component for visibility. Show an estimated progress bar (30s)
instead of a spinner during deep scans so the user has a sense of
liveness and expected duration. Add a cancel button to abort a scan in
progress.

* perf(rooms): index rooms.group_id (#404)

group_id is an unindexed foreign key, so listing rooms by group and the
ON DELETE SET NULL on group removal both scan the rooms table. Adds the
index, matching ix_agents_parent_agent_id.

* fix(db): rejoin the two migration heads so the service can boot (#426)

Two migrations landed in parallel off the same parent, so the chain had two
heads. Startup runs `alembic upgrade head`, which is ambiguous with more than
one, and a deployment not already sitting on one of the two refuses to boot
with "Multiple head revisions are present".

`test_single_head` already asserts this and has been failing on main since the
second one merged: each pull request was green against its own branch, where
there was one head, and nothing re-ran the suite against the merge result.

The revision is empty. Neither head carries schema the other needs.

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

* fix(plugins): sync opencode embedded skill with create_room_from_yaml

The connector's SKILL.md gained the new operation but the copy the app
embeds did not, and connector-assets.test.ts rightly refuses drift
between the two.

---------

Co-authored-by: Petr Bauch <petr.bauch@sandboxquantum.com>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
---
 .../claude-code-plugin/skills/switch/SKILL.md |   1 +
 .../codex-plugin/skills/switch/SKILL.md       |   1 +
 .../opencode-plugin/skills/switch/SKILL.md    |   1 +
 .../drizzle/0048_agent_owner_name.sql         |   1 +
 .../drizzle/meta/_journal.json                |   7 +
 .../src/main/core/agents/add-agent.test.ts    |  38 ++
 .../src/main/core/agents/add-agent.ts         |  30 +-
 .../core/agents/agent-credentials-slot.ts     |  28 +-
 .../agents/agent-events-renderer-bridge.ts    |  14 +
 .../agents/attach-configured-agents.test.ts   |   1 +
 .../core/agents/attach-configured-agents.ts   |  27 +-
 .../src/main/core/agents/controller.ts        |  14 +
 .../src/main/core/agents/createAgent.ts       |   1 +
 .../src/main/core/agents/deleteAgent.test.ts  |  70 +-
 .../src/main/core/agents/deleteAgent.ts       |  28 +-
 .../core/agents/discover-loadable-agents.ts   | 280 ++++++++
 .../agents/remove-loadable-agent-config.ts    |  44 ++
 .../src/main/core/agents/utils.ts             |   1 +
 .../core/agents/write-switch-settings.test.ts |  23 +
 .../main/core/agents/write-switch-settings.ts |  94 ++-
 .../backfill-agent-icons.test.ts              |   1 +
 .../delete-server-agents.db.test.ts           |   1 +
 .../switch-servers/delete-server-agents.ts    |   8 +-
 .../core/switch-servers/gateway-client.ts     |   2 +
 .../src/main/core/telemetry/events.ts         |   1 +
 .../src/main/db/schema.ts                     |   3 +
 .../switch-console-desktop/src/main/index.ts  |   2 +
 .../src/renderer/App.tsx                      |   2 +
 .../src/renderer/app/agent-crud-events.tsx    |  29 +
 .../src/renderer/app/modal-registry.ts        |   2 +
 .../add-agent-modal/add-agent-modal.tsx       |   9 +
 .../components/delete-agent-modal.tsx         |  43 +-
 .../components/location-titlebar.tsx          |  11 +-
 .../hooks/use-confirm-delete-agent.tsx        |   7 +-
 .../locations/stores/location-manager.test.ts |  60 +-
 .../locations/stores/location-manager.ts      |  13 +-
 .../load-existing-agents-section.tsx          | 607 ++++++++++++++++++
 .../remove-agent-config-modal.tsx             |  57 ++
 .../remote-hosts/views/remote-host-view.tsx   |  24 +-
 .../remote-hosts/views/remote-hosts-view.tsx  |  19 +-
 .../switch-servers/server-agents-view.tsx     |   5 +
 .../tests/browser/palette-agent-icon.test.tsx |   2 +
 .../src/shared/core/agents/agents.ts          |   5 +
 .../core/switch-servers/switch-servers.ts     |   8 +
 .../src/shared/events/appEvents.ts            |  11 +
 .../load-existing-agents-expanded.png         | Bin 0 -> 141106 bytes
 .../src/agents/impl/opencode/skill-file.ts    |   1 +
 .../bridges/agent/operations/definitions.py   |  75 ++-
 core/switch_core/db/models.py                 |   4 +
 .../a1c7e2f9b430_index_rooms_group_id.py      |  29 +
 ...idc_identities_and_group_id_index_heads.py |  29 +
 .../operations/test_create_room_from_yaml.py  | 340 ++++++++++
 .../bridges/agent/test_mcp_tool_surface.py    |   1 +
 53 files changed, 2075 insertions(+), 40 deletions(-)
 create mode 100644 console/apps/switch-console-desktop/drizzle/0048_agent_owner_name.sql
 create mode 100644 console/apps/switch-console-desktop/src/main/core/agents/agent-events-renderer-bridge.ts
 create mode 100644 console/apps/switch-console-desktop/src/main/core/agents/discover-loadable-agents.ts
 create mode 100644 console/apps/switch-console-desktop/src/main/core/agents/remove-loadable-agent-config.ts
 create mode 100644 console/apps/switch-console-desktop/src/renderer/app/agent-crud-events.tsx
 create mode 100644 console/apps/switch-console-desktop/src/renderer/features/remote-hosts/load-existing-agents-section.tsx
 create mode 100644 console/apps/switch-console-desktop/src/renderer/features/remote-hosts/remove-agent-config-modal.tsx
 create mode 100644 console/docs/screenshots/load-existing-agents-expanded.png
 create mode 100644 core/switch_core/migrations/versions/a1c7e2f9b430_index_rooms_group_id.py
 create mode 100644 core/switch_core/migrations/versions/b47e0c39a1f5_merge_oidc_identities_and_group_id_index_heads.py
 create mode 100644 core/tests/switch_core/bridges/agent/operations/test_create_room_from_yaml.py

diff --git a/connectors/claude-code-plugin/skills/switch/SKILL.md b/connectors/claude-code-plugin/skills/switch/SKILL.md
index 8c0d877b5..5b3b17488 100644
--- a/connectors/claude-code-plugin/skills/switch/SKILL.md
+++ b/connectors/claude-code-plugin/skills/switch/SKILL.md
@@ -791,6 +791,7 @@ failure-mode tools are covered in the sections just above.
 - `list_room_groups` — the group tree rooms are organised into.
 - `get_room_group_detail` — one group's rooms and child groups.
 - `create_room_group` — provision a new room group.
+- `create_room_from_yaml` — provision a room or group from a YAML template.
 - `list_agents` — every agent on the instance, with optional filters.
 - `get_agent_detail` — one agent's config, capabilities and sessions.
 - `update_agent_detail` — change an agent you own.
diff --git a/connectors/codex-plugin/skills/switch/SKILL.md b/connectors/codex-plugin/skills/switch/SKILL.md
index fbaf9a7f9..c95b4dc3b 100644
--- a/connectors/codex-plugin/skills/switch/SKILL.md
+++ b/connectors/codex-plugin/skills/switch/SKILL.md
@@ -788,6 +788,7 @@ failure-mode tools are covered in the sections just above.
 - `list_room_groups` — the group tree rooms are organised into.
 - `get_room_group_detail` — one group's rooms and child groups.
 - `create_room_group` — provision a new room group.
+- `create_room_from_yaml` — provision a room or group from a YAML template.
 - `list_agents` — every agent on the instance, with optional filters.
 - `get_agent_detail` — one agent's config, capabilities and sessions.
 - `update_agent_detail` — change an agent you own.
diff --git a/connectors/opencode-plugin/skills/switch/SKILL.md b/connectors/opencode-plugin/skills/switch/SKILL.md
index cb274a1ec..6e8a6070c 100644
--- a/connectors/opencode-plugin/skills/switch/SKILL.md
+++ b/connectors/opencode-plugin/skills/switch/SKILL.md
@@ -791,6 +791,7 @@ failure-mode tools are covered in the sections just above.
 - `list_room_groups` — the group tree rooms are organised into.
 - `get_room_group_detail` — one group's rooms and child groups.
 - `create_room_group` — provision a new room group.
+- `create_room_from_yaml` — provision a room or group from a YAML template.
 - `list_agents` — every agent on the instance, with optional filters.
 - `get_agent_detail` — one agent's config, capabilities and sessions.
 - `update_agent_detail` — change an agent you own.
diff --git a/console/apps/switch-console-desktop/drizzle/0048_agent_owner_name.sql b/console/apps/switch-console-desktop/drizzle/0048_agent_owner_name.sql
new file mode 100644
index 000000000..d2e2254d4
--- /dev/null
+++ b/console/apps/switch-console-desktop/drizzle/0048_agent_owner_name.sql
@@ -0,0 +1 @@
+ALTER TABLE `agents` ADD `owner_name` text;
\ No newline at end of file
diff --git a/console/apps/switch-console-desktop/drizzle/meta/_journal.json b/console/apps/switch-console-desktop/drizzle/meta/_journal.json
index 2b8b7d0f6..8adcf9253 100644
--- a/console/apps/switch-console-desktop/drizzle/meta/_journal.json
+++ b/console/apps/switch-console-desktop/drizzle/meta/_journal.json
@@ -337,6 +337,13 @@
       "when": 1786983032561,
       "tag": "0047_materialise_telemetry_consent",
       "breakpoints": true
+    },
+    {
+      "idx": 48,
+      "version": "6",
+      "when": 1788633600000,
+      "tag": "0048_agent_owner_name",
+      "breakpoints": true
     }
   ]
 }
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/add-agent.test.ts b/console/apps/switch-console-desktop/src/main/core/agents/add-agent.test.ts
index 5c5bb36cd..65f20936b 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/add-agent.test.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/add-agent.test.ts
@@ -88,6 +88,19 @@ vi.mock('./setAgentAutoSession', () => ({
 vi.mock('./agent-events', () => ({ agentEvents: { _emit: vi.fn() } }));
 vi.mock('@main/core/telemetry/telemetry-service', () => ({ trackEvent: vi.fn() }));
 vi.mock('@main/lib/logger', () => ({ log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() } }));
+vi.mock('@main/db/client', () => ({
+  db: {
+    select: () => ({
+      from: () => ({
+        where: () => ({
+          limit: () => Promise.resolve([]),
+        }),
+      }),
+    }),
+  },
+}));
+vi.mock('@main/db/schema', () => ({ agents: { id: 'id', switchAgentId: 'switchAgentId' } }));
+vi.mock('drizzle-orm', () => ({ eq: vi.fn() }));
 
 const { addAgent } = await import('./add-agent');
 const { trackEvent } = await import('@main/core/telemetry/telemetry-service');
@@ -222,6 +235,31 @@ describe('addAgent', () => {
     ).toBe(theirs);
   });
 
+  it('refuses when same-server credentials exist but the agent is unknown to this install (CHOO-2560)', async () => {
+    // A colleague's Console provisioned this agent on the same Switch server.
+    // The credentials file carries the same endpoint, but its agent id is not
+    // in this install's database (the mock returns []). Minting over it would
+    // destroy their token.
+    const colleague = JSON.stringify({
+      env: {
+        SWITCH_API_ENDPOINT: 'https://switch.example.com',
+        SWITCH_API_TOKEN: 'colleague-token',
+        SWITCH_AGENT_ID: 'colleague-agent',
+      },
+    });
+    h.state.workspace = fakeFs({ [agentSettingsRelativePath('codex-hoot')]: colleague });
+
+    const result = await addAgent(params());
+
+    expect(result).toEqual({ kind: 'already-configured' });
+    expect(h.registerAgentIdentity).not.toHaveBeenCalled();
+    expect(h.createAgent).not.toHaveBeenCalled();
+    // The colleague's file is intact.
+    expect(
+      await (h.state.workspace as PluginFs).read(agentSettingsRelativePath('codex-hoot'))
+    ).toBe(colleague);
+  });
+
   it('refuses a name already taken in the location, without minting an identity', async () => {
     // The gateway's 409 is scoped to the Switch server, so it cannot see a name
     // that is free there and taken in this directory — where both agents would
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/add-agent.ts b/console/apps/switch-console-desktop/src/main/core/agents/add-agent.ts
index 014df7a72..f86c988c9 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/add-agent.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/add-agent.ts
@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import type { RepoAgentAttributes } from '@switch-console/core/agents/plugins';
+import { eq } from 'drizzle-orm';
 import { locationManager } from '@main/core/locations/location-manager';
 import { checkIsValidDirectory } from '@main/core/locations/path-utils';
 import { ensureLocation, getLocationByHostDir } from '@main/core/locations/store';
@@ -9,6 +10,8 @@ import { agentTypeOf } from '@main/core/telemetry/agent-type';
 import type { TelemetryAgentCreateFailure } from '@main/core/telemetry/events';
 import { entryPointOf } from '@main/core/telemetry/narrow';
 import { trackEvent } from '@main/core/telemetry/telemetry-service';
+import { db } from '@main/db/client';
+import { agents as agentsTable } from '@main/db/schema';
 import { log } from '@main/lib/logger';
 import { agentAvatarUrlForName } from '@shared/core/agents/agent-avatar';
 import type { AgentProviderConfig } from '@shared/core/agents/agent-provider-config';
@@ -18,7 +21,7 @@ import type { UiEntryPoint } from '@shared/core/telemetry/reporting';
 import { basenameFromAnyPath } from '@shared/path-name';
 import { writeAgentConfigFile } from './agent-config-file';
 import { syncAgentConfig } from './agent-config-sync';
-import { foreignCredentialsOwner } from './agent-credentials-slot';
+import { foreignCredentialsOwner, sameEndpointAgentId } from './agent-credentials-slot';
 import { agentEvents } from './agent-events';
 import { agentNameTaken } from './agent-name-taken';
 import { resolveWorkspaceFsFor } from './agent-workspace-fs';
@@ -72,6 +75,7 @@ export type AddAgentResult =
   | { kind: 'unauthenticated' }
   | { kind: 'name-conflict' }
   | { kind: 'credentials-conflict'; endpoint: string }
+  | { kind: 'already-configured' }
   | { kind: 'invalid-name'; message: string }
   | { kind: 'error'; message: string };
 
@@ -83,6 +87,7 @@ const ADD_AGENT_FAILURE_REASON: Record<
   unauthenticated: 'unauthenticated',
   'name-conflict': 'name_conflict',
   'credentials-conflict': 'credentials_conflict',
+  'already-configured': 'already_configured',
   'invalid-name': 'invalid_name',
   error: 'error',
 };
@@ -182,6 +187,28 @@ async function runAddAgent(params: AddAgentParams): Promise<AddAgentResult> {
     });
   }
 
+  // The cross-deployment check above passes when the slot belongs to the SAME
+  // server. That is safe when this install already manages the agent (the
+  // agentNameTaken check above covers it), but not when the file was written by another
+  // Console — its agent is in this install's blind spot. Minting here would
+  // overwrite the existing identity and destroy its token (CHOO-2560).
+  const slotAgentId = await sameEndpointAgentId(
+    params.sshHost,
+    params.dir,
+    params.name,
+    server.apiUrl
+  );
+  if (slotAgentId !== null) {
+    const [knownLocally] = await db
+      .select({ id: agentsTable.id })
+      .from(agentsTable)
+      .where(eq(agentsTable.switchAgentId, slotAgentId))
+      .limit(1);
+    if (!knownLocally) {
+      return reportFailedCreate(params, { kind: 'already-configured' });
+    }
+  }
+
   const registered = await registerAgentIdentity(server, {
     name: params.name,
     description: params.description,
@@ -206,6 +233,7 @@ async function runAddAgent(params: AddAgentParams): Promise<AddAgentResult> {
       apiEndpoint: server.apiUrl,
       apiToken: registered.apiKey,
       agentId: registered.id,
+      expectedAgentId: slotAgentId ?? undefined,
     });
     // The config file is the agent's configuration; the provider's own file is
     // generated from it, here and on every later edit.
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/agent-credentials-slot.ts b/console/apps/switch-console-desktop/src/main/core/agents/agent-credentials-slot.ts
index 1c66c3c23..81bafcd68 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/agent-credentials-slot.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/agent-credentials-slot.ts
@@ -1,5 +1,6 @@
 import { resolveWorkspaceFsFor } from './agent-workspace-fs';
-import { foreignCredentialsOwnerFs } from './write-switch-settings';
+import { agentSettingsRelativePath } from './switch-settings-paths';
+import { existingAgentIdInSlot, foreignCredentialsOwnerFs } from './write-switch-settings';
 
 /**
  * The Switch deployment that already owns `.switch/agents/<slug>.json` in a
@@ -28,3 +29,28 @@ export async function foreignCredentialsOwner(
     workspace.close();
   }
 }
+
+/**
+ * The `SWITCH_AGENT_ID` of an agent already configured in the credentials slot
+ * for `slug`, when the file belongs to the SAME deployment as `apiEndpoint` —
+ * otherwise null.
+ *
+ * The create path calls this after the cross-deployment check
+ * ({@link foreignCredentialsOwner}) and before minting a new identity. A
+ * same-server file whose agent id is unknown to this install's database is a
+ * colleague's agent: minting over it would overwrite their token (CHOO-2560).
+ */
+export async function sameEndpointAgentId(
+  sshHost: string | null,
+  dir: string,
+  slug: string,
+  apiEndpoint: string
+): Promise<string | null> {
+  const workspace = await resolveWorkspaceFsFor(sshHost, dir);
+  try {
+    const existingRaw = await workspace.fs.read(agentSettingsRelativePath(slug));
+    return existingAgentIdInSlot(existingRaw, apiEndpoint);
+  } finally {
+    workspace.close();
+  }
+}
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/agent-events-renderer-bridge.ts b/console/apps/switch-console-desktop/src/main/core/agents/agent-events-renderer-bridge.ts
new file mode 100644
index 000000000..b67b9ddcf
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/main/core/agents/agent-events-renderer-bridge.ts
@@ -0,0 +1,14 @@
+import { events } from '@main/lib/events';
+import { agentsChangedChannel } from '@shared/events/appEvents';
+import { agentEvents } from './agent-events';
+
+/**
+ * Forward agent CRUD from the main-only `agentEvents` bus to the renderer, so
+ * renderer stores and queries can react to create/update/delete without each
+ * mutating call site refetching by hand.
+ */
+export function bridgeAgentEventsToRenderer(): void {
+  agentEvents.on('agent:created', () => events.emit(agentsChangedChannel, { kind: 'created' }));
+  agentEvents.on('agent:updated', () => events.emit(agentsChangedChannel, { kind: 'updated' }));
+  agentEvents.on('agent:deleted', () => events.emit(agentsChangedChannel, { kind: 'deleted' }));
+}
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.test.ts b/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.test.ts
index b99e25029..bf6e13a6a 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.test.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.test.ts
@@ -103,6 +103,7 @@ vi.mock('./setAgentAutoSession', () => ({
   reconcileAgentAutoSessionFromGateway: vi.fn(async () => {}),
 }));
 vi.mock('./agent-events', () => ({ agentEvents: { _emit: h.emit } }));
+vi.mock('./remote-watcher', () => ({ startRemoteDiscovery: vi.fn(async () => {}) }));
 vi.mock('@main/lib/logger', () => ({ log: { info: vi.fn(), warn: h.warn, error: vi.fn() } }));
 
 const { attachConfiguredAgents } = await import('./attach-configured-agents');
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.ts b/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.ts
index f232387c2..a56bb053a 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/attach-configured-agents.ts
@@ -28,7 +28,7 @@ export type AttachConfiguredAgentsParams = {
    * taken from the scan: discovery infers it best-effort and reports `null` when
    * the directory names none, in which case the user picks.
    */
-  agents: Array<{ name: string; providerId: AgentProviderId }>;
+  agents: Array<{ name: string; providerId: AgentProviderId; ownerName?: string | null }>;
 };
 
 export type AttachConfiguredAgentsResult = Result<Agent[], OnboardAgentError>;
@@ -81,7 +81,8 @@ export async function attachConfiguredAgents(
     ).map((d) => [d.name, d])
   );
 
-  const selected: Array<{ name: string; providerId: AgentProviderId }> = [];
+  const selected: Array<{ name: string; providerId: AgentProviderId; ownerName?: string | null }> =
+    [];
   for (const requested of params.agents) {
     const found = discovered.get(requested.name);
     if (!found) {
@@ -110,7 +111,7 @@ export async function attachConfiguredAgents(
   });
 
   const created: Agent[] = [];
-  for (const { name, providerId } of selected) {
+  for (const { name, providerId, ownerName } of selected) {
     const found = discovered.get(name);
     if (!found) continue;
 
@@ -159,6 +160,7 @@ export async function attachConfiguredAgents(
       apiEndpoint: found.apiEndpoint,
       serverId: params.serverId,
       autoApprove: params.sshHost !== null,
+      ownerName: ownerName ?? null,
     });
     created.push(agent);
 
@@ -171,9 +173,22 @@ export async function attachConfiguredAgents(
   }
 
   await locationManager.openLocation(location);
-  // No control to name: an attach is driven by whichever screen offered the
-  // scan, and nothing on the way here says which. `unknown` reports the absence
-  // of a claim rather than inventing one.
   for (const agent of created) agentEvents._emit('agent:created', agent, 'unknown');
+
+  if (params.sshHost !== null) {
+    // Lazy import: remote-watcher transitively loads Electron's `app` module at
+    // the top level, which breaks the unit-test environment where `app` is
+    // undefined. A dynamic import defers that cost to runtime (always Electron).
+    const { startRemoteDiscovery } = await import('./remote-watcher');
+    for (const agent of created) {
+      startRemoteDiscovery(agent.id).catch((error) => {
+        log.warn('attachConfiguredAgents: failed to start session discovery', {
+          agentId: agent.id,
+          error: String(error),
+        });
+      });
+    }
+  }
+
   return ok(created);
 }
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/controller.ts b/console/apps/switch-console-desktop/src/main/core/agents/controller.ts
index 39ec76ee3..f50e7725a 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/controller.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/controller.ts
@@ -23,11 +23,18 @@ import { createAgent } from './createAgent';
 import { getAgentDefinitionFields } from './definition-fields';
 import { deleteAgent, type DeleteAgentOptions } from './deleteAgent';
 import { discoverConfiguredAgents } from './discover-configured-agents';
+import {
+  discoverLoadableAgentsInDir,
+  discoverLoadableAgentsOnHost,
+  type DiscoverLoadableAgentsParams,
+} from './discover-loadable-agents';
 import { discoverLocationAgents } from './discover-location-agents';
 import { getAgentById } from './getAgentById';
 import { getAgents } from './getAgents';
 import { onboardAgent } from './onboard-agent';
 import { onboardLocationAgents, type OnboardLocationParams } from './onboard-location-agents';
+import type { RemoveLoadableAgentConfigParams } from './remove-loadable-agent-config';
+import { removeLoadableAgentConfig } from './remove-loadable-agent-config';
 import { renameAgent } from './renameAgent';
 import { resetRemoteAgent } from './reset-remote-agent';
 import { setAgentAutoApprove, type AgentAutoApproveParams } from './setAgentAutoApprove';
@@ -85,13 +92,20 @@ export const agentsController = createRPCController({
   }) => discoverLocationAgents(params),
   discoverConfiguredAgents: (params: { sshHost: string | null; dir: string; serverId: string }) =>
     discoverConfiguredAgents(params),
+  discoverLoadableAgentsOnHost: (params: DiscoverLoadableAgentsParams) =>
+    discoverLoadableAgentsOnHost(params),
+  discoverLoadableAgentsInDir: (params: { sshHost: string; dir: string; serverId: string }) =>
+    discoverLoadableAgentsInDir(params),
   attachConfiguredAgents: (params: AttachConfiguredAgentsParams) => attachConfiguredAgents(params),
+  removeLoadableAgentConfig: (params: RemoveLoadableAgentConfigParams) =>
+    removeLoadableAgentConfig(params),
   getAgents: (locationId?: string) => getAgents(locationId),
   getAgentById: (agentId: string) => getAgentById(agentId),
   renameAgent: (params: RenameAgentParams) => renameAgent(params),
   deleteAgent: (params: { agentId: string } & DeleteAgentOptions) =>
     deleteAgent(params.agentId, {
       deleteInSwitch: params.deleteInSwitch,
+      removeProvisionedFiles: params.removeProvisionedFiles,
       trigger: params.trigger,
     }),
   resetRemoteAgent: (params: { agentId: string }) => resetRemoteAgent(params.agentId),
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/createAgent.ts b/console/apps/switch-console-desktop/src/main/core/agents/createAgent.ts
index 52f875245..8cdebcabb 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/createAgent.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/createAgent.ts
@@ -16,6 +16,7 @@ export async function createAgent(params: CreateAgentParams): Promise<Agent> {
       apiEndpoint: params.apiEndpoint,
       serverId: params.serverId,
       autoApprove: params.autoApprove,
+      ownerName: params.ownerName ?? null,
       providerConfig: params.providerConfig ?? null,
       updatedAt: sql`CURRENT_TIMESTAMP`,
     })
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.test.ts b/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.test.ts
index 3780b49c8..29ae201d4 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.test.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.test.ts
@@ -119,7 +119,11 @@ describe('deleteAgent', () => {
     const fs = fakeFs({ [agentSettingsRelativePath('codex-hoot')]: CREDS });
     h.state.fs = fs;
 
-    await deleteAgent('agent-1', { deleteInSwitch: false, trigger: 'user' });
+    await deleteAgent('agent-1', {
+      deleteInSwitch: false,
+      removeProvisionedFiles: true,
+      trigger: 'user',
+    });
 
     expect(await fs.exists(agentSettingsRelativePath('codex-hoot'))).toBe(false);
   });
@@ -131,12 +135,38 @@ describe('deleteAgent', () => {
     });
     h.state.fs = fs;
 
-    await deleteAgent('agent-1', { deleteInSwitch: false, trigger: 'user' });
+    await deleteAgent('agent-1', {
+      deleteInSwitch: false,
+      removeProvisionedFiles: true,
+      trigger: 'user',
+    });
 
     expect(await fs.exists(agentSettingsRelativePath('cc-hoot'))).toBe(false);
     expect(await fs.exists('.claude/agents/cc-hoot.md')).toBe(false);
   });
 
+  it('leaves the working directory untouched on a plain remove (CHOO-2560)', async () => {
+    // An agent loaded from a shared host has credentials another install owns;
+    // a remove without removeProvisionedFiles must not reach into the directory.
+    h.state.agent = { id: 'agent-1', name: 'cc-hoot', providerId: 'claude', locationId: 'loc' };
+    const fs = fakeFs({
+      [agentSettingsRelativePath('cc-hoot')]: CREDS,
+      '.claude/agents/cc-hoot.md': '# cc-hoot',
+    });
+    h.state.fs = fs;
+
+    await deleteAgent('agent-1', {
+      deleteInSwitch: false,
+      removeProvisionedFiles: false,
+      trigger: 'user',
+    });
+
+    expect(await fs.exists(agentSettingsRelativePath('cc-hoot'))).toBe(true);
+    expect(await fs.exists('.claude/agents/cc-hoot.md')).toBe(true);
+    expect(h.removeLocal).not.toHaveBeenCalled();
+    expect(h.removeSwitchCredentials).not.toHaveBeenCalled();
+  });
+
   it('leaves a sibling agent sharing the directory untouched', async () => {
     const fs = fakeFs({
       [agentSettingsRelativePath('cc-hoot')]: CREDS,
@@ -144,14 +174,22 @@ describe('deleteAgent', () => {
     });
     h.state.fs = fs;
 
-    await deleteAgent('agent-1', { deleteInSwitch: false, trigger: 'user' });
+    await deleteAgent('agent-1', {
+      deleteInSwitch: false,
+      removeProvisionedFiles: true,
+      trigger: 'user',
+    });
 
     expect(await fs.exists(agentSettingsRelativePath('cc-sibling'))).toBe(true);
   });
 
   describe('what it reports', () => {
     it('describes the agent that was removed, from the row before it goes', async () => {
-      await deleteAgent('agent-1', { deleteInSwitch: false, trigger: 'user' });
+      await deleteAgent('agent-1', {
+        deleteInSwitch: false,
+        removeProvisionedFiles: false,
+        trigger: 'user',
+      });
 
       expect(h.trackEvent).toHaveBeenCalledWith('agent_removed', {
         agent_type: 'claude',
@@ -166,7 +204,11 @@ describe('deleteAgent', () => {
     it('separates a server teardown from a person removing an agent', async () => {
       // Wiping a managed server deletes every agent on it through this same
       // function; without the distinction one click looks like an exodus.
-      await deleteAgent('agent-1', { deleteInSwitch: false, trigger: 'server_teardown' });
+      await deleteAgent('agent-1', {
+        deleteInSwitch: false,
+        removeProvisionedFiles: false,
+        trigger: 'server_teardown',
+      });
 
       expect(h.trackEvent).toHaveBeenCalledWith(
         'agent_removed',
@@ -179,7 +221,11 @@ describe('deleteAgent', () => {
       // every one of them reported starting.
       h.state.sessionRows = [{ id: 's-1' }, { id: 's-2' }];
 
-      await deleteAgent('agent-1', { deleteInSwitch: false, trigger: 'user' });
+      await deleteAgent('agent-1', {
+        deleteInSwitch: false,
+        removeProvisionedFiles: false,
+        trigger: 'user',
+      });
 
       expect(h.sessionHookEmit).toHaveBeenCalledWith('session:deleted', 's-1');
       expect(h.sessionHookEmit).toHaveBeenCalledWith('session:deleted', 's-2');
@@ -201,7 +247,11 @@ describe('deleteAgent', () => {
       vi.mocked(getServer).mockResolvedValue({ id: 'srv-1' } as never);
 
       await expect(
-        deleteAgent('agent-1', { deleteInSwitch: true, trigger: 'user' })
+        deleteAgent('agent-1', {
+          deleteInSwitch: true,
+          removeProvisionedFiles: false,
+          trigger: 'user',
+        })
       ).rejects.toThrow();
 
       expect(h.trackEvent).toHaveBeenCalledWith(
@@ -221,7 +271,11 @@ describe('deleteAgent', () => {
       };
 
       await expect(
-        deleteAgent('agent-1', { deleteInSwitch: true, trigger: 'user' })
+        deleteAgent('agent-1', {
+          deleteInSwitch: true,
+          removeProvisionedFiles: false,
+          trigger: 'user',
+        })
       ).rejects.toThrow();
 
       expect(h.trackEvent).toHaveBeenCalledWith(
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.ts b/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.ts
index cfa87aab4..57c312eea 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/deleteAgent.ts
@@ -44,6 +44,19 @@ export type DeleteAgentOptions = {
    * left registered on the server.
    */
   deleteInSwitch: boolean;
+  /**
+   * Also tear down what was provisioned on disk for this agent (its
+   * `.switch/agents/<name>.json` credentials, provider definition files, launch
+   * profile) and kill its sidecar on the host.
+   *
+   * Required with no default, because the right answer depends on who owns the
+   * on-disk state: an agent this Console created can carry its files out, but an
+   * agent merely loaded from a shared host (CHOO-2560) has credentials that
+   * belong to ANOTHER install — deleting them there is data loss on a
+   * colleague's machine. Plain remove must mirror attach's guarantee: nothing in
+   * the working directory is touched.
+   */
+  removeProvisionedFiles: boolean;
   /**
    * Whether a person removed this agent or a server teardown swept it up.
    *
@@ -188,9 +201,11 @@ async function killRemoteSidecar(agent: Agent): Promise<void> {
  *    caches the agent's Switch credentials in memory, so without an explicit
  *    stop it keeps heartbeating and polling notifications for an agent that
  *    no longer exists.
- * 4. The Switch credentials + definition file Switch Console provisioned on disk for
- *    THIS agent (local or remote), which a bare row delete would leave orphaned.
- *    Sibling agents' files in the same directory are untouched.
+ * 4. Only when `removeProvisionedFiles` is set: the Switch credentials +
+ *    definition file provisioned on disk for THIS agent (local or remote), and
+ *    its sidecar. A plain remove leaves the working directory and the host's
+ *    processes untouched — on a shared host they may belong to another install
+ *    (CHOO-2560). Sibling agents' files are never touched either way.
  *
  * The agent's location row is intentionally kept — locations are reusable
  * and other agents may still live there.
@@ -247,14 +262,17 @@ async function removeAgent(
     await stopRemoteWatcher(agentId).catch((error) => {
       log.warn('deleteAgent: failed to stop remote watcher', { agentId, error: String(error) });
     });
-    if (agent) await killRemoteSidecar(agent);
+    // The sidecar is host state, like the files: killing it under an agent
+    // another install still manages takes their agent offline. Only tear it
+    // down when the on-disk teardown was asked for.
+    if (agent && options.removeProvisionedFiles) await killRemoteSidecar(agent);
   } else {
     autoSessionWatcher.stopForAgent(agentId);
   }
 
   await setAutoSessionAgent(agentId, false);
 
-  if (agent && location) {
+  if (agent && location && options.removeProvisionedFiles) {
     await removeProvisionedFiles(agent, location).catch((error) => {
       log.warn('deleteAgent: failed to remove provisioned files', {
         agentId,
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/discover-loadable-agents.ts b/console/apps/switch-console-desktop/src/main/core/agents/discover-loadable-agents.ts
new file mode 100644
index 000000000..b43e7a13b
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/main/core/agents/discover-loadable-agents.ts
@@ -0,0 +1,280 @@
+import { SshExecutionContext } from '@main/core/execution-context/ssh-execution-context';
+import { sshConnectionIdForHost } from '@main/core/locations/location-transport';
+import { ensureSshConnected } from '@main/core/ssh/connect/connect-agent-ssh';
+import { fetchAgents, fetchMe } from '@main/core/switch-servers/gateway-client';
+import { getServer } from '@main/core/switch-servers/servers-store';
+import { log } from '@main/lib/logger';
+import type { AgentProviderId } from '@shared/core/providers/agent-provider-registry';
+import { sameApiEndpoint } from '@shared/core/switch-servers/switch-servers';
+import type { DiscoveredConfiguredAgent, ProviderSource } from './discover-configured-agents';
+import { discoverConfiguredAgents } from './discover-configured-agents';
+
+/**
+ * An agent found on a remote host that can be loaded into this Console.
+ *
+ * Merges server-assisted discovery (which carries owner attribution) with a
+ * bounded on-host scan (which catches unregistered agents). Server-attributed
+ * entries win on dedup so attribution is preserved.
+ */
+export type LoadableAgent = {
+  name: string;
+  dir: string;
+  switchAgentId: string;
+  apiEndpoint: string;
+  providerId: AgentProviderId | null;
+  providerSource: ProviderSource;
+  /** Whether this Console already has a row for this agent. */
+  alreadyAgent: boolean;
+  /** The agent's owner on the server, when known via server-assisted discovery. */
+  ownerName: string | null;
+  /** True when the signed-in user is the agent's owner on the server. */
+  viewerIsOwner: boolean;
+  /** The agent's server-side description, when known via server-assisted discovery. */
+  description: string | null;
+  /** The source that found this agent. */
+  source: 'server' | 'scan';
+  /** True when the on-disk endpoint does not match the server's URL. */
+  endpointMismatch: boolean;
+  /** When set, the agent cannot be loaded and this is the human-readable reason. */
+  blockedReason: string | null;
+};
+
+export type DiscoverLoadableAgentsParams = {
+  sshHost: string;
+  serverId: string;
+  /** When true, run a depth-limited `find` over `$HOME` in addition to the
+   *  cheap server-assisted discovery. Off by default — the walk can be slow
+   *  on large VMs. */
+  includeHomeScan?: boolean;
+};
+
+export type DiscoverLoadableAgentsResult = {
+  agents: LoadableAgent[];
+  /** The target server's API URL, for rendering endpoint mismatches legibly. */
+  serverApiUrl: string;
+};
+
+/**
+ * Discover agents on a remote host that can be loaded into this Console,
+ * merging two sources and deduping by `(dir, name)`.
+ *
+ * 1. **Server-assisted:** `GET /agents` for the deployment's agents with
+ *    `repo_dir`; confirm each dir on-host via `discoverConfiguredAgents`.
+ * 2. **Bounded `$HOME` scan:** depth-limited `find` under the host's `$HOME`
+ *    for dirs holding `.switch/agents/*.json`.
+ *
+ * Server-attributed entries win on dedup so owner attribution is preserved.
+ */
+export async function discoverLoadableAgentsOnHost(
+  params: DiscoverLoadableAgentsParams
+): Promise<DiscoverLoadableAgentsResult> {
+  const server = await getServer(params.serverId);
+  if (!server) throw new Error(`No Switch server with id ${params.serverId}`);
+
+  // Key: "dir\0name" → LoadableAgent. Server entries inserted first win.
+  const seen = new Map<string, LoadableAgent>();
+
+  // --- Source 1: Server-assisted discovery ---
+  try {
+    const remoteAgents = await fetchAgents(server);
+    // Marks rows the signed-in user owns; an auth failure degrades to not-owner.
+    const me = await fetchMe(server).catch(() => null);
+
+    // Collect distinct repo_dirs from agents whose known_agent_options carry one.
+    type ServerAgentInfo = {
+      ownerName: string | null;
+      ownerId: string | null;
+      description: string | null;
+    };
+    const dirOwners = new Map<string, Map<string, ServerAgentInfo>>();
+    for (const agent of remoteAgents) {
+      const repoDir =
+        agent.knownAgentOptions &&
+        typeof agent.knownAgentOptions === 'object' &&
+        typeof (agent.knownAgentOptions as Record<string, unknown>).repo_dir === 'string'
+          ? ((agent.knownAgentOptions as Record<string, unknown>).repo_dir as string)
+          : null;
+      if (!repoDir) continue;
+
+      if (!dirOwners.has(repoDir)) dirOwners.set(repoDir, new Map());
+      dirOwners.get(repoDir)!.set(agent.name, {
+        ownerName: agent.ownerName,
+        ownerId: agent.ownerId,
+        description: agent.description ?? null,
+      });
+    }
+
+    for (const [dir, nameOwners] of dirOwners) {
+      try {
+        const discovered = await discoverConfiguredAgents({
+          sshHost: params.sshHost,
+          dir,
+          serverId: params.serverId,
+        });
+        for (const agent of discovered) {
+          const key = `${dir}\0${agent.name}`;
+          const info = nameOwners.get(agent.name) ?? null;
+          seen.set(key, {
+            name: agent.name,
+            dir,
+            switchAgentId: agent.switchAgentId,
+            apiEndpoint: agent.apiEndpoint,
+            providerId: agent.providerId,
+            providerSource: agent.providerSource,
+            alreadyAgent: agent.alreadyAgent,
+            ownerName: info?.ownerName ?? null,
+            viewerIsOwner: !!(me && info?.ownerId && info.ownerId === me.id),
+            description: info?.description ?? null,
+            source: 'server',
+            endpointMismatch: !sameApiEndpoint(agent.apiEndpoint, server.apiUrl),
+            blockedReason: blockedReasonFor(agent, server.apiUrl),
+          });
+        }
+      } catch (error) {
+        log.warn('discoverLoadableAgentsOnHost: server-assisted dir scan failed', {
+          dir,
+          sshHost: params.sshHost,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+  } catch (error) {
+    log.warn('discoverLoadableAgentsOnHost: server-assisted discovery failed', {
+      serverId: params.serverId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  // --- Source 2: Bounded $HOME scan (opt-in) ---
+  if (!params.includeHomeScan) return { agents: [...seen.values()], serverApiUrl: server.apiUrl };
+  try {
+    const scannedDirs = await findSwitchAgentDirsOnHost(params.sshHost);
+    for (const dir of scannedDirs) {
+      try {
+        const discovered = await discoverConfiguredAgents({
+          sshHost: params.sshHost,
+          dir,
+          serverId: params.serverId,
+        });
+        for (const agent of discovered) {
+          const key = `${dir}\0${agent.name}`;
+          if (!seen.has(key)) {
+            seen.set(key, {
+              name: agent.name,
+              dir,
+              switchAgentId: agent.switchAgentId,
+              apiEndpoint: agent.apiEndpoint,
+              providerId: agent.providerId,
+              providerSource: agent.providerSource,
+              alreadyAgent: agent.alreadyAgent,
+              ownerName: null,
+              viewerIsOwner: false,
+              description: null,
+              source: 'scan',
+              endpointMismatch: !sameApiEndpoint(agent.apiEndpoint, server.apiUrl),
+              blockedReason: blockedReasonFor(agent, server.apiUrl),
+            });
+          }
+        }
+      } catch (error) {
+        log.warn('discoverLoadableAgentsOnHost: scan dir discovery failed', {
+          dir,
+          sshHost: params.sshHost,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+  } catch (error) {
+    log.warn('discoverLoadableAgentsOnHost: bounded scan failed', {
+      sshHost: params.sshHost,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+
+  return { agents: [...seen.values()], serverApiUrl: server.apiUrl };
+}
+
+function blockedReasonFor(agent: DiscoveredConfiguredAgent, serverApiUrl: string): string | null {
+  if (agent.alreadyAgent) return 'Already loaded in this Console';
+  if (!sameApiEndpoint(agent.apiEndpoint, serverApiUrl))
+    return 'Endpoint does not match this server';
+  return null;
+}
+
+/**
+ * Bounded depth-limited scan of `$HOME` on a remote host for directories
+ * containing `.switch/agents/*.json`. Prunes `node_modules` and every hidden
+ * directory except `.switch` itself — dot-trees like `.cargo`, `.npm` or
+ * `.vscode-server` hold hundreds of thousands of entries on a dev box and can
+ * never contain a working directory we would surface.
+ *
+ * Returns the parent working directories (the dirs that contain `.switch/`),
+ * not the `.switch/agents/` paths themselves.
+ */
+async function findSwitchAgentDirsOnHost(sshHost: string): Promise<string[]> {
+  const proxy = await ensureSshConnected(sshConnectionIdForHost(sshHost), sshHost);
+  const ctx = new SshExecutionContext(proxy);
+  let result: { stdout: string };
+  try {
+    result = await ctx.exec('sh', [
+      '-c',
+      [
+        'find "$HOME" -maxdepth 6',
+        '-type d \\( -name node_modules -o \\( -name ".*" ! -name .switch \\) \\) -prune',
+        '-o -type f -path "*/.switch/agents/*.json" -print',
+        '2>/dev/null',
+        '| sed "s|/\\.switch/agents/.*||"',
+        '| sort -u',
+      ].join(' '),
+    ]);
+  } catch (error) {
+    // Disclosed fallback: an exec failure must not read as "empty host", so
+    // leave a trace even though discovery continues with the server source.
+    log.warn('findSwitchAgentDirsOnHost: $HOME scan failed', {
+      sshHost,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return [];
+  }
+  return result.stdout
+    .trim()
+    .split('\n')
+    .filter((line) => line.length > 0);
+}
+
+/**
+ * Discover agents in a single manually-specified directory — the "scan a
+ * directory" fallback. A thin wrapper that calls the existing per-dir scan
+ * and attaches the same metadata shape as the merged discovery.
+ */
+export async function discoverLoadableAgentsInDir(params: {
+  sshHost: string;
+  dir: string;
+  serverId: string;
+}): Promise<{ agents: LoadableAgent[]; serverApiUrl: string }> {
+  const server = await getServer(params.serverId);
+  if (!server) throw new Error(`No Switch server with id ${params.serverId}`);
+
+  const discovered = await discoverConfiguredAgents({
+    sshHost: params.sshHost,
+    dir: params.dir,
+    serverId: params.serverId,
+  });
+
+  const agents = discovered.map((agent) => ({
+    name: agent.name,
+    dir: params.dir,
+    switchAgentId: agent.switchAgentId,
+    apiEndpoint: agent.apiEndpoint,
+    providerId: agent.providerId,
+    providerSource: agent.providerSource,
+    alreadyAgent: agent.alreadyAgent,
+    ownerName: null,
+    viewerIsOwner: false,
+    description: null,
+    source: 'scan' as const,
+    endpointMismatch: !sameApiEndpoint(agent.apiEndpoint, server.apiUrl),
+    blockedReason: blockedReasonFor(agent, server.apiUrl),
+  }));
+  return { agents, serverApiUrl: server.apiUrl };
+}
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/remove-loadable-agent-config.ts b/console/apps/switch-console-desktop/src/main/core/agents/remove-loadable-agent-config.ts
new file mode 100644
index 000000000..dafa03c4e
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/main/core/agents/remove-loadable-agent-config.ts
@@ -0,0 +1,44 @@
+import { log } from '@main/lib/logger';
+import { resolveWorkspaceFsFor } from './agent-workspace-fs';
+import { agentSettingsRelativePath } from './switch-settings-paths';
+
+export type RemoveLoadableAgentConfigParams = {
+  sshHost: string | null;
+  dir: string;
+  name: string;
+};
+
+export type RemoveLoadableAgentConfigResult =
+  | { removed: true }
+  | { removed: false; reason: 'not-found' };
+
+/**
+ * Delete an agent's on-disk config (`.switch/agents/<name>.json`) from a
+ * working directory, so a stale or wrong-endpoint entry surfaced by "Load
+ * existing agents" can be cleaned up in place (CHOO-2560).
+ *
+ * Deliberately host-file-only: the agent's registration on the Switch server
+ * is untouched (deregistering is the owner's call, made from an attached
+ * agent's own page), and no Console rows anywhere are affected. Callers
+ * should not offer this for agents already loaded in this Console — deleting
+ * the file under a managed agent breaks its launches.
+ */
+export async function removeLoadableAgentConfig(
+  params: RemoveLoadableAgentConfigParams
+): Promise<RemoveLoadableAgentConfigResult> {
+  const relPath = agentSettingsRelativePath(params.name);
+  const ctx = await resolveWorkspaceFsFor(params.sshHost, params.dir);
+  try {
+    const existing = await ctx.fs.read(relPath);
+    if (existing === null) return { removed: false, reason: 'not-found' };
+    await ctx.fs.delete(relPath);
+    log.info('removeLoadableAgentConfig: deleted agent config', {
+      sshHost: params.sshHost,
+      dir: params.dir,
+      name: params.name,
+    });
+    return { removed: true };
+  } finally {
+    ctx.close();
+  }
+}
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/utils.ts b/console/apps/switch-console-desktop/src/main/core/agents/utils.ts
index f3a542541..801b36b72 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/utils.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/utils.ts
@@ -17,6 +17,7 @@ export function mapAgentRowToAgent(row: AgentRow): Agent {
     serverId: row.serverId ?? null,
     status: row.status ?? null,
     autoApprove: row.autoApprove,
+    ownerName: row.ownerName ?? null,
     providerConfig: row.providerConfig ?? null,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.test.ts b/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.test.ts
index d3722681d..f0a806d0e 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.test.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.test.ts
@@ -10,6 +10,7 @@ import {
   SWITCH_SETTINGS_RELATIVE_PATH,
 } from './switch-settings-paths';
 import {
+  ExistingAgentCredentialsError,
   ForeignAgentCredentialsError,
   foreignCredentialsEndpoint,
   foreignCredentialsOwnerFs,
@@ -219,11 +220,14 @@ describe('writeNeutralAgentSettingsFs, against another install of Switch Console
       },
     });
 
+    // The caller passes expectedAgentId to confirm it owns the slot — without
+    // this, the same-endpoint guard refuses the write (CHOO-2560).
     await writeNeutralAgentSettingsFs(createPluginFs(dir), {
       slug: 'ours',
       apiEndpoint: 'https://switch.example.com',
       apiToken: 'new-token',
       agentId: 'new-agent',
+      expectedAgentId: 'old-agent',
     });
 
     const raw = await fs.readFile(path.join(dir, agentSettingsRelativePath('ours')), 'utf8');
@@ -234,6 +238,25 @@ describe('writeNeutralAgentSettingsFs, against another install of Switch Console
     });
   });
 
+  it('refuses when same-endpoint slot holds a different agent and no expectedAgentId is given (CHOO-2560)', async () => {
+    await seed('colleague', {
+      env: {
+        SWITCH_API_ENDPOINT: 'https://switch.example.com',
+        SWITCH_API_TOKEN: 'their-token',
+        SWITCH_AGENT_ID: 'their-agent',
+      },
+    });
+
+    await expect(
+      writeNeutralAgentSettingsFs(createPluginFs(dir), {
+        slug: 'colleague',
+        apiEndpoint: 'https://switch.example.com',
+        apiToken: 'our-token',
+        agentId: 'our-agent',
+      })
+    ).rejects.toBeInstanceOf(ExistingAgentCredentialsError);
+  });
+
   it('reports the owning server through foreignCredentialsOwnerFs, for a caller checking before it registers', async () => {
     await seed('shared-name', otherInstall);
     const workspaceFs = createPluginFs(dir);
diff --git a/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.ts b/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.ts
index 3ca57d23c..b9019e6ad 100644
--- a/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.ts
+++ b/console/apps/switch-console-desktop/src/main/core/agents/write-switch-settings.ts
@@ -367,6 +367,36 @@ export class ForeignAgentCredentialsError extends Error {
   }
 }
 
+/**
+ * The credentials file for this agent name already belongs to a different
+ * agent on the SAME Switch deployment. Writing would overwrite that agent's
+ * identity and destroy its API token — the same hazard as
+ * {@link ForeignAgentCredentialsError}, but between agents on the same server
+ * rather than across deployments (CHOO-2560).
+ */
+export class ExistingAgentCredentialsError extends Error {
+  readonly slug: string;
+  readonly relPath: string;
+  readonly existingAgentId: string;
+  readonly incomingAgentId: string;
+
+  constructor(params: {
+    slug: string;
+    relPath: string;
+    existingAgentId: string;
+    incomingAgentId: string;
+  }) {
+    super(
+      `${params.relPath} in this directory already holds credentials for agent ${params.existingAgentId} on this Switch server. Writing it would overwrite that agent's identity and destroy its API token, which cannot be recovered. Load the existing agent instead, or use a different agent name.`
+    );
+    this.name = 'ExistingAgentCredentialsError';
+    this.slug = params.slug;
+    this.relPath = params.relPath;
+    this.existingAgentId = params.existingAgentId;
+    this.incomingAgentId = params.incomingAgentId;
+  }
+}
+
 /**
  * Read the per-agent credentials slot for `slug` and report the Switch
  * deployment it already belongs to, when that is a different one. Callers use
@@ -383,6 +413,49 @@ export async function foreignCredentialsOwnerFs(
   return foreignCredentialsEndpoint(existingRaw, apiEndpoint);
 }
 
+/**
+ * The `SWITCH_AGENT_ID` already in a credentials slot when the file belongs to
+ * the SAME deployment — otherwise null (no file, not a provisioned agent, or a
+ * different deployment).
+ *
+ * This is the inverse of {@link foreignCredentialsEndpoint}: that one catches
+ * a different-server collision; this one catches a same-server collision where
+ * the identity exists on-disk but is unknown to this install's database — i.e.
+ * a colleague's agent that would be clobbered by a blind write.
+ *
+ * Pure: takes the existing file text, or null when no file exists. A failed
+ * read is not null — `PluginFs.read` throws on transport errors, and callers
+ * must let that propagate: mapping it to null would make a transient error
+ * read as "slot free" and clobber real credentials.
+ */
+export function existingAgentIdInSlot(
+  existingRaw: string | null,
+  apiEndpoint: string
+): string | null {
+  if (existingRaw === null) return null;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(existingRaw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+
+  const env = (parsed as Record<string, unknown>).env;
+  if (!env || typeof env !== 'object' || Array.isArray(env)) return null;
+
+  const existingEndpoint = (env as Record<string, unknown>).SWITCH_API_ENDPOINT;
+  if (typeof existingEndpoint !== 'string' || existingEndpoint.trim() === '') return null;
+
+  if (!sameApiEndpoint(existingEndpoint, apiEndpoint)) return null;
+
+  const agentId = (env as Record<string, unknown>).SWITCH_AGENT_ID;
+  if (typeof agentId !== 'string' || agentId.trim() === '') return null;
+
+  return agentId;
+}
+
 /**
  * Write an agent's provider-neutral per-agent Switch credentials over a
  * {@link PluginFs} (local disk or a remote repo dir via SFTP), keyed by `slug`
@@ -402,7 +475,7 @@ export async function foreignCredentialsOwnerFs(
  */
 export async function writeNeutralAgentSettingsFs(
   workspaceFs: PluginFs,
-  params: { slug: string } & SwitchSettingsCredentials
+  params: { slug: string; expectedAgentId?: string } & SwitchSettingsCredentials
 ): Promise<void> {
   const relPath = agentSettingsRelativePath(params.slug);
   const existingRaw = await workspaceFs.read(relPath);
@@ -416,6 +489,25 @@ export async function writeNeutralAgentSettingsFs(
     });
   }
 
+  // Defence in depth: if the slot holds a same-endpoint identity that is NOT
+  // the one we are about to write, refuse — it belongs to a colleague's agent
+  // and overwriting it would destroy their token (CHOO-2560). Callers that have
+  // already verified the overwrite is safe pass `expectedAgentId` to bypass this
+  // guard for their own agent (e.g. runAddAgent after its pre-mint DB lookup).
+  const slotAgentId = existingAgentIdInSlot(existingRaw, params.apiEndpoint);
+  if (
+    slotAgentId !== null &&
+    slotAgentId !== params.agentId &&
+    slotAgentId !== params.expectedAgentId
+  ) {
+    throw new ExistingAgentCredentialsError({
+      slug: params.slug,
+      relPath,
+      existingAgentId: slotAgentId,
+      incomingAgentId: params.agentId,
+    });
+  }
+
   if (!(await workspaceFs.exists(SWITCH_AGENTS_GITIGNORE_RELATIVE))) {
     await workspaceFs.write(SWITCH_AGENTS_GITIGNORE_RELATIVE, '*\n');
   }
diff --git a/console/apps/switch-console-desktop/src/main/core/switch-servers/backfill-agent-icons.test.ts b/console/apps/switch-console-desktop/src/main/core/switch-servers/backfill-agent-icons.test.ts
index b765f6040..90aee30fa 100644
--- a/console/apps/switch-console-desktop/src/main/core/switch-servers/backfill-agent-icons.test.ts
+++ b/console/apps/switch-console-desktop/src/main/core/switch-servers/backfill-agent-icons.test.ts
@@ -42,6 +42,7 @@ function agent(overrides: Partial<RemoteAgentSummary>): RemoteAgentSummary {
     ownerId: 'user-me',
     ownerName: 'me',
     knownAgentType: 'claude-code',
+    knownAgentOptions: null,
     addressingPolicy: null,
     iconUrl: null,
     createdAt: '2026-01-01T00:00:00Z',
diff --git a/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.db.test.ts b/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.db.test.ts
index b38f92171..f9167e769 100644
--- a/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.db.test.ts
+++ b/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.db.test.ts
@@ -82,6 +82,7 @@ describe('deleteAgentsForServer', () => {
 
     expect(mocks.deleteAgent).toHaveBeenCalledWith('agent-a', {
       deleteInSwitch: false,
+      removeProvisionedFiles: true,
       // Wiping a server is one action, not a person deleting each agent.
       trigger: 'server_teardown',
     });
diff --git a/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.ts b/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.ts
index 2a3ebd6e1..6fd47dbde 100644
--- a/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.ts
+++ b/console/apps/switch-console-desktop/src/main/core/switch-servers/delete-server-agents.ts
@@ -40,7 +40,13 @@ export async function deleteAgentsForServer(
 
   for (const row of rows) {
     try {
-      await deleteAgent(row.id, { deleteInSwitch: false, trigger: 'server_teardown' });
+      // A destroyed managed server's agents were provisioned by this install,
+      // so their on-disk files go with them.
+      await deleteAgent(row.id, {
+        deleteInSwitch: false,
+        removeProvisionedFiles: true,
+        trigger: 'server_teardown',
+      });
       deleted.push(row.id);
     } catch (error) {
       failed.push({ agentId: row.id, error: String(error) });
diff --git a/console/apps/switch-console-desktop/src/main/core/switch-servers/gateway-client.ts b/console/apps/switch-console-desktop/src/main/core/switch-servers/gateway-client.ts
index cf5b98038..55a1825a6 100644
--- a/console/apps/switch-console-desktop/src/main/core/switch-servers/gateway-client.ts
+++ b/console/apps/switch-console-desktop/src/main/core/switch-servers/gateway-client.ts
@@ -353,6 +353,7 @@ type AgentSummaryJson = {
   owner_id?: string | null;
   owner_name: string | null;
   known_agent_type: string | null;
+  known_agent_options?: Record<string, unknown> | null;
   addressing_policy?: AddressingPolicy | null;
   icon_url?: string | null;
   created_at: string;
@@ -371,6 +372,7 @@ function toRemoteAgentSummary(json: AgentSummaryJson): RemoteAgentSummary {
     ownerId: json.owner_id ?? null,
     ownerName: json.owner_name,
     knownAgentType: json.known_agent_type,
+    knownAgentOptions: json.known_agent_options ?? null,
     addressingPolicy: json.addressing_policy ?? null,
     iconUrl: json.icon_url ?? null,
     createdAt: json.created_at,
diff --git a/console/apps/switch-console-desktop/src/main/core/telemetry/events.ts b/console/apps/switch-console-desktop/src/main/core/telemetry/events.ts
index d8c676766..582bb22ca 100644
--- a/console/apps/switch-console-desktop/src/main/core/telemetry/events.ts
+++ b/console/apps/switch-console-desktop/src/main/core/telemetry/events.ts
@@ -51,6 +51,7 @@ export type TelemetryAgentCreateFailure =
   | 'unauthenticated'
   | 'name_conflict'
   | 'credentials_conflict'
+  | 'already_configured'
   | 'invalid_name'
   /**
    * The two the other way into this — dropping a folder on the sidebar — hits
diff --git a/console/apps/switch-console-desktop/src/main/db/schema.ts b/console/apps/switch-console-desktop/src/main/db/schema.ts
index 98ce833e0..539b0e919 100644
--- a/console/apps/switch-console-desktop/src/main/db/schema.ts
+++ b/console/apps/switch-console-desktop/src/main/db/schema.ts
@@ -161,6 +161,9 @@ export const agents = sqliteTable(
     // Defaults false for local agents; onboarding seeds it true for remote
     // agents (see onboard-agent). Editable per agent in location settings.
     autoApprove: integer('auto_approve', { mode: 'boolean' }).notNull().default(false),
+    // The display name of the agent's owner on the Switch server, set when the
+    // agent was loaded from another install rather than created here.
+    ownerName: text('owner_name'),
     // Per-agent, provider-specific launch config (Codex model / effort /
     // instructions folded into the agent's Codex profile). Null when unset.
     providerConfig: versionedJsonColumn(agentProviderConfig)('provider_config'),
diff --git a/console/apps/switch-console-desktop/src/main/index.ts b/console/apps/switch-console-desktop/src/main/index.ts
index 59a96b772..15b449016 100644
--- a/console/apps/switch-console-desktop/src/main/index.ts
+++ b/console/apps/switch-console-desktop/src/main/index.ts
@@ -11,6 +11,7 @@ import { registerAppScheme, setupAppProtocol } from './app/protocol';
 import { createMainWindow, getMainWindow } from './app/window';
 import { agentHookService } from './core/agent-hooks/agent-hook-service';
 import { reapOrphanedAgentRuntimes } from './core/agent-runtime/reap-orphaned-runtimes';
+import { bridgeAgentEventsToRenderer } from './core/agents/agent-events-renderer-bridge';
 import { migrateAgentStorage } from './core/agents/migrate-agent-storage';
 import { initializeRemoteDiscovery, initializeRemoteWatchers } from './core/agents/remote-watcher';
 import { resolveAgentServers } from './core/agents/resolve-servers';
@@ -231,6 +232,7 @@ void app.whenReady().then(async () => {
       log.error('Failed to initialise remote watchers at startup:', e);
     }
     try {
+      bridgeAgentEventsToRenderer();
       await initializeRemoteDiscovery();
     } catch (e) {
       log.error('Failed to initialise remote session discovery at startup:', e);
diff --git a/console/apps/switch-console-desktop/src/renderer/App.tsx b/console/apps/switch-console-desktop/src/renderer/App.tsx
index 3e5c3e088..05264a712 100644
--- a/console/apps/switch-console-desktop/src/renderer/App.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/App.tsx
@@ -1,4 +1,5 @@
 import { QueryClientProvider } from '@tanstack/react-query';
+import { AgentCrudEvents } from './app/agent-crud-events';
 import { AppMenuEvents } from './app/app-menu-events';
 import { Workspace } from './app/workspace';
 import { SessionFocusReporter } from './features/sessions/session-focus-reporter-mount';
@@ -20,6 +21,7 @@ function AppContent() {
         <TerminalPoolProvider>
           <WorkspaceViewProvider>
             <AppMenuEvents />
+            <AgentCrudEvents />
             <SessionFocusReporter />
             <SessionDeeplinkListener />
             <RightSidebarProvider>
diff --git a/console/apps/switch-console-desktop/src/renderer/app/agent-crud-events.tsx b/console/apps/switch-console-desktop/src/renderer/app/agent-crud-events.tsx
new file mode 100644
index 000000000..64b91b02f
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/renderer/app/agent-crud-events.tsx
@@ -0,0 +1,29 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import { agentsStore } from '@renderer/features/locations/stores/agents-store';
+import { getLocationManagerStore } from '@renderer/features/locations/stores/location-selectors';
+import { LOAD_AGENTS_QUERY_KEY } from '@renderer/features/remote-hosts/load-existing-agents-section';
+import { events } from '@renderer/lib/ipc';
+import { agentsChangedChannel } from '@shared/events/appEvents';
+
+/**
+ * React to agent CRUD from the main process (CHOO-2560): reload the sidebar's
+ * agents store AND location manager, and refetch any open "Load existing
+ * agents" discovery, so a created or removed agent is reflected everywhere
+ * without per-call-site invalidation.
+ */
+export function AgentCrudEvents() {
+  const queryClient = useQueryClient();
+
+  useEffect(
+    () =>
+      events.on(agentsChangedChannel, () => {
+        void agentsStore.load();
+        void getLocationManagerStore().reload();
+        void queryClient.invalidateQueries({ queryKey: [LOAD_AGENTS_QUERY_KEY] });
+      }),
+    [queryClient]
+  );
+
+  return null;
+}
diff --git a/console/apps/switch-console-desktop/src/renderer/app/modal-registry.ts b/console/apps/switch-console-desktop/src/renderer/app/modal-registry.ts
index ee1720368..22808fac9 100644
--- a/console/apps/switch-console-desktop/src/renderer/app/modal-registry.ts
+++ b/console/apps/switch-console-desktop/src/renderer/app/modal-registry.ts
@@ -3,6 +3,7 @@ import { AddAgentModal } from '@renderer/features/locations/components/add-agent
 import { DeleteAgentModal } from '@renderer/features/locations/components/delete-agent-modal';
 import { ResetAgentModal } from '@renderer/features/locations/components/reset-agent-modal';
 import { AddHostModal } from '@renderer/features/remote-hosts/add-host-modal';
+import { RemoveAgentConfigModal } from '@renderer/features/remote-hosts/remove-agent-config-modal';
 import { CreateSessionModal } from '@renderer/features/sessions/create-session-modal/create-session-modal';
 import { DeleteSessionModal } from '@renderer/features/sessions/delete-session-modal';
 import { RenameSessionModal } from '@renderer/features/sessions/rename-session-modal';
@@ -52,6 +53,7 @@ export const modalRegistry = {
   addAgentModal: createModal(AddAgentModal, { size: 'lg', dismissOnOutsideClick: false }),
   confirmActionModal: createModal(ConfirmActionDialog, { size: 'xs' }),
   deleteAgentModal: createModal(DeleteAgentModal, { size: 'sm' }),
+  removeAgentConfigModal: createModal(RemoveAgentConfigModal, { size: 'sm' }),
   resetAgentModal: createModal(ResetAgentModal, { size: 'sm' }),
   confirmExternalLinkModal: createModal(ExternalLinkChoiceDialog, { size: 'sm' }),
   unsavedChangesModal: createModal(UnsavedChangesDialog, { size: 'xs' }),
diff --git a/console/apps/switch-console-desktop/src/renderer/features/locations/components/add-agent-modal/add-agent-modal.tsx b/console/apps/switch-console-desktop/src/renderer/features/locations/components/add-agent-modal/add-agent-modal.tsx
index 435c23376..91c607534 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/locations/components/add-agent-modal/add-agent-modal.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/locations/components/add-agent-modal/add-agent-modal.tsx
@@ -293,6 +293,15 @@ export const AddAgentModal = observer(function AddAgentModal({
       });
       return;
     }
+    if (result.kind === 'already-configured') {
+      toast({
+        title: 'An agent with this name is already configured here',
+        description:
+          'This directory already holds credentials for an agent of that name. Load the existing agent instead of creating a new one.',
+        variant: 'destructive',
+      });
+      return;
+    }
     if (result.kind === 'invalid-name') {
       toast({
         title: 'Switch rejected these agent details',
diff --git a/console/apps/switch-console-desktop/src/renderer/features/locations/components/delete-agent-modal.tsx b/console/apps/switch-console-desktop/src/renderer/features/locations/components/delete-agent-modal.tsx
index b56fa6431..f1346e772 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/locations/components/delete-agent-modal.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/locations/components/delete-agent-modal.tsx
@@ -15,15 +15,21 @@ export type DeleteAgentModalArgs = {
   agentId: string;
   /** Display name for the agent (its Switch name, falling back to the location). */
   agentLabel: string;
+  /** The agent's host (null = this machine), for naming where its files live. */
+  sshHost: string | null;
+  /** The agent's working directory, for naming where its files live. */
+  dir: string | null;
 };
 
-/** What the confirm resolves with: whether to also delete the agent in Switch. */
-export type DeleteAgentModalResult = { deleteInSwitch: boolean };
+/** What the confirm resolves with: what to tear down beyond this Console's row. */
+export type DeleteAgentModalResult = { deleteInSwitch: boolean; removeProvisionedFiles: boolean };
 
 type Props = BaseModalProps<DeleteAgentModalResult> & DeleteAgentModalArgs;
 
-export function DeleteAgentModal({ agentLabel, onSuccess, onClose }: Props) {
+export function DeleteAgentModal({ agentLabel, sshHost, dir, onSuccess, onClose }: Props) {
   const [deleteInSwitch, setDeleteInSwitch] = useState(false);
+  const [removeProvisionedFiles, setRemoveProvisionedFiles] = useState(false);
+  const filesPlace = dir ? (sshHost ? `${sshHost}:${dir}` : dir) : null;
 
   return (
     <>
@@ -33,10 +39,32 @@ export function DeleteAgentModal({ agentLabel, onSuccess, onClose }: Props) {
       <DialogContentArea className="flex flex-col gap-4 pt-0">
         <p className="text-sm text-foreground-muted">
           <span className="font-medium text-foreground">{agentLabel}</span> will be removed from
-          Switch Console and the Switch credentials it stored on this machine will be cleared. The
-          folder stays on the filesystem.
+          Switch Console. Its working directory, the credentials stored there, and any running
+          sidecar are untouched unless you choose below.
         </p>
 
+        {filesPlace && (
+          <label className="group/field flex cursor-pointer items-start gap-2.5">
+            <Checkbox
+              checked={removeProvisionedFiles}
+              onCheckedChange={(checked) => setRemoveProvisionedFiles(checked === true)}
+              className="mt-0.5"
+            />
+            <span className="flex flex-col gap-0.5">
+              <span className="text-sm font-medium">
+                Also delete its files on <code className="break-all">{filesPlace}</code>
+              </span>
+              <span className="text-xs text-foreground-muted">
+                Removes the credentials and definition files provisioned in the working directory
+                and stops the agent{"'"}s sidecar.
+                {sshHost
+                  ? ' On a shared host these may belong to another install — an agent you loaded rather than created should usually keep them.'
+                  : ''}
+              </span>
+            </span>
+          </label>
+        )}
+
         <label className="group/field flex cursor-pointer items-start gap-2.5">
           <Checkbox
             checked={deleteInSwitch}
@@ -56,7 +84,10 @@ export function DeleteAgentModal({ agentLabel, onSuccess, onClose }: Props) {
         <Button variant="outline" onClick={onClose}>
           Cancel
         </Button>
-        <ConfirmButton variant="destructive" onClick={() => onSuccess({ deleteInSwitch })}>
+        <ConfirmButton
+          variant="destructive"
+          onClick={() => onSuccess({ deleteInSwitch, removeProvisionedFiles })}
+        >
           {deleteInSwitch ? 'Remove & delete in Switch' : 'Remove'}
         </ConfirmButton>
       </DialogFooter>
diff --git a/console/apps/switch-console-desktop/src/renderer/features/locations/components/location-titlebar.tsx b/console/apps/switch-console-desktop/src/renderer/features/locations/components/location-titlebar.tsx
index e1bf11047..4dc8dfbfe 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/locations/components/location-titlebar.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/locations/components/location-titlebar.tsx
@@ -184,7 +184,16 @@ export const LocationTitlebar = observer(function LocationTitlebar() {
 
   return (
     <Titlebar
-      leftSlot={<AgentCrumb agent={agent} />}
+      leftSlot={
+        <div className="flex items-center gap-2">
+          <AgentCrumb agent={agent} />
+          {agent?.ownerName && (
+            <span className="text-xs text-foreground-tertiary-passive">
+              loaded · by {agent.ownerName}
+            </span>
+          )}
+        </div>
+      }
       rightSlot={
         <div className="mr-1 flex items-center gap-1.5">
           {mounted &&
diff --git a/console/apps/switch-console-desktop/src/renderer/features/locations/hooks/use-confirm-delete-agent.tsx b/console/apps/switch-console-desktop/src/renderer/features/locations/hooks/use-confirm-delete-agent.tsx
index bc53689f0..9e7088214 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/locations/hooks/use-confirm-delete-agent.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/locations/hooks/use-confirm-delete-agent.tsx
@@ -34,14 +34,19 @@ export function useConfirmDeleteAgent() {
     if (!targetAgentId) return;
     const resolvedAgentId = targetAgentId;
 
+    const location = getLocationManagerStore().locations.get(locationId)?.data ?? null;
+
     showDeleteAgent({
       agentId: resolvedAgentId,
       agentLabel: locationLabel,
-      onSuccess: ({ deleteInSwitch }) => {
+      sshHost: location?.sshHost ?? null,
+      dir: location?.dir ?? null,
+      onSuccess: ({ deleteInSwitch, removeProvisionedFiles }) => {
         void (async () => {
           try {
             await getLocationManagerStore().removeAgent(locationId, resolvedAgentId, {
               deleteInSwitch,
+              removeProvisionedFiles,
             });
             // Refresh the detail views that list a location's agents (settings
             // sections, delete modal) so the removed agent drops and its siblings
diff --git a/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.test.ts b/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.test.ts
index ca400bed0..5954402f8 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.test.ts
+++ b/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.test.ts
@@ -77,6 +77,7 @@ function agent(overrides: Partial<Agent> = {}): Agent {
     serverId: 'server-1',
     status: null,
     autoApprove: false,
+    ownerName: null,
     providerConfig: null,
     createdAt: '2026-05-28T00:00:00.000Z',
     updatedAt: '2026-05-28T00:00:00.000Z',
@@ -211,6 +212,53 @@ describe('LocationManagerStore agent onboarding', () => {
   });
 });
 
+describe('LocationManagerStore reload', () => {
+  const stubLocation = {} as LocationStore;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.openLocation.mockResolvedValue({ success: true });
+  });
+
+  it('mounts a newly-appeared location on reload', async () => {
+    const store = new LocationManagerStore();
+    // First load: no locations, no agents.
+    mocks.getLocations.mockResolvedValueOnce([]);
+    mocks.getAgents.mockResolvedValueOnce([]);
+    await store.load();
+    expect(store.locations.size).toBe(0);
+
+    // An agent was loaded externally — reload should pick it up.
+    mocks.getLocations.mockResolvedValueOnce([location({ id: 'new-loc' })]);
+    mocks.getAgents.mockResolvedValueOnce([agent({ locationId: 'new-loc' })]);
+    await store.reload();
+    expect(store.locations.has('new-loc')).toBe(true);
+  });
+
+  it('drops a location whose last agent was removed on reload', async () => {
+    const store = new LocationManagerStore();
+    store.locations.set('stale-loc', stubLocation);
+
+    // The DB still has the location row but no agents point at it.
+    mocks.getLocations.mockResolvedValueOnce([location({ id: 'stale-loc' })]);
+    mocks.getAgents.mockResolvedValueOnce([]);
+    await store.reload();
+    expect(store.locations.has('stale-loc')).toBe(false);
+  });
+
+  it('preserves a pending-creation location during reload', async () => {
+    const store = new LocationManagerStore();
+    store.locations.set('onboarding-loc', stubLocation);
+    store.pendingCreationIds.add('onboarding-loc');
+
+    // A concurrent CRUD event triggers reload while onboarding is in flight.
+    mocks.getLocations.mockResolvedValueOnce([]);
+    mocks.getAgents.mockResolvedValueOnce([]);
+    await store.reload();
+    expect(store.locations.has('onboarding-loc')).toBe(true);
+  });
+});
+
 describe('LocationManagerStore removeAgent', () => {
   // removeAgent only gets/deletes the location by key, so a placeholder stands in
   // for the (heavy) real LocationStore.
@@ -231,11 +279,12 @@ describe('LocationManagerStore removeAgent', () => {
     const store = new LocationManagerStore();
     store.locations.set('loc', stubLocation);
 
-    await store.removeAgent('loc', 'a', { deleteInSwitch: false });
+    await store.removeAgent('loc', 'a', { deleteInSwitch: false, removeProvisionedFiles: false });
 
     expect(mocks.deleteAgent).toHaveBeenCalledWith({
       agentId: 'a',
       deleteInSwitch: false,
+      removeProvisionedFiles: false,
       trigger: 'user',
     });
     expect(store.locations.has('loc')).toBe(true);
@@ -250,11 +299,12 @@ describe('LocationManagerStore removeAgent', () => {
     const store = new LocationManagerStore();
     store.locations.set('loc', stubLocation);
 
-    await store.removeAgent('loc', 'a', { deleteInSwitch: true });
+    await store.removeAgent('loc', 'a', { deleteInSwitch: true, removeProvisionedFiles: false });
 
     expect(mocks.deleteAgent).toHaveBeenCalledWith({
       agentId: 'a',
       deleteInSwitch: true,
+      removeProvisionedFiles: false,
       trigger: 'user',
     });
     expect(store.locations.has('loc')).toBe(false);
@@ -269,9 +319,9 @@ describe('LocationManagerStore removeAgent', () => {
     const store = new LocationManagerStore();
     store.locations.set('loc', stubLocation);
 
-    await expect(store.removeAgent('loc', 'a', { deleteInSwitch: true })).rejects.toThrow(
-      'gateway down'
-    );
+    await expect(
+      store.removeAgent('loc', 'a', { deleteInSwitch: true, removeProvisionedFiles: false })
+    ).rejects.toThrow('gateway down');
     expect(store.locations.has('loc')).toBe(true);
     expect(agentsStore.byLocation.get('loc')?.map((x) => x.id)).toEqual(['a']);
   });
diff --git a/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.ts b/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.ts
index 27de5a71f..906d2530a 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.ts
+++ b/console/apps/switch-console-desktop/src/renderer/features/locations/stores/location-manager.ts
@@ -79,6 +79,13 @@ export class LocationManagerStore {
     const locationIdsWithAgents = new Set(agents.map((a) => a.locationId));
     const toMount: string[] = [];
     runInAction(() => {
+      // Drop locations whose last agent was removed since the previous load,
+      // but skip any mid-onboarding placeholder — it has no DB agent yet.
+      for (const id of this.locations.keys()) {
+        if (!locationIdsWithAgents.has(id) && !this.pendingCreationIds.has(id)) {
+          this.locations.delete(id);
+        }
+      }
       for (const loc of rawLocations) {
         if (!locationIdsWithAgents.has(loc.id)) continue;
         if (this.locations.has(loc.id)) continue;
@@ -297,6 +304,9 @@ export class LocationManagerStore {
           rpc.agents.deleteAgent({
             agentId: agent.id,
             deleteInSwitch: false,
+            // Removing a location forgets it here; files on disk (possibly a
+            // shared host's) stay put.
+            removeProvisionedFiles: false,
             trigger: 'user',
           })
         )
@@ -318,7 +328,7 @@ export class LocationManagerStore {
   async removeAgent(
     locationId: string,
     agentId: string,
-    options: { deleteInSwitch: boolean }
+    options: { deleteInSwitch: boolean; removeProvisionedFiles: boolean }
   ): Promise<void> {
     // A directory is a flat container of independent agents (CHOO-1440), so
     // deleting one must remove only that agent — its siblings, and the location
@@ -341,6 +351,7 @@ export class LocationManagerStore {
       await rpc.agents.deleteAgent({
         agentId,
         deleteInSwitch: options.deleteInSwitch,
+        removeProvisionedFiles: options.removeProvisionedFiles,
         trigger: 'user',
       });
       // Reconcile against the source of truth (also corrects the optimistic guess).
diff --git a/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/load-existing-agents-section.tsx b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/load-existing-agents-section.tsx
new file mode 100644
index 000000000..5b2890e03
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/load-existing-agents-section.tsx
@@ -0,0 +1,607 @@
+/**
+ * "Load existing agents" section for a remote host's page (CHOO-2560).
+ *
+ * Shows agents already configured on the host — by a colleague's Console or
+ * an earlier install — that this Console does not yet manage. The user
+ * selects which to load (attach); agents that need a provider pick get one
+ * inline. Already-loaded agents appear disabled.
+ *
+ * Discovery runs on demand when the user clicks "Discover agents".
+ */
+
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import {
+  ChevronDown,
+  ChevronRight,
+  Download,
+  FolderSearch,
+  Info,
+  RefreshCw,
+  ScanSearch,
+  Trash2,
+  X,
+} from 'lucide-react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { failureText } from '@renderer/lib/errors/describe-failure';
+import { toast } from '@renderer/lib/hooks/use-toast';
+import { rpc } from '@renderer/lib/ipc';
+import { useShowModal } from '@renderer/lib/modal/modal-provider';
+import { Button } from '@renderer/lib/ui/button';
+import { Checkbox } from '@renderer/lib/ui/checkbox';
+import { Input } from '@renderer/lib/ui/input';
+import { Label } from '@renderer/lib/ui/label';
+import { Progress } from '@renderer/lib/ui/progress';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@renderer/lib/ui/select';
+import { Spinner } from '@renderer/lib/ui/spinner';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@renderer/lib/ui/tooltip';
+import type { AgentProviderId } from '@shared/core/providers/agent-provider-registry';
+import { AGENT_PROVIDERS, getProvider } from '@shared/core/providers/agent-provider-registry';
+
+type LoadableAgentRow = {
+  name: string;
+  dir: string;
+  switchAgentId: string;
+  apiEndpoint: string;
+  providerId: AgentProviderId | null;
+  providerSource: string;
+  alreadyAgent: boolean;
+  ownerName: string | null;
+  viewerIsOwner: boolean;
+  description: string | null;
+  source: 'server' | 'scan';
+  endpointMismatch: boolean;
+  blockedReason: string | null;
+};
+
+export const LOAD_AGENTS_QUERY_KEY = 'load-existing-agents';
+
+export function LoadExistingAgentsSection({
+  sshHost,
+  serverId,
+  initiallyOpen = false,
+}: {
+  sshHost: string;
+  serverId: string;
+  initiallyOpen?: boolean;
+}) {
+  const [isOpen, setIsOpen] = useState(initiallyOpen);
+  const [scanRequested, setScanRequested] = useState(false);
+  const queryClient = useQueryClient();
+  const showRemoveConfig = useShowModal('removeAgentConfigModal');
+
+  const discovery = useQuery({
+    queryKey: [LOAD_AGENTS_QUERY_KEY, sshHost, serverId],
+    queryFn: () => rpc.agents.discoverLoadableAgentsOnHost({ sshHost, serverId }),
+    enabled: isOpen && scanRequested,
+  });
+
+  const [manualAgents, setManualAgents] = useState<LoadableAgentRow[]>([]);
+  // Server URL for endpoint-mismatch copy; either discovery source reports it.
+  const [manualServerApiUrl, setManualServerApiUrl] = useState<string | null>(null);
+  const serverApiUrl = discovery.data?.serverApiUrl ?? manualServerApiUrl;
+
+  const agents: LoadableAgentRow[] = useMemo(() => {
+    const auto = discovery.data?.agents ?? [];
+    if (manualAgents.length === 0) return auto;
+    const seen = new Set(auto.map((a) => `${a.dir}\0${a.name}`));
+    return [...auto, ...manualAgents.filter((a) => !seen.has(`${a.dir}\0${a.name}`))];
+  }, [discovery.data, manualAgents]);
+
+  const [providerOverrides, setProviderOverrides] = useState<Record<string, AgentProviderId>>({});
+
+  const setProviderFor = useCallback((key: string, providerId: AgentProviderId) => {
+    setProviderOverrides((prev) => ({ ...prev, [key]: providerId }));
+  }, []);
+
+  // Selection state: keys are "dir\0name".
+  const [selected, setSelected] = useState<Set<string>>(new Set());
+  const [expanded, setExpanded] = useState<Set<string>>(new Set());
+
+  const toggleAgent = useCallback((key: string) => {
+    setSelected((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  }, []);
+
+  const toggleExpanded = useCallback((key: string) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      return next;
+    });
+  }, []);
+
+  const selectableAgents = useMemo(() => agents.filter((a) => !a.blockedReason), [agents]);
+
+  const toggleAll = useCallback(() => {
+    if (selected.size === selectableAgents.length) {
+      setSelected(new Set());
+    } else {
+      setSelected(new Set(selectableAgents.map((a) => `${a.dir}\0${a.name}`)));
+    }
+  }, [selectableAgents, selected.size]);
+
+  const selectedByDir = useMemo(() => {
+    const byDir = new Map<
+      string,
+      Array<{ name: string; providerId: AgentProviderId; ownerName?: string | null }>
+    >();
+    for (const key of selected) {
+      const agent = agents.find((a) => `${a.dir}\0${a.name}` === key);
+      if (!agent) continue;
+      const pid = providerOverrides[key] ?? agent.providerId;
+      if (!pid) continue;
+      if (!byDir.has(agent.dir)) byDir.set(agent.dir, []);
+      byDir.get(agent.dir)!.push({ name: agent.name, providerId: pid, ownerName: agent.ownerName });
+    }
+    return byDir;
+  }, [selected, agents, providerOverrides]);
+
+  const allSelectedHaveProvider = useMemo(() => {
+    for (const key of selected) {
+      const agent = agents.find((a) => `${a.dir}\0${a.name}` === key);
+      if (!agent) continue;
+      if (!agent.providerId && !providerOverrides[key]) return false;
+    }
+    return true;
+  }, [selected, agents, providerOverrides]);
+
+  const canLoad = selected.size > 0 && allSelectedHaveProvider;
+
+  const loadMutation = useMutation({
+    mutationFn: async () => {
+      const results: string[] = [];
+      for (const [dir, dirAgents] of selectedByDir) {
+        const result = await rpc.agents.attachConfiguredAgents({
+          sshHost,
+          dir,
+          serverId,
+          agents: dirAgents,
+        });
+        if (result.success) {
+          results.push(...result.data.map((a: { name: string }) => a.name));
+        } else {
+          const e = result.error;
+          const msg =
+            'message' in e
+              ? e.message
+              : e.type === 'switch-agent-not-on-server'
+                ? `Agent ${e.agentId} not found on server ${e.serverName}`
+                : `Not signed in to server ${e.serverName}`;
+          throw new Error(msg);
+        }
+      }
+      return results;
+    },
+    onSuccess: async (names) => {
+      toast({
+        title: `Loaded ${names.length} agent${names.length === 1 ? '' : 's'}`,
+        description: names.join(', '),
+      });
+      setSelected(new Set());
+
+      // Mark loaded agents as blocked immediately so the label appears without
+      // waiting for the SSH round trip that a full refetch requires.
+      const loaded = new Set(names);
+      queryClient.setQueryData(
+        [LOAD_AGENTS_QUERY_KEY, sshHost, serverId],
+        (prev: { agents: LoadableAgentRow[]; serverApiUrl: string } | undefined) => {
+          if (!prev) return prev;
+          return {
+            ...prev,
+            agents: prev.agents.map((a) =>
+              loaded.has(a.name)
+                ? { ...a, alreadyAgent: true, blockedReason: 'Already loaded in this Console' }
+                : a
+            ),
+          };
+        }
+      );
+      // Also update manual agents so both lists stay consistent.
+      setManualAgents((prev) =>
+        prev.map((a) =>
+          loaded.has(a.name)
+            ? { ...a, alreadyAgent: true, blockedReason: 'Already loaded in this Console' }
+            : a
+        )
+      );
+
+      void queryClient.invalidateQueries({ queryKey: [LOAD_AGENTS_QUERY_KEY, sshHost, serverId] });
+    },
+    onError: (error) => {
+      toast({
+        title: 'Failed to load agents',
+        description: failureText(error, 'Could not load the selected agents.'),
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const removeMutation = useMutation({
+    mutationFn: async (agent: LoadableAgentRow) => {
+      const result = await rpc.agents.removeLoadableAgentConfig({
+        sshHost,
+        dir: agent.dir,
+        name: agent.name,
+      });
+      if (!result.removed) throw new Error('Config file not found on the host.');
+      return agent;
+    },
+    onSuccess: (agent) => {
+      toast({ title: 'Config deleted', description: `${agent.name} removed from ${agent.dir}` });
+      const key = `${agent.dir}\0${agent.name}`;
+      setManualAgents((prev) => prev.filter((a) => `${a.dir}\0${a.name}` !== key));
+      setSelected((prev) => {
+        const next = new Set(prev);
+        next.delete(key);
+        return next;
+      });
+      void queryClient.invalidateQueries({ queryKey: [LOAD_AGENTS_QUERY_KEY, sshHost, serverId] });
+    },
+    onError: (error) => {
+      toast({
+        title: 'Failed to delete config',
+        description: failureText(error, 'Could not delete the config file.'),
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const confirmRemove = useCallback(
+    (agent: LoadableAgentRow) => {
+      showRemoveConfig({
+        agentName: agent.name,
+        dir: agent.dir,
+        sshHost,
+        onSuccess: () => removeMutation.mutate(agent),
+      });
+    },
+    [showRemoveConfig, sshHost, removeMutation]
+  );
+
+  const [manualDir, setManualDir] = useState('');
+  const manualScan = useMutation({
+    mutationFn: (dir: string) => rpc.agents.discoverLoadableAgentsInDir({ sshHost, dir, serverId }),
+    onSuccess: (found) => {
+      setManualServerApiUrl(found.serverApiUrl);
+      setManualAgents((prev) => {
+        const keys = new Set(prev.map((a) => `${a.dir}\0${a.name}`));
+        return [
+          ...prev,
+          ...found.agents.filter((a: LoadableAgentRow) => !keys.has(`${a.dir}\0${a.name}`)),
+        ];
+      });
+      setManualDir('');
+    },
+  });
+
+  const deepScan = useMutation({
+    mutationFn: () =>
+      rpc.agents.discoverLoadableAgentsOnHost({ sshHost, serverId, includeHomeScan: true }),
+    onSuccess: (result) => {
+      queryClient.setQueryData([LOAD_AGENTS_QUERY_KEY, sshHost, serverId], result);
+    },
+  });
+
+  const [deepScanProgress, setDeepScanProgress] = useState(0);
+  const deepScanStartRef = useRef(0);
+  useEffect(() => {
+    if (!deepScan.isPending) {
+      setDeepScanProgress(0);
+      return;
+    }
+    deepScanStartRef.current = Date.now();
+    const ESTIMATED_DURATION = 30_000;
+    const id = setInterval(() => {
+      const elapsed = Date.now() - deepScanStartRef.current;
+      setDeepScanProgress(Math.min(100, (elapsed / ESTIMATED_DURATION) * 100));
+    }, 200);
+    return () => clearInterval(id);
+  }, [deepScan.isPending]);
+
+  const providerOptions = AGENT_PROVIDERS.filter((p) => p.detectable !== false);
+
+  return (
+    <section className="pt-2">
+      <button
+        type="button"
+        className="flex w-full items-center gap-1 px-3 py-2 text-left"
+        onClick={() =>
+          setIsOpen((prev) => {
+            if (prev) setScanRequested(false);
+            return !prev;
+          })
+        }
+      >
+        {isOpen ? <ChevronDown className="size-4" /> : <ChevronRight className="size-4" />}
+        <Label className="cursor-pointer">Load existing agents</Label>
+      </button>
+
+      {isOpen && (
+        <div className="space-y-3 px-3 pb-2">
+          {!scanRequested ? (
+            <div className="flex items-center gap-2">
+              <Button size="sm" variant="outline" onClick={() => setScanRequested(true)}>
+                <ScanSearch className="size-4" /> Discover agents
+              </Button>
+              <span className="text-xs text-foreground-muted">
+                Check this host for agents to load
+              </span>
+            </div>
+          ) : discovery.isLoading ? (
+            <div className="flex items-center gap-2 text-sm text-foreground-muted">
+              <Spinner /> Checking registered agents on this host…
+            </div>
+          ) : deepScan.isPending ? (
+            <div className="space-y-2">
+              <div className="flex items-center justify-between text-sm text-foreground-muted">
+                <span>Walking home directory on {sshHost}…</span>
+                <Button size="sm" variant="ghost" onClick={() => deepScan.reset()}>
+                  <X className="size-3" /> Cancel
+                </Button>
+              </div>
+              <Progress value={deepScanProgress} />
+            </div>
+          ) : discovery.isError ? (
+            <p className="text-xs text-destructive">
+              {failureText(discovery.error, 'Could not scan the host.')}
+            </p>
+          ) : agents.length === 0 ? (
+            <div className="space-y-1">
+              <p className="text-sm text-foreground-muted">
+                No registered agents found in this host's known directories. Scan a specific
+                directory below.
+              </p>
+              <Tooltip>
+                <TooltipTrigger>
+                  <Button size="sm" variant="outline" onClick={() => deepScan.mutate()}>
+                    <ScanSearch className="size-4" /> Deep scan
+                  </Button>
+                </TooltipTrigger>
+                <TooltipContent>
+                  Scans the full filesystem on this host. May take a while on large VMs.
+                </TooltipContent>
+              </Tooltip>
+            </div>
+          ) : (
+            <>
+              <div className="flex items-center justify-between">
+                {selectableAgents.length > 0 && (
+                  <button
+                    type="button"
+                    className="text-xs text-foreground-muted hover:text-foreground"
+                    onClick={toggleAll}
+                  >
+                    {selected.size > 0 && selected.size === selectableAgents.length
+                      ? 'Deselect all'
+                      : 'Select all'}
+                  </button>
+                )}
+                <div className="flex items-center gap-1">
+                  <Tooltip>
+                    <TooltipTrigger>
+                      <Button size="sm" variant="outline" onClick={() => deepScan.mutate()}>
+                        <ScanSearch className="size-3" /> Deep scan
+                      </Button>
+                    </TooltipTrigger>
+                    <TooltipContent>
+                      Scans the full filesystem on this host. May take a while on large VMs.
+                    </TooltipContent>
+                  </Tooltip>
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    disabled={discovery.isFetching}
+                    onClick={() =>
+                      void queryClient.invalidateQueries({
+                        queryKey: [LOAD_AGENTS_QUERY_KEY, sshHost, serverId],
+                      })
+                    }
+                  >
+                    <RefreshCw className={`size-3 ${discovery.isFetching ? 'animate-spin' : ''}`} />
+                    Rescan
+                  </Button>
+                </div>
+              </div>
+
+              <div className="divide-y divide-border rounded-md border">
+                {agents.map((agent) => {
+                  const key = `${agent.dir}\0${agent.name}`;
+                  const blocked = !!agent.blockedReason;
+                  const needsProvider = !agent.providerId && !providerOverrides[key];
+                  const isSelected = selected.has(key);
+                  const isExpanded = expanded.has(key);
+
+                  return (
+                    <div key={key}>
+                      <div className="flex items-center gap-3 px-3 py-2">
+                        <Checkbox
+                          checked={isSelected}
+                          disabled={blocked}
+                          onCheckedChange={() => toggleAgent(key)}
+                        />
+                        <div className="min-w-0 flex-1">
+                          <div className="flex items-center gap-2">
+                            <span className="truncate text-sm font-medium">{agent.name}</span>
+                            {agent.blockedReason && (
+                              <span className="shrink-0 text-xs text-destructive">
+                                {agent.blockedReason}
+                              </span>
+                            )}
+                          </div>
+                          <div className="flex items-center gap-2 text-xs text-foreground-muted">
+                            <span className="truncate">{agent.dir}</span>
+                            {agent.ownerName && <span>· by {agent.ownerName}</span>}
+                            {agent.providerId && (
+                              <span>
+                                · {getProvider(agent.providerId)?.name ?? agent.providerId}
+                              </span>
+                            )}
+                          </div>
+                          {agent.endpointMismatch ? (
+                            <p className="text-xs text-foreground-muted">
+                              Registered against <code>{agent.apiEndpoint}</code>
+                              {serverApiUrl && (
+                                <>
+                                  ; this server is <code>{serverApiUrl}</code>
+                                </>
+                              )}
+                            </p>
+                          ) : (
+                            !blocked &&
+                            agent.ownerName && (
+                              <p className="text-xs text-foreground-muted">
+                                Session access: yes · rooms: policy admits only its owner
+                                {agent.viewerIsOwner
+                                  ? ' (you)'
+                                  : `, ask ${agent.ownerName} to widen`}
+                              </p>
+                            )
+                          )}
+                        </div>
+                        {!blocked && needsProvider && (
+                          <Select
+                            value={providerOverrides[key] ?? ''}
+                            onValueChange={(v) => setProviderFor(key, v as AgentProviderId)}
+                          >
+                            <SelectTrigger className="w-36">
+                              <SelectValue placeholder="Provider" />
+                            </SelectTrigger>
+                            <SelectContent>
+                              {providerOptions.map((p) => (
+                                <SelectItem key={p.id} value={p.id}>
+                                  {p.name}
+                                </SelectItem>
+                              ))}
+                            </SelectContent>
+                          </Select>
+                        )}
+                        <Button
+                          size="sm"
+                          variant="ghost"
+                          className="shrink-0 px-2 text-foreground-muted hover:text-foreground"
+                          aria-label={`${isExpanded ? 'Hide' : 'Show'} details for ${agent.name}`}
+                          onClick={() => toggleExpanded(key)}
+                        >
+                          <Info className="size-3.5" />
+                        </Button>
+                        <Button
+                          size="sm"
+                          variant="ghost"
+                          className="shrink-0 px-2 text-foreground-muted hover:text-destructive"
+                          aria-label={`Delete ${agent.name}'s config from this host`}
+                          disabled={agent.alreadyAgent || removeMutation.isPending}
+                          title={
+                            agent.alreadyAgent
+                              ? 'Loaded in this Console — remove it from the agent itself'
+                              : 'Delete this config file from the host'
+                          }
+                          onClick={() => confirmRemove(agent)}
+                        >
+                          <Trash2 className="size-3.5" />
+                        </Button>
+                      </div>
+                      {isExpanded && (
+                        <div className="space-y-1 border-t border-dashed border-border px-3 py-2 pl-10 text-xs">
+                          {agent.description && (
+                            <p className="text-foreground">{agent.description}</p>
+                          )}
+                          <dl className="grid grid-cols-[auto_1fr] gap-x-3 gap-y-0.5 text-foreground-muted">
+                            <dt>Agent ID</dt>
+                            <dd className="truncate font-mono">{agent.switchAgentId}</dd>
+                            <dt>Endpoint</dt>
+                            <dd className="truncate font-mono">{agent.apiEndpoint}</dd>
+                            <dt>Directory</dt>
+                            <dd className="truncate font-mono">{agent.dir}</dd>
+                            <dt>Provider</dt>
+                            <dd>
+                              {agent.providerId
+                                ? `${getProvider(agent.providerId)?.name ?? agent.providerId} (${agent.providerSource})`
+                                : 'unknown — pick one to load'}
+                            </dd>
+                            {agent.ownerName && (
+                              <>
+                                <dt>Owner</dt>
+                                <dd>
+                                  {agent.ownerName}
+                                  {agent.viewerIsOwner ? ' (you)' : ''}
+                                </dd>
+                              </>
+                            )}
+                            <dt>Found via</dt>
+                            <dd>
+                              {agent.source === 'server' ? 'server registration' : 'host scan'}
+                            </dd>
+                          </dl>
+                        </div>
+                      )}
+                    </div>
+                  );
+                })}
+              </div>
+            </>
+          )}
+
+          {/* Manual directory scan fallback */}
+          <div className="flex items-center gap-2">
+            <FolderSearch className="size-4 shrink-0 text-foreground-muted" />
+            <Input
+              value={manualDir}
+              placeholder="Scan a directory (absolute path)"
+              className="flex-1"
+              onChange={(e) => setManualDir(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === 'Enter' && manualDir.trim()) manualScan.mutate(manualDir.trim());
+              }}
+            />
+            <Button
+              size="sm"
+              variant="outline"
+              disabled={!manualDir.trim() || manualScan.isPending}
+              onClick={() => manualScan.mutate(manualDir.trim())}
+            >
+              {manualScan.isPending ? <Spinner /> : 'Scan'}
+            </Button>
+          </div>
+          {manualScan.isError && (
+            <p className="text-xs text-destructive">
+              {failureText(manualScan.error, 'Could not scan the directory.')}
+            </p>
+          )}
+
+          {/* Load button */}
+          {agents.length > 0 && (
+            <div className="flex justify-end">
+              <Button
+                size="sm"
+                disabled={!canLoad || loadMutation.isPending}
+                onClick={() => loadMutation.mutate()}
+              >
+                {loadMutation.isPending ? (
+                  <>
+                    <Spinner /> Loading…
+                  </>
+                ) : (
+                  <>
+                    <Download className="size-4" /> Load {selected.size} agent
+                    {selected.size === 1 ? '' : 's'}
+                  </>
+                )}
+              </Button>
+            </div>
+          )}
+        </div>
+      )}
+    </section>
+  );
+}
diff --git a/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/remove-agent-config-modal.tsx b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/remove-agent-config-modal.tsx
new file mode 100644
index 000000000..95eea0b11
--- /dev/null
+++ b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/remove-agent-config-modal.tsx
@@ -0,0 +1,57 @@
+import type { BaseModalProps } from '@renderer/lib/modal/modal-provider';
+import { Button } from '@renderer/lib/ui/button';
+import { ConfirmButton } from '@renderer/lib/ui/confirm-button';
+import {
+  DialogContentArea,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@renderer/lib/ui/dialog';
+
+export type RemoveAgentConfigModalArgs = {
+  /** The agent's name (also the config file's stem). */
+  agentName: string;
+  /** The working directory holding the config, for the confirmation copy. */
+  dir: string;
+  /** The host the directory lives on. */
+  sshHost: string;
+};
+
+export type RemoveAgentConfigModalResult = { confirmed: true };
+
+type Props = BaseModalProps<RemoveAgentConfigModalResult> & RemoveAgentConfigModalArgs;
+
+/**
+ * Confirm deleting an agent's on-disk config from a remote host — the cleanup
+ * action in "Load existing agents" (CHOO-2560). Host-file-only by design: the
+ * server registration and other Consoles are untouched, and the copy says so.
+ */
+export function RemoveAgentConfigModal({ agentName, dir, sshHost, onSuccess, onClose }: Props) {
+  return (
+    <>
+      <DialogHeader showCloseButton={false}>
+        <DialogTitle>Delete agent config from host</DialogTitle>
+      </DialogHeader>
+      <DialogContentArea className="flex flex-col gap-3 pt-0">
+        <p className="text-sm text-foreground-muted">
+          This deletes <span className="font-medium text-foreground">{agentName}</span>
+          {"'"}s config file (<code>.switch/agents/{agentName}.json</code>) in{' '}
+          <code className="break-all">{dir}</code> on{' '}
+          <span className="font-medium text-foreground">{sshHost}</span>.
+        </p>
+        <p className="text-xs text-foreground-muted">
+          The agent{"'"}s registration on the Switch server is not affected, and neither is any
+          Console already running it. The file{"'"}s API token cannot be recovered.
+        </p>
+      </DialogContentArea>
+      <DialogFooter>
+        <Button variant="outline" onClick={onClose}>
+          Cancel
+        </Button>
+        <ConfirmButton variant="destructive" onClick={() => onSuccess({ confirmed: true })}>
+          Delete config
+        </ConfirmButton>
+      </DialogFooter>
+    </>
+  );
+}
diff --git a/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-host-view.tsx b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-host-view.tsx
index e4feda9b2..b8b34f509 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-host-view.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-host-view.tsx
@@ -31,9 +31,11 @@ import { Spinner } from '@renderer/lib/ui/spinner';
 import { StatusBadge } from '@renderer/lib/ui/status-badge';
 import { deriveHostStatus } from '@shared/core/remote-hosts/host-status';
 import { isHostBlocked } from '@shared/core/remote-hosts/reachability';
+import { switchServersStore } from '../../switch-servers/switch-servers-store';
 import { hostReachabilityStore } from '../host-reachability-store';
 import { hostSetupStore } from '../host-setup-store';
 import { HostUnreachablePanel } from '../host-unreachable-panel';
+import { LoadExistingAgentsSection } from '../load-existing-agents-section';
 import { SetupDetailSheet, type SheetTarget } from '../setup/setup-detail-sheet';
 import {
   AgentTypeRowItem,
@@ -51,7 +53,7 @@ import {
   useSkipSetupStep,
   useUpdateSetupStep,
 } from '../setup/use-host-setup';
-import { REMOTE_HOSTS_QUERY_KEY } from './remote-hosts-view';
+import { consumeJustAddedHost, REMOTE_HOSTS_QUERY_KEY } from './remote-hosts-view';
 
 function useSshHost(): string {
   return useParams('remoteHost').params.sshHost;
@@ -59,6 +61,7 @@ function useSshHost(): string {
 
 export const RemoteHostMainPanel = observer(function RemoteHostMainPanel() {
   const sshHost = useSshHost();
+  const [justAdded] = useState(() => consumeJustAddedHost(sshHost));
   const { navigate } = useNavigate();
 
   const hosts = useQuery({
@@ -100,6 +103,17 @@ export const RemoteHostMainPanel = observer(function RemoteHostMainPanel() {
     startPrepare();
   }, [blocked, plan.isLoading, startPrepare]);
 
+  // Resolve the Switch server for this host: prefer a managed server on this
+  // host, then the active server, then the first available. Read the
+  // observables outside useMemo so MobX tracks them and React sees them change.
+  const servers = switchServersStore.servers;
+  const activeServer = switchServersStore.activeServer;
+  const serverId = useMemo(() => {
+    const managed = servers.find((s) => s.sshHost === sshHost && s.managed);
+    if (managed) return managed.id;
+    return activeServer?.id ?? servers[0]?.id ?? null;
+  }, [sshHost, servers, activeServer]);
+
   const status = deriveHostStatus(reachability, plan.data ?? null);
   const { prerequisites, agentTypes } = useMemo(
     () => groupPlanSteps(plan.data ?? null),
@@ -265,6 +279,14 @@ export const RemoteHostMainPanel = observer(function RemoteHostMainPanel() {
                     ))}
                   </section>
                 )}
+
+                {serverId && (
+                  <LoadExistingAgentsSection
+                    sshHost={sshHost}
+                    serverId={serverId}
+                    initiallyOpen={justAdded}
+                  />
+                )}
               </div>
             )}
 
diff --git a/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-hosts-view.tsx b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-hosts-view.tsx
index dd3783789..95760bd76 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-hosts-view.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/remote-hosts/views/remote-hosts-view.tsx
@@ -35,6 +35,22 @@ import { useAllHostSetupPlans } from '../setup/use-host-setup';
 
 export const REMOTE_HOSTS_QUERY_KEY = ['remote-hosts'];
 
+/**
+ * Volatile flag: the SSH host alias just added by the Add Host modal, consumed
+ * once by `remote-host-view.tsx` to auto-expand the Load Existing Agents
+ * section on the post-add-host page visit.
+ */
+export let justAddedHost: string | null = null;
+
+/** Consume the flag — returns the value and clears it. */
+export function consumeJustAddedHost(sshHost: string): boolean {
+  if (justAddedHost === sshHost) {
+    justAddedHost = null;
+    return true;
+  }
+  return false;
+}
+
 type HostFilter = 'all' | 'ready' | 'attention';
 
 type RemoteHost = { sshHost: string; name: string };
@@ -201,7 +217,8 @@ export const RemoteHostsSettingsPage = observer(function RemoteHostsSettingsPage
                 onboarded: sshHosts,
                 onAdded: (sshHost) => {
                   invalidate();
-                  openHost(sshHost);
+                  justAddedHost = sshHost;
+                  navigate('remoteHost', { sshHost });
                 },
               })
             }
diff --git a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/server-agents-view.tsx b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/server-agents-view.tsx
index d8cd684d2..093dde3a5 100644
--- a/console/apps/switch-console-desktop/src/renderer/features/switch-servers/server-agents-view.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/features/switch-servers/server-agents-view.tsx
@@ -123,6 +123,11 @@ const AgentCard = observer(function AgentCard({
             {provider ? `${provider} · ` : ''}
             {sshHost ?? 'this computer'}
           </div>
+          {agent.ownerName && (
+            <div className="truncate text-xs text-foreground-tertiary-passive">
+              loaded · by {agent.ownerName}
+            </div>
+          )}
         </div>
       </div>
 
diff --git a/console/apps/switch-console-desktop/src/renderer/tests/browser/palette-agent-icon.test.tsx b/console/apps/switch-console-desktop/src/renderer/tests/browser/palette-agent-icon.test.tsx
index 7bd3b8a25..59b5e5d75 100644
--- a/console/apps/switch-console-desktop/src/renderer/tests/browser/palette-agent-icon.test.tsx
+++ b/console/apps/switch-console-desktop/src/renderer/tests/browser/palette-agent-icon.test.tsx
@@ -36,6 +36,7 @@ const AGENT: Agent = {
   serverId: SERVER_ID,
   status: null,
   autoApprove: false,
+  ownerName: null,
   providerConfig: null,
   createdAt: '2026-01-01T00:00:00.000Z',
   updatedAt: '2026-01-01T00:00:00.000Z',
@@ -61,6 +62,7 @@ function remoteAgent(iconUrl: string | null): RemoteAgentSummary {
     ownerId: null,
     ownerName: null,
     knownAgentType: 'claude-code',
+    knownAgentOptions: null,
     addressingPolicy: null,
     iconUrl,
     createdAt: '2026-01-01T00:00:00.000Z',
diff --git a/console/apps/switch-console-desktop/src/shared/core/agents/agents.ts b/console/apps/switch-console-desktop/src/shared/core/agents/agents.ts
index 649a68c2e..58d073034 100644
--- a/console/apps/switch-console-desktop/src/shared/core/agents/agents.ts
+++ b/console/apps/switch-console-desktop/src/shared/core/agents/agents.ts
@@ -26,6 +26,9 @@ export type Agent = {
    * "bypass permissions" flag. Defaults false for local agents and true for
    * remote agents (seeded at onboarding); editable per agent. */
   autoApprove: boolean;
+  /** The agent's owner on the Switch server, set when the agent was loaded from
+   * another install. Null for agents this Console created. */
+  ownerName: string | null;
   /** Per-agent, provider-specific launch config (e.g. Codex model / effort /
    * instructions). Null when unset. */
   providerConfig: AgentProviderConfig | null;
@@ -47,6 +50,8 @@ export type CreateAgentParams = {
   /** Seed for the per-agent bypass-permissions flag: false for local agents,
    * true for remote agents. */
   autoApprove: boolean;
+  /** The agent's owner on the Switch server, when loaded from another install. */
+  ownerName?: string | null;
   /** Optional per-agent provider config set at creation. */
   providerConfig?: AgentProviderConfig | null;
 };
diff --git a/console/apps/switch-console-desktop/src/shared/core/switch-servers/switch-servers.ts b/console/apps/switch-console-desktop/src/shared/core/switch-servers/switch-servers.ts
index bd7840f5e..5ac0427ad 100644
--- a/console/apps/switch-console-desktop/src/shared/core/switch-servers/switch-servers.ts
+++ b/console/apps/switch-console-desktop/src/shared/core/switch-servers/switch-servers.ts
@@ -184,6 +184,10 @@ export type RemoteAgentSummary = {
   ownerId: string | null;
   ownerName: string | null;
   knownAgentType: string | null;
+  /** The agent's known-agent options, including `repo_dir` when the server
+   * recorded one. Null for agents registered before the field existed or when
+   * the server omits it. */
+  knownAgentOptions: Record<string, unknown> | null;
   /** Who may address the agent, or null when it is open to everyone. On the
    * summary as well as the detail, so "which of these agents answers only its
    * owner" is one list read rather than a read per agent. Null also for a
@@ -713,6 +717,10 @@ export type ProvisionAgentResult =
    * the Switch deployment at `endpoint` — another install's agent. Refused
    * before minting, so nothing was created. */
   | { kind: 'credentials-conflict'; endpoint: string }
+  /** The working directory already holds credentials for this name on the SAME
+   * server, but the agent is unknown to this install — a colleague's agent.
+   * Refused before minting to avoid destroying their token (CHOO-2560). */
+  | { kind: 'already-configured' }
   | RegisterIdentityFailure;
 
 /**
diff --git a/console/apps/switch-console-desktop/src/shared/events/appEvents.ts b/console/apps/switch-console-desktop/src/shared/events/appEvents.ts
index cae27d74f..de74bcc79 100644
--- a/console/apps/switch-console-desktop/src/shared/events/appEvents.ts
+++ b/console/apps/switch-console-desktop/src/shared/events/appEvents.ts
@@ -18,6 +18,17 @@ export const externalLinkOpenRequestedChannel = defineEvent<{ url: string }>(
   'external-link:open-requested'
 );
 
+/**
+ * An agent row was created, updated or deleted in the main process
+ * (main → renderer). Bridges the main-only `agentEvents` bus so renderer
+ * stores and queries can react to agent CRUD from any path — Add Agent,
+ * Load existing agents, Remove agent — without each call site having to
+ * remember a manual refetch (CHOO-2560).
+ */
+export const agentsChangedChannel = defineEvent<{ kind: 'created' | 'updated' | 'deleted' }>(
+  'agents:changed'
+);
+
 /**
  * A mouse back/forward button pressed on Windows, where those buttons arrive as
  * an `app-command` on the window rather than as a mouse event in the page.
diff --git a/console/docs/screenshots/load-existing-agents-expanded.png b/console/docs/screenshots/load-existing-agents-expanded.png
new file mode 100644
index 0000000000000000000000000000000000000000..38753cfcf5d44fc67152de6959f8c404c5719673
GIT binary patch
literal 141106
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

literal 0
HcmV?d00001

diff --git a/console/packages/plugins/src/agents/impl/opencode/skill-file.ts b/console/packages/plugins/src/agents/impl/opencode/skill-file.ts
index 348304a1a..fb45a6e32 100644
--- a/console/packages/plugins/src/agents/impl/opencode/skill-file.ts
+++ b/console/packages/plugins/src/agents/impl/opencode/skill-file.ts
@@ -799,6 +799,7 @@ failure-mode tools are covered in the sections just above.
 - \`list_room_groups\` — the group tree rooms are organised into.
 - \`get_room_group_detail\` — one group's rooms and child groups.
 - \`create_room_group\` — provision a new room group.
+- \`create_room_from_yaml\` — provision a room or group from a YAML template.
 - \`list_agents\` — every agent on the instance, with optional filters.
 - \`get_agent_detail\` — one agent's config, capabilities and sessions.
 - \`update_agent_detail\` — change an agent you own.
diff --git a/core/switch_core/bridges/agent/operations/definitions.py b/core/switch_core/bridges/agent/operations/definitions.py
index b461768d9..9e4887e4f 100644
--- a/core/switch_core/bridges/agent/operations/definitions.py
+++ b/core/switch_core/bridges/agent/operations/definitions.py
@@ -30,7 +30,8 @@
 from switch_core.bridges.agent.protocol.instructions import build_room_instructions
 from switch_core.bridges.agent.protocol.service import ProtocolService
 from switch_core.bridges.agent.protocol.types import IntegrationProfile
-from switch_core.db.models import CollaborationBridge
+from switch_core.db.models import CollaborationBridge, User
+from switch_core.rooms_yaml import GroupSpec, RoomYamlService
 
 logger = logging.getLogger(__name__)
 
@@ -1552,6 +1553,78 @@ async def get_room_group_detail(group_id: str) -> dict[str, Any]:
     return await protocol.get_room_group_detail(agent_id, group_id)
 
 
+@operation
+async def create_room_from_yaml(
+    yaml: str,
+    inputs: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Provision a room or group of rooms from a YAML template.
+
+    Parses the YAML document (a ``room:`` or ``group:`` template, optionally
+    with ``params:`` declarations) and provisions the result — the agent-side
+    mirror of the gateway's ``POST /rooms/from-yaml``.
+
+    Args:
+        yaml: The YAML template text. Must contain a top-level ``room:`` key
+            (single room) or ``group:`` key (group of rooms with links).
+            May include a ``params:`` block declaring parameters with
+            defaults, descriptions and constraints; parameter placeholders
+            in the template are interpolated before provisioning.
+        inputs: Optional dict of parameter values to supply when the template
+            declares ``params:``. Keys that match a declared parameter
+            override its default; required parameters with no default must
+            be supplied here or provisioning fails with a clear error
+            naming the missing input.
+
+    Returns:
+        For a single room: ``{room_id, room_name, attached_reference_ids,
+        created_reference_ids, created_document_ids, role_names,
+        failed_attachments}``.
+        For a group: ``{group_id, group_name, rooms: [...], errors: [...]}``.
+    """
+    agent_id = get_agent_id()
+    protocol = get_protocol()
+
+    async with protocol.session_factory() as session:
+        agent = await protocol.agent_store.get(session, agent_id)
+        if agent is None:
+            raise ValueError(f"Unknown agent: {agent_id}")
+        if agent.owner_id is None:
+            raise ValueError(
+                f"Agent {agent_id} has no owner and cannot provision rooms"
+            )
+        owner_is_admin = False
+        owner = await session.get(User, agent.owner_id)
+        owner_is_admin = owner is not None and owner.role == "admin"
+
+    owner_id: str = agent.owner_id
+
+    rooms_yaml = RoomYamlService(
+        room_service=protocol.room_service,
+        resource_service=protocol.resource_service,
+        room_store=protocol.room_store,
+        agent_store=protocol.agent_store,
+        bridge_store=protocol.bridge_store,
+        external_user_store=protocol.external_user_store,
+        room_group_store=protocol.room_group_store,
+        room_role_store=protocol.room_role_store,
+        session_factory=protocol.session_factory,
+    )
+
+    spec = rooms_yaml.parse(yaml, inputs=inputs)
+
+    if isinstance(spec, GroupSpec):
+        return (
+            await rooms_yaml.provision_group(
+                spec, user_id=owner_id, is_admin=owner_is_admin
+            )
+        ).model_dump()
+
+    return (
+        await rooms_yaml.provision(spec, user_id=owner_id, is_admin=owner_is_admin)
+    ).model_dump()
+
+
 @operation
 async def list_agents(
     name_contains: str | None = None,
diff --git a/core/switch_core/db/models.py b/core/switch_core/db/models.py
index dda48abda..91db96e0a 100644
--- a/core/switch_core/db/models.py
+++ b/core/switch_core/db/models.py
@@ -317,6 +317,10 @@ class Room(Base):
             unique=True,
             postgresql_where=text("external_channel_id IS NOT NULL"),
         ),
+        # group_id is a foreign key with no index, so listing rooms by group
+        # and the ON DELETE SET NULL when a group is removed both scan the
+        # table. Mirrors ix_agents_parent_agent_id.
+        Index("ix_rooms_group_id", "group_id"),
     )
 
     id: Mapped[str] = mapped_column(Text, primary_key=True, default=_uuid)
diff --git a/core/switch_core/migrations/versions/a1c7e2f9b430_index_rooms_group_id.py b/core/switch_core/migrations/versions/a1c7e2f9b430_index_rooms_group_id.py
new file mode 100644
index 000000000..abc13a943
--- /dev/null
+++ b/core/switch_core/migrations/versions/a1c7e2f9b430_index_rooms_group_id.py
@@ -0,0 +1,29 @@
+"""index rooms.group_id
+
+group_id is a foreign key with no index, so listing rooms by group and the
+ON DELETE SET NULL when a group is removed both scan the rooms table. Mirrors
+ix_agents_parent_agent_id.
+
+Revision ID: a1c7e2f9b430
+Revises: c8e4a10b7f36
+Create Date: 2026-09-09 00:00:00.000000
+
+"""
+
+from collections.abc import Sequence
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "a1c7e2f9b430"
+down_revision: str | None = "c8e4a10b7f36"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_index("ix_rooms_group_id", "rooms", ["group_id"])
+
+
+def downgrade() -> None:
+    op.drop_index("ix_rooms_group_id", table_name="rooms")
diff --git a/core/switch_core/migrations/versions/b47e0c39a1f5_merge_oidc_identities_and_group_id_index_heads.py b/core/switch_core/migrations/versions/b47e0c39a1f5_merge_oidc_identities_and_group_id_index_heads.py
new file mode 100644
index 000000000..705a51d17
--- /dev/null
+++ b/core/switch_core/migrations/versions/b47e0c39a1f5_merge_oidc_identities_and_group_id_index_heads.py
@@ -0,0 +1,29 @@
+"""merge the oidc identities and rooms.group_id index heads
+
+Two migrations landed in parallel off the same parent, leaving the chain with
+two heads. `alembic upgrade head` is ambiguous with more than one, and the
+service runs exactly that at startup, so a deployment not already sitting on
+one of the two refuses to boot. Neither head carries schema of its own that the
+other needs; this only rejoins them.
+
+Revision ID: b47e0c39a1f5
+Revises: 04f27f37e474, a1c7e2f9b430
+Create Date: 2026-09-10
+
+"""
+
+from collections.abc import Sequence
+
+# revision identifiers, used by Alembic.
+revision: str = "b47e0c39a1f5"
+down_revision: str | Sequence[str] | None = ("04f27f37e474", "a1c7e2f9b430")
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    pass
+
+
+def downgrade() -> None:
+    pass
diff --git a/core/tests/switch_core/bridges/agent/operations/test_create_room_from_yaml.py b/core/tests/switch_core/bridges/agent/operations/test_create_room_from_yaml.py
new file mode 100644
index 000000000..3f6d481de
--- /dev/null
+++ b/core/tests/switch_core/bridges/agent/operations/test_create_room_from_yaml.py
@@ -0,0 +1,340 @@
+"""Behavioral tests for the create_room_from_yaml operation (CHOO-2666).
+
+Exercises the full operation path: YAML in → room/group provisioned, with
+error cases for missing inputs and (separately) authorization. Uses the same
+FakeRoomService pattern as test_rooms_yaml.py — real PostgreSQL, no Matrix.
+"""
+
+from __future__ import annotations
+
+import uuid
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+import pytest_asyncio
+from sqlalchemy import insert, select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from switch_core.bridges.agent.operations import context as op_context
+from switch_core.bridges.agent.operations.callctx import (
+    CallContext,
+    reset_call_context,
+    set_call_context,
+)
+from switch_core.bridges.agent.operations.definitions import create_room_from_yaml
+from switch_core.bridges.resource.service import ResourceService
+from switch_core.db.models import (
+    Agent,
+    ApiKey,
+    Client,
+    Room,
+    RoomGroup,
+    RoomLink,
+    User,
+    room_agents,
+)
+from switch_core.db.stores.agent_store import AgentStore
+from switch_core.db.stores.collaboration_bridge_store import CollaborationBridgeStore
+from switch_core.db.stores.document_store import DocumentStore
+from switch_core.db.stores.external_user_store import ExternalUserStore
+from switch_core.db.stores.package_store import PackageStore
+from switch_core.db.stores.reference_store import ReferenceStore
+from switch_core.db.stores.reference_type_store import ReferenceTypeStore
+from switch_core.db.stores.room_group_store import RoomGroupStore
+from switch_core.db.stores.room_link_store import RoomLinkStore
+from switch_core.db.stores.room_role_store import RoomRoleStore
+from switch_core.db.stores.room_store import RoomStore
+from switch_core.room_service import RoomCreateConfig, RoomCreateResult
+
+
+class FakeRoomService:
+    """DB-only stand-in — same as test_rooms_yaml.py."""
+
+    def __init__(
+        self,
+        session_factory: async_sessionmaker[AsyncSession],
+        agent_store: AgentStore,
+    ) -> None:
+        self._sf = session_factory
+        self._agents = agent_store
+
+    async def create_room(self, config: RoomCreateConfig) -> RoomCreateResult:
+        async with self._sf() as session:
+            agent_ids: list[str] = []
+            if config.agent_names:
+                agents = await self._agents.get_by_names(session, config.agent_names)
+                name_to_id = {a.name: a.id for a in agents}
+                missing = [n for n in config.agent_names if n not in name_to_id]
+                if missing:
+                    raise ValueError(f"Unknown agents: {', '.join(missing)}")
+                agent_ids = [name_to_id[n] for n in config.agent_names]
+
+            room = Room(
+                matrix_room_id=f"!{uuid.uuid4().hex}:test.local",
+                name=config.name,
+                description=config.description,
+                channel_type=config.channel_type or "channel_public",
+                bridge_id=config.bridge_id,
+                instructions=config.instructions,
+                created_by=config.created_by,
+                owner_id=config.owner_id,
+                read_visibility=config.read_visibility,
+                write_visibility=config.write_visibility,
+                group_id=config.group_id,
+            )
+            session.add(room)
+            await session.flush()
+            for aid in agent_ids:
+                await session.execute(
+                    insert(room_agents).values(room_id=room.id, agent_id=aid)
+                )
+            await session.commit()
+            return RoomCreateResult(room=room, failed_attachments=[])
+
+
+async def _make_agent(session: AsyncSession, name: str, user_id: str) -> Agent:
+    api_key = ApiKey(
+        user_id=user_id,
+        key_hash=f"hash-{name}",
+        encrypted_key="enc",
+        label=name,
+        type="agent",
+    )
+    client = Client(
+        matrix_user_id=f"@{name}:test.local",
+        display_name=name,
+        type="agent",
+    )
+    session.add_all([api_key, client])
+    await session.flush()
+    agent = Agent(
+        name=name,
+        description=f"{name} desc",
+        agent_type="always_on",
+        connector_type="claude_code",
+        integration_profile={"connection_model": "always_on"},
+        client_id=client.id,
+        api_key_id=api_key.id,
+        owner_id=user_id,
+    )
+    session.add(agent)
+    await session.flush()
+    return agent
+
+
+@pytest_asyncio.fixture
+async def env(session_factory: async_sessionmaker[AsyncSession]):
+    """Seed a user + agent and wire up a fake protocol for the operation."""
+    agent_store = AgentStore()
+    resource_service = ResourceService(
+        reference_store=ReferenceStore(),
+        reference_type_store=ReferenceTypeStore(),
+        document_store=DocumentStore(),
+        package_store=PackageStore(),
+        room_link_store=RoomLinkStore(),
+        session_factory=session_factory,
+    )
+
+    fake_protocol = SimpleNamespace(
+        session_factory=session_factory,
+        agent_store=agent_store,
+        room_service=FakeRoomService(session_factory, agent_store),
+        resource_service=resource_service,
+        room_store=RoomStore(),
+        bridge_store=CollaborationBridgeStore(),
+        external_user_store=ExternalUserStore(),
+        room_group_store=RoomGroupStore(),
+        room_role_store=RoomRoleStore(),
+    )
+
+    async with session_factory() as session:
+        user = User(name="alice", email="alice@example.com", role="member")
+        session.add(user)
+        await session.flush()
+        user_id = user.id
+        agent = await _make_agent(session, "claude-code.alice", user_id)
+        await _make_agent(session, "claude-code.bob", user_id)
+        await session.commit()
+        agent_id = agent.id
+
+    old_protocol = op_context._protocol
+    op_context.init_operations_protocol(fake_protocol)  # type: ignore[arg-type]
+    try:
+        yield {
+            "agent_id": agent_id,
+            "user_id": user_id,
+            "session_factory": session_factory,
+        }
+    finally:
+        op_context._protocol = old_protocol
+
+
+SINGLE_ROOM_YAML = """\
+version: 0
+room:
+  name: "Test Room"
+  description: "A test room"
+  agents: ["claude-code.alice"]
+"""
+
+PARAMETERIZED_YAML = """\
+version: 0
+params:
+  project:
+    type: string
+room:
+  name: "{project} room"
+  description: "Room for {project}"
+  agents: ["claude-code.alice"]
+"""
+
+GROUP_YAML = """\
+version: 0
+params:
+  team:
+    type: string
+group:
+  name: "{team} group"
+rooms:
+  - name: "{team} main"
+    description: "Main room"
+    agents: ["claude-code.alice"]
+  - name: "{team} support"
+    description: "Support room"
+    agents: ["claude-code.bob"]
+links:
+  - from: "{team} main"
+    to: "{team} support"
+    label: support
+"""
+
+MISSING_REQUIRED_YAML = """\
+version: 0
+params:
+  project:
+    type: string
+room:
+  name: "{project} room"
+  description: "Room for {project}"
+  agents: ["claude-code.alice"]
+"""
+
+
+def _with_agent(env: dict[str, Any]):
+    """Set call context for the agent and return a cleanup token."""
+    return set_call_context(CallContext(agent_id=env["agent_id"], session_key=None))
+
+
+@pytest.mark.asyncio
+async def test_single_room_provisioned(env):
+    """A minimal room: YAML → room created with the right name and agent."""
+    token = _with_agent(env)
+    try:
+        result = await create_room_from_yaml(yaml=SINGLE_ROOM_YAML)
+    finally:
+        reset_call_context(token)
+
+    assert result["room_name"] == "Test Room"
+    assert result["room_id"]
+
+    async with env["session_factory"]() as session:
+        room = await session.get(Room, result["room_id"])
+        assert room is not None
+        assert room.name == "Test Room"
+
+
+@pytest.mark.asyncio
+async def test_single_room_with_params(env):
+    """A parameterized template: inputs are interpolated into the room."""
+    token = _with_agent(env)
+    try:
+        result = await create_room_from_yaml(
+            yaml=PARAMETERIZED_YAML, inputs={"project": "Atlas"}
+        )
+    finally:
+        reset_call_context(token)
+
+    assert result["room_name"] == "Atlas room"
+
+
+@pytest.mark.asyncio
+async def test_group_provisioned_with_links(env):
+    """A group template: rooms + links created."""
+    token = _with_agent(env)
+    try:
+        result = await create_room_from_yaml(yaml=GROUP_YAML, inputs={"team": "alpha"})
+    finally:
+        reset_call_context(token)
+
+    assert result["group_name"] == "alpha group"
+    assert len(result["rooms"]) == 2
+    room_names = {r["room_name"] for r in result["rooms"]}
+    assert room_names == {"alpha main", "alpha support"}
+
+    async with env["session_factory"]() as session:
+        group = await session.get(RoomGroup, result["group_id"])
+        assert group is not None
+        assert group.name == "alpha group"
+
+        links = (await session.execute(select(RoomLink))).scalars().all()
+        assert len(links) == 1
+        assert links[0].label == "support"
+
+
+@pytest.mark.asyncio
+async def test_missing_required_input_raises_nothing_created(env):
+    """Missing a required param → ValueError, no room created."""
+    token = _with_agent(env)
+    try:
+        with pytest.raises(ValueError, match="project"):
+            await create_room_from_yaml(yaml=MISSING_REQUIRED_YAML)
+    finally:
+        reset_call_context(token)
+
+    async with env["session_factory"]() as session:
+        rooms = (await session.execute(select(Room))).scalars().all()
+        assert len(rooms) == 0
+
+
+@pytest.mark.asyncio
+async def test_no_owner_raises(env):
+    """An agent with no owner_id cannot provision."""
+    sf = env["session_factory"]
+    async with sf() as session:
+        # Create an ownerless agent
+        api_key = ApiKey(
+            user_id=env["user_id"],
+            key_hash="hash-orphan",
+            encrypted_key="enc",
+            label="orphan",
+            type="agent",
+        )
+        client = Client(
+            matrix_user_id="@orphan:test.local",
+            display_name="orphan",
+            type="agent",
+        )
+        session.add_all([api_key, client])
+        await session.flush()
+        agent = Agent(
+            name="orphan",
+            description="no owner",
+            agent_type="always_on",
+            connector_type="claude_code",
+            integration_profile={"connection_model": "always_on"},
+            client_id=client.id,
+            api_key_id=api_key.id,
+            owner_id=None,
+        )
+        session.add(agent)
+        await session.flush()
+        orphan_id = agent.id
+        await session.commit()
+
+    token = set_call_context(CallContext(agent_id=orphan_id, session_key=None))
+    try:
+        with pytest.raises(ValueError, match="no owner"):
+            await create_room_from_yaml(yaml=SINGLE_ROOM_YAML)
+    finally:
+        reset_call_context(token)
diff --git a/core/tests/switch_core/bridges/agent/test_mcp_tool_surface.py b/core/tests/switch_core/bridges/agent/test_mcp_tool_surface.py
index 274b8a9ba..9bef7dd33 100644
--- a/core/tests/switch_core/bridges/agent/test_mcp_tool_surface.py
+++ b/core/tests/switch_core/bridges/agent/test_mcp_tool_surface.py
@@ -78,6 +78,7 @@ async def test_documented_tools_exist(tool_names: set[str]) -> None:
         "list_room_groups",
         "create_room_group",
         "get_room_group_detail",
+        "create_room_from_yaml",
         "list_agents",
         "get_agent_detail",
         "update_agent_detail",