From 16b4ec2b21da8ea4bbca4f520daadc44999878bc Mon Sep 17 00:00:00 2001
From: Soushi888 <sacha.pignot@protonmail.com>
Date: Tue, 3 Nov 2026 20:31:45 -0500
Subject: [PATCH] feat(ui): Moss group context for groups and NDOs

Inside Moss the Moss group is the group: the tool instance's provisioned group
cell is the one Nondominium group, joined automatically with no invite code.
The profile comes from profilesClient, the role from myAccountabilitiesPerGroup,
and NDO clones are created through the WeaveClient. A layer choice in
LobbyServiceResolved keeps the Lobby DNA, Group DNA and invite codes for the
standalone build.

NDO clones are not registered as public: Moss 0.16.0-rc.5 cannot register a
clone that carries DNA properties (PUBLIC_NDO_CLONES, see #162).
---
 CHANGELOG.md                                  |   1 +
 documentation/IMPLEMENTATION_STATUS.md        |   2 +-
 .../specifications/moss-integration.md        |  23 ++-
 .../specifications/ui_architecture.md         |   2 +-
 ui/src/lib/components/group/GroupView.svelte  |  20 ++-
 .../components/lobby/LobbyProfileBar.svelte   |  20 ++-
 ui/src/lib/components/lobby/NdoBrowser.svelte |   7 +-
 ui/src/lib/components/shell/Sidebar.svelte    |  37 +++-
 ui/src/lib/moss/group-cell.spec.ts            |  55 ++++++
 ui/src/lib/moss/group-cell.ts                 |  31 ++++
 ui/src/lib/moss/ndo-clone.spec.ts             |  59 +++++++
 ui/src/lib/moss/ndo-clone.ts                  |  43 +++++
 ui/src/lib/moss/profile.spec.ts               |  73 ++++++++
 ui/src/lib/moss/profile.ts                    |  64 +++++++
 .../lib/services/holochain.service.svelte.ts  |  22 ++-
 ui/src/lib/services/zomes/lobby.service.ts    |  55 +++++-
 ui/src/lib/services/zomes/moss-lobby.spec.ts  | 163 +++++++++++++++++
 ui/src/lib/services/zomes/moss-lobby.ts       | 167 ++++++++++++++++++
 ui/src/lib/stores/moss.store.svelte.ts        |  49 +++++
 ui/src/routes/+layout.svelte                  |   6 +
 20 files changed, 858 insertions(+), 41 deletions(-)
 create mode 100644 ui/src/lib/moss/group-cell.spec.ts
 create mode 100644 ui/src/lib/moss/group-cell.ts
 create mode 100644 ui/src/lib/moss/ndo-clone.spec.ts
 create mode 100644 ui/src/lib/moss/ndo-clone.ts
 create mode 100644 ui/src/lib/moss/profile.spec.ts
 create mode 100644 ui/src/lib/moss/profile.ts
 create mode 100644 ui/src/lib/services/zomes/moss-lobby.spec.ts
 create mode 100644 ui/src/lib/services/zomes/moss-lobby.ts
 create mode 100644 ui/src/lib/stores/moss.store.svelte.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eb36f1dd..20ffb74f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,6 +26,7 @@ NDO over a live DHT.
   with two agents and one group (`bun run tool-dev`), `@theweave/api` in the UI, and a
   connection mode that takes the conductor client from Moss. The standalone build is
   unchanged. See `documentation/specifications/moss-integration.md`.
+- **Moss group context.** Inside Moss the Moss group is the group: the tool instance's `group` cell is the one Nondominium group, joined automatically with no invite code, the profile comes from Moss, the role from the Moss accountabilities, and NDO clones are created through the `WeaveClient`. Standalone keeps the Lobby, the Group DNA and invite links.
 - **Lobby DNA** as the entry point. Groups are announced here for discovery, and NDOs are
   browsed and filtered across every group the agent belongs to.
 - **Group DNA, one cloned cell per group.** Each group is its own DHT with its own
diff --git a/documentation/IMPLEMENTATION_STATUS.md b/documentation/IMPLEMENTATION_STATUS.md
index 969d2790..efd68510 100644
--- a/documentation/IMPLEMENTATION_STATUS.md
+++ b/documentation/IMPLEMENTATION_STATUS.md
@@ -296,7 +296,7 @@ There is no `get_all_groups` extern in a Group cell; each cell represents one is
 Nondominium runs as a Moss tool in `weave` dev mode. Standalone (Lobby, Group DNA, invite codes) is unchanged.
 
 - ✅ **Scaffold (#163).** `weave/weave.dev.config.ts` (two agents, one group, tool served from `localhost:8888`), `bun run tool-dev`, `@theweave/api` in `ui/`, host detection and the Moss connection mode in `ui/src/lib/moss/`, an empty `AppletServices`. The UI connects through the applet client Moss hands it.
-- ❌ **Moss group context (#164).** Profiles from Moss, roles from `myAccountabilitiesPerGroup()`, the instance's `group` cell as the Nondominium group, NDO clones through the `WeaveClient`. Not yet implemented: inside Moss the Lobby and invite-code flows are not adapted.
+- ✅ **Moss group context (#164).** Inside Moss the profile comes from `profilesClient`, the role from `myAccountabilitiesPerGroup()`, the tool instance's provisioned `group` cell is the one Nondominium group (the tool installer creates its profile, every other member joins it automatically, no invite code), and NDO clones are created through the `WeaveClient`. Standalone keeps the Lobby DNA, Group DNA and invite codes. Known gap: NDO clones are not registered as public to the Moss group, because Moss rc.5 cannot register a clone that carries DNA properties (see [moss-integration.md](specifications/moss-integration.md)).
 - ❌ **NDOs as assets (#165).** WAL, `getAssetInfo`, `search`, asset view.
 
 See [moss-integration.md](specifications/moss-integration.md).
diff --git a/documentation/specifications/moss-integration.md b/documentation/specifications/moss-integration.md
index fd9e816f..2883bead 100644
--- a/documentation/specifications/moss-integration.md
+++ b/documentation/specifications/moss-integration.md
@@ -1,6 +1,6 @@
 # Moss Integration
 
-**Status:** v0.1.0 pilot, in progress. The tool scaffold and dev config are implemented (#163). The Moss group context (#164) and NDOs as assets (#165) follow. Supersedes the "Moss Integration Contract" in [lobby-architecture.md](lobby-architecture.md) §9 where they differ.
+**Status:** v0.1.0 pilot, in progress. The tool scaffold and dev config (#163) and the Moss group context (#164) are implemented. NDOs as assets (#165) follows. Supersedes the "Moss Integration Contract" in [lobby-architecture.md](lobby-architecture.md) §9 where they differ.
 
 Moss is the Weave host (lightningrodlabs/moss). In the v0.1.0 pilot Nondominium runs as a **tool** inside Moss, started with the `weave` CLI in dev mode. The standalone build (Lobby DNA, Group DNA, invite codes) keeps compiling and running unchanged; the pilot ships Moss only.
 
@@ -55,7 +55,26 @@ hc-connect.ts  connectHolochainClient()
 
 Moss mode is a connection mode (`HolochainConnectionMode` gains `'moss'`). The cross-group view is not implemented: a cross-group render throws.
 
+## The Moss group context (#164)
+
+Inside Moss the standalone Lobby model is replaced behind one seam, `LobbyServiceResolved` in `lobby.service.ts`: it is `MossLobbyServiceLive` when the page is hosted by Moss and `LobbyServiceLive` otherwise. Stores, `NdoService` and components see the same `LobbyService` interface in both.
+
+| Concern | Standalone | Inside Moss |
+|---|---|---|
+| Groups | Lobby DNA announces clones of the Group DNA | One group: the tool instance's provisioned `group` cell (`MOSS_GROUP_ID = 'moss'`) |
+| Joining | Invite code or link | Automatic: the tool installer (`toolInstaller`) creates the `GroupProfile`, named after the Moss group; every other member waits for it to gossip, then calls `join_group` |
+| Profile | `LobbyUserProfile` form, localStorage | `profilesClient`, mapped to the same `LobbyUserProfile` shape |
+| Role | none | `myAccountabilitiesPerGroup()`, strongest of Member, Steward, Progenitor, shown in the sidebar |
+| NDO clone | `AppWebsocket.createCloneCell` | `WeaveClient.createCloneCell(req, PUBLIC_NDO_CLONES)` |
+| Discovery of NDOs | `NdoAnchor` in the group cell | same |
+
+Create group, join group and invite links are hidden in Moss (`mossStore.isMoss`), and the service refuses them with `Groups are managed by Moss`. The Lobby DHT calls answer with nothing: every tool instance is its own network, so there is no shared lobby to announce to.
+
+Code: `ui/src/lib/moss/` (`group-cell.ts`, `profile.ts`, `ndo-clone.ts`), `ui/src/lib/services/zomes/moss-lobby.ts` (the service, with injected dependencies so it runs in a unit test against a mocked WeaveClient) and `ui/src/lib/stores/moss.store.svelte.ts`.
+
+**NDO clones are not public to the Moss group (`PUBLIC_NDO_CLONES = false`).** `createCloneCell(req, true)` registers the clone in the Moss group DNA so other members and always-online nodes can install it. Moss `0.16.0-rc.5` cannot register a clone that carries DNA properties: `join_cloned_cell` declares `properties: Option<SerializedBytes>` and the renderer forwards the properties object untouched, so the call fails with a Deserialize error and leaves an orphan cell. NDO clones need their properties (ADR-013). Discovery does not depend on the registration, since peers re-derive the clone from the `NdoAnchor` in the group cell, but an always-online node (wdocker) will not host the NDO cells until this flips. Flip `PUBLIC_NDO_CLONES` once Moss accepts properties.
+
 ## Open items
 
-- `weaveClient.createCloneCell(req, true)` fails whenever `req.modifiers.properties` is set, which NDO clones need. See the #162 result and #164.
+- `weaveClient.createCloneCell(req, true)` fails whenever `req.modifiers.properties` is set, which NDO clones need (see above and the #162 result).
 - `AppletServices` in `@theweave/api` `0.7.0-rc.3` has `getAssetInfo`, `search` and `creatables`. Opening an asset is not a method on it: Moss renders the tool with an `asset` view (`renderInfo.view.type === 'asset'`), and the tool calls `weaveClient.openAsset` to open other assets.
diff --git a/documentation/specifications/ui_architecture.md b/documentation/specifications/ui_architecture.md
index fc7ae813..f6279e42 100644
--- a/documentation/specifications/ui_architecture.md
+++ b/documentation/specifications/ui_architecture.md
@@ -102,7 +102,7 @@ On top of this hierarchy, the **next** UI iteration adds a cross-cutting **Persp
 
 Dependencies only point down: routes render components, components read stores, stores call services, services call the Holochain client. The domain layer sits beside the services and is imported by stores and components. The three rules that keep it that way are enforced by a script (see [§17](#17-architecture-invariants)).
 
-**Moss host (`lib/moss/`).** When the UI runs inside Moss it is a tool, not a page that owns its conductor connection. `lib/moss/` holds that seam as plain TypeScript beside the service layer: `host.ts` (pure host detection), `connect.ts` (the `WeaveClient` connection, injectable for tests) and `applet-services.ts` (what the tool tells Moss about itself). Only `utils/hc-connect.ts` imports it, as one more connection mode (§15.4), so components, stores and services see the same `AppClient` whether the host is Moss or a standalone conductor. Details in [moss-integration.md](moss-integration.md).
+**Moss host (`lib/moss/`).** When the UI runs inside Moss it is a tool, not a page that owns its conductor connection. `lib/moss/` holds that seam as plain TypeScript beside the service layer: `host.ts` (pure host detection), `connect.ts` (the `WeaveClient` connection, injectable for tests) and `applet-services.ts` (what the tool tells Moss about itself). Only `utils/hc-connect.ts` imports it, as one more connection mode (§15.4), so components, stores and services see the same `AppClient` whether the host is Moss or a standalone conductor. The group context has one more seam: `LobbyServiceResolved` selects `MossLobbyServiceLive` (one group, the tool instance's `group` cell) or the Lobby and Group DNA implementation, behind the same `LobbyService` interface, and `moss.store.svelte.ts` holds the Moss profile and role for components. Details in [moss-integration.md](moss-integration.md).
 
 ---
 
diff --git a/ui/src/lib/components/group/GroupView.svelte b/ui/src/lib/components/group/GroupView.svelte
index 150422f3..b2c8d15b 100644
--- a/ui/src/lib/components/group/GroupView.svelte
+++ b/ui/src/lib/components/group/GroupView.svelte
@@ -9,6 +9,7 @@
   import { appContext } from '$lib/stores/app.context.svelte';
   import { groupStore } from '$lib/stores/group.store.svelte';
   import { lobbyStore } from '$lib/stores/lobby.store.svelte';
+  import { mossStore } from '$lib/stores/moss.store.svelte';
   import { devStorageKey } from '$lib/utils/hc-connect';
   import type { ActiveFilters } from '$lib/stores/lobby.store.svelte';
   import NdoBrowser from '$lib/components/lobby/NdoBrowser.svelte';
@@ -102,7 +103,8 @@
     appContext.currentView = 'group';
     appContext.selectedGroupId = groupId;
     void groupStore.loadGroupData(groupId);
-    if (!hasVisited(groupId)) {
+    // Inside Moss the profile and who sees it are the Moss group's business.
+    if (!mossStore.isMoss && !hasVisited(groupId)) {
       showProfileModal = true;
     }
   });
@@ -183,13 +185,15 @@
       <p class="mt-1 font-mono text-sm text-gray-400">{groupId}</p>
     </div>
     <div class="flex items-center gap-2">
-      <button
-        type="button"
-        onclick={copyInviteLink}
-        class="rounded border border-gray-300 px-3 py-2 text-sm font-medium text-gray-600 hover:bg-gray-50"
-      >
-        {inviteCopied ? 'Invite link copied!' : 'Copy invite link'}
-      </button>
+      {#if !mossStore.isMoss}
+        <button
+          type="button"
+          onclick={copyInviteLink}
+          class="rounded border border-gray-300 px-3 py-2 text-sm font-medium text-gray-600 hover:bg-gray-50"
+        >
+          {inviteCopied ? 'Invite link copied!' : 'Copy invite link'}
+        </button>
+      {/if}
       <button
         type="button"
         onclick={() => {
diff --git a/ui/src/lib/components/lobby/LobbyProfileBar.svelte b/ui/src/lib/components/lobby/LobbyProfileBar.svelte
index 616a3019..396ecf1e 100644
--- a/ui/src/lib/components/lobby/LobbyProfileBar.svelte
+++ b/ui/src/lib/components/lobby/LobbyProfileBar.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
   import { appContext } from '$lib/stores/app.context.svelte';
+  import { mossStore } from '$lib/stores/moss.store.svelte';
 
   interface Props {
     /** Open the profile setup / edit modal */
@@ -18,14 +19,17 @@
     <span class="text-sm text-gray-700">
       Signed in as <span class="font-semibold text-gray-900">{profile.nickname}</span>
     </span>
-    <button
-      type="button"
-      aria-label="Edit profile"
-      onclick={() => onOpenProfile()}
-      class="rounded px-2 py-1 text-xs font-medium text-blue-600 hover:bg-blue-50"
-    >
-      Edit
-    </button>
+    <!-- Inside Moss the profile belongs to the Moss group and is edited there. -->
+    {#if !mossStore.isMoss}
+      <button
+        type="button"
+        aria-label="Edit profile"
+        onclick={() => onOpenProfile()}
+        class="rounded px-2 py-1 text-xs font-medium text-blue-600 hover:bg-blue-50"
+      >
+        Edit
+      </button>
+    {/if}
   {:else}
     <span class="text-sm text-gray-500">No Lobby profile yet</span>
     <button
diff --git a/ui/src/lib/components/lobby/NdoBrowser.svelte b/ui/src/lib/components/lobby/NdoBrowser.svelte
index 9017c719..bf187fd4 100644
--- a/ui/src/lib/components/lobby/NdoBrowser.svelte
+++ b/ui/src/lib/components/lobby/NdoBrowser.svelte
@@ -6,6 +6,7 @@
     ResourceNature
   } from '@nondominium/shared-types';
   import type { ActiveFilters } from '$lib/stores/lobby.store.svelte';
+  import { mossStore } from '$lib/stores/moss.store.svelte';
   import NdoCard from './NdoCard.svelte';
 
   interface Props {
@@ -224,7 +225,11 @@
         Loading NDOs…
       </div>
     {:else if descriptors.length === 0 && !errorMessage}
-      {#if showOnboarding && !hasGroups}
+      {#if showOnboarding && !hasGroups && mossStore.isMoss}
+        <p class="text-sm text-gray-500">
+          Waiting for the Moss group to sync. NDOs appear here once it has.
+        </p>
+      {:else if showOnboarding && !hasGroups}
         <div class="rounded-lg border border-dashed border-blue-200 bg-blue-50 p-6 text-center">
           <p class="text-sm font-medium text-gray-800">Create or join a group to see NDOs</p>
           <p class="mt-1 text-sm text-gray-500">
diff --git a/ui/src/lib/components/shell/Sidebar.svelte b/ui/src/lib/components/shell/Sidebar.svelte
index 447aae1f..8c193cb0 100644
--- a/ui/src/lib/components/shell/Sidebar.svelte
+++ b/ui/src/lib/components/shell/Sidebar.svelte
@@ -3,6 +3,7 @@
   import { goto } from '$app/navigation';
   import { lobbyStore } from '$lib/stores/lobby.store.svelte';
   import { appContext } from '$lib/stores/app.context.svelte';
+  import { mossStore } from '$lib/stores/moss.store.svelte';
   import UserProfileForm from '$lib/components/lobby/UserProfileForm.svelte';
 
   const isActive = (href: string) =>
@@ -138,21 +139,27 @@
           >
             {g.name}
           </a>
-          <button
-            type="button"
-            title="Copy invite link"
-            onclick={(e) => copyInviteLink(g.id, e)}
-            class="shrink-0 rounded px-1.5 py-0.5 text-xs text-gray-400 opacity-0 transition-opacity group-hover:opacity-100 hover:bg-white hover:text-blue-600"
-          >
-            {copiedGroupId === g.id ? '✓' : '⎘'}
-          </button>
+          {#if !mossStore.isMoss}
+            <button
+              type="button"
+              title="Copy invite link"
+              onclick={(e) => copyInviteLink(g.id, e)}
+              class="shrink-0 rounded px-1.5 py-0.5 text-xs text-gray-400 opacity-0 transition-opacity group-hover:opacity-100 hover:bg-white hover:text-blue-600"
+            >
+              {copiedGroupId === g.id ? '✓' : '⎘'}
+            </button>
+          {/if}
         </li>
       {/each}
     </ul>
   {:else}
-    <p class="mb-2 text-xs text-gray-400 italic">No groups yet.</p>
+    <p class="mb-2 text-xs text-gray-400 italic">
+      {mossStore.isMoss ? 'Waiting for the Moss group to sync…' : 'No groups yet.'}
+    </p>
   {/if}
 
+  <!-- Inside Moss the Moss group is the group: no creating, joining or invite codes. -->
+  {#if !mossStore.isMoss}
   <!-- Create Group -->
   {#if showCreateForm}
     <div class="mb-2 rounded border border-gray-200 bg-white p-2">
@@ -255,8 +262,19 @@
     </button>
   {/if}
 
+  {/if}
+
   <!-- My Profile -->
   <div class="mt-auto border-t border-gray-200 pt-3">
+    {#if mossStore.isMoss}
+      <!-- The profile and the role belong to the Moss group; edit them in Moss. -->
+      <p class="px-2 py-1.5 text-xs text-gray-500">
+        <span class="font-medium text-gray-700">{appContext.lobbyUserProfile?.nickname ?? 'Member'}</span>
+        {#if mossStore.role}
+          <span class="ml-1 text-gray-400">· {mossStore.role}</span>
+        {/if}
+      </p>
+    {:else}
     <button
       type="button"
       onclick={() => {
@@ -271,5 +289,6 @@
         Set up profile
       {/if}
     </button>
+    {/if}
   </div>
 </nav>
diff --git a/ui/src/lib/moss/group-cell.spec.ts b/ui/src/lib/moss/group-cell.spec.ts
new file mode 100644
index 00000000..4391eada
--- /dev/null
+++ b/ui/src/lib/moss/group-cell.spec.ts
@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { CellType, type AppInfo } from '@holochain/client';
+import { MOSS_GROUP_ID, getMossGroupCell } from './group-cell';
+
+const dna = new Uint8Array([1, 2, 3]);
+const agent = new Uint8Array([9, 9, 9]);
+
+function appInfo(cellInfo: Record<string, unknown[]>): AppInfo {
+  return { cell_info: cellInfo } as unknown as AppInfo;
+}
+
+describe('getMossGroupCell', () => {
+  it('returns the provisioned group cell Moss installs for the tool instance', () => {
+    const cell = getMossGroupCell(
+      appInfo({
+        group: [
+          {
+            type: CellType.Provisioned,
+            value: { cell_id: [dna, agent], dna_modifiers: { network_seed: 'instance-seed' } }
+          }
+        ]
+      })
+    );
+    expect(cell).toEqual({
+      networkSeed: 'instance-seed',
+      dnaHash: dna,
+      cellId: [dna, agent],
+      cloneId: 'group',
+      enabled: true
+    });
+  });
+
+  it('ignores cloned group cells, which belong to the standalone model', () => {
+    const cell = getMossGroupCell(
+      appInfo({
+        group: [
+          { type: CellType.Cloned, value: { cell_id: [dna, agent], dna_modifiers: { network_seed: 'x' } } }
+        ]
+      })
+    );
+    expect(cell).toBeNull();
+  });
+
+  it('falls back to the group id when the cell carries no network seed', () => {
+    const cell = getMossGroupCell(
+      appInfo({ group: [{ type: CellType.Provisioned, value: { cell_id: [dna, agent], dna_modifiers: {} } }] })
+    );
+    expect(cell?.networkSeed).toBe(MOSS_GROUP_ID);
+  });
+
+  it('returns null when the app has no group role or no app info', () => {
+    expect(getMossGroupCell(appInfo({}))).toBeNull();
+    expect(getMossGroupCell(null)).toBeNull();
+  });
+});
diff --git a/ui/src/lib/moss/group-cell.ts b/ui/src/lib/moss/group-cell.ts
new file mode 100644
index 00000000..89237c30
--- /dev/null
+++ b/ui/src/lib/moss/group-cell.ts
@@ -0,0 +1,31 @@
+import { CellType, type AppInfo, type CellInfo } from '@holochain/client';
+import type { GroupCellInfo } from '../services/group-clone.helpers';
+
+/**
+ * Inside Moss there is exactly one Nondominium group: the tool instance's own
+ * `group` cell. This is its id wherever the standalone UI would use the clone's
+ * network seed.
+ */
+export const MOSS_GROUP_ID = 'moss';
+
+/**
+ * The `group` cell Moss installs for the tool instance. Moss provisions every
+ * role of the manifest, deferred ones included (verified in the #162 spike), so
+ * unlike the standalone model this cell is provisioned, not cloned.
+ */
+export function getMossGroupCell(appInfo: AppInfo | null): GroupCellInfo | null {
+  const cells: CellInfo[] = appInfo?.cell_info?.['group'] ?? [];
+  for (const cellInfo of cells) {
+    if (cellInfo.type !== CellType.Provisioned) continue;
+    const { cell_id, dna_modifiers } = cellInfo.value;
+    const seed = dna_modifiers?.network_seed;
+    return {
+      networkSeed: typeof seed === 'string' && seed ? seed : MOSS_GROUP_ID,
+      dnaHash: cell_id[0],
+      cellId: cell_id,
+      cloneId: 'group',
+      enabled: true
+    };
+  }
+  return null;
+}
diff --git a/ui/src/lib/moss/ndo-clone.spec.ts b/ui/src/lib/moss/ndo-clone.spec.ts
new file mode 100644
index 00000000..594ef4ae
--- /dev/null
+++ b/ui/src/lib/moss/ndo-clone.spec.ts
@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { ClonedCell } from '@holochain/client';
+import type { NdoDnaProperties } from '@nondominium/shared-types';
+import { PUBLIC_NDO_CLONES, createNdoCloneViaWeave } from './ndo-clone';
+
+const properties: NdoDnaProperties = {
+  name: 'Seed library',
+  property_regime: 'Commons',
+  resource_nature: 'Physical',
+  created_at: 1793754000000000
+};
+const cloned = { cell_id: [new Uint8Array([1]), new Uint8Array([2])], clone_id: 'ndo.3' } as unknown as ClonedCell;
+
+describe('createNdoCloneViaWeave', () => {
+  it('asks the WeaveClient, never the applet client, for the clone', async () => {
+    const weave = { createCloneCell: vi.fn(async (_req: unknown, _public: boolean) => cloned) };
+    const result = await createNdoCloneViaWeave(weave, { networkSeed: 'ndo_seed', properties });
+    expect(result).toBe(cloned);
+    expect(weave.createCloneCell).toHaveBeenCalledTimes(1);
+  });
+
+  it('requests the ndo role with the seed and plain-object DNA properties', async () => {
+    const weave = { createCloneCell: vi.fn(async (_req: unknown, _public: boolean) => cloned) };
+    await createNdoCloneViaWeave(weave, { networkSeed: 'ndo_seed', properties });
+    const [request] = weave.createCloneCell.mock.calls[0] as unknown as [
+      { role_name: string; name: string; modifiers: { network_seed: string; properties: unknown } }
+    ];
+    expect(request.role_name).toBe('ndo');
+    expect(request.name).toBe('Seed library');
+    expect(request.modifiers.network_seed).toBe('ndo_seed');
+    expect(request.modifiers.properties).toEqual(properties);
+    expect(request.modifiers.properties).not.toBeInstanceOf(Uint8Array);
+  });
+
+  it('keeps NDO clones private to the instance: Moss cannot register a public clone that has DNA properties', async () => {
+    // Moss 0.16.0-rc.5: join_cloned_cell declares `properties: Option<SerializedBytes>` and the
+    // renderer forwards the properties object untouched, so any properties fail to deserialize
+    // and leave an orphan cell. Flip this when Moss accepts them (issue #162).
+    expect(PUBLIC_NDO_CLONES).toBe(false);
+    const weave = { createCloneCell: vi.fn(async (_req: unknown, _public: boolean) => cloned) };
+    await createNdoCloneViaWeave(weave, { networkSeed: 'ndo_seed', properties });
+    expect(weave.createCloneCell.mock.calls[0]?.[1]).toBe(false);
+  });
+
+  it('passes an explicit public flag through', async () => {
+    const weave = { createCloneCell: vi.fn(async (_req: unknown, _public: boolean) => cloned) };
+    await createNdoCloneViaWeave(weave, { networkSeed: 'ndo_seed', properties }, true);
+    expect(weave.createCloneCell.mock.calls[0]?.[1]).toBe(true);
+  });
+
+  it('propagates a Moss failure to the caller', async () => {
+    const weave = {
+      createCloneCell: vi.fn(async () => {
+        throw new Error('Wasm runtime error');
+      })
+    };
+    await expect(createNdoCloneViaWeave(weave, { networkSeed: 's', properties })).rejects.toThrow('Wasm runtime error');
+  });
+});
diff --git a/ui/src/lib/moss/ndo-clone.ts b/ui/src/lib/moss/ndo-clone.ts
new file mode 100644
index 00000000..fc763fb7
--- /dev/null
+++ b/ui/src/lib/moss/ndo-clone.ts
@@ -0,0 +1,43 @@
+import type { ClonedCell, CreateCloneCellRequest } from '@holochain/client';
+import type { NdoDnaProperties } from '@nondominium/shared-types';
+
+/**
+ * Whether NDO clones are registered in the Moss group DNA for other members and
+ * always-online nodes (`createCloneCell(req, true)`).
+ *
+ * False for now. Moss 0.16.0-rc.5 cannot register a clone that carries DNA
+ * properties: `join_cloned_cell` declares `properties: Option<SerializedBytes>`
+ * and the renderer forwards the properties object untouched, so the call fails
+ * with a Deserialize error and leaves an orphan cell. NDO clones carry the
+ * immutable Layer 0 fields as properties (ADR-013). Discovery does not need the
+ * registration: peers re-derive the clone from the `NdoAnchor` in the group cell.
+ * Flip this when Moss accepts properties. See #162.
+ */
+export const PUBLIC_NDO_CLONES = false;
+
+/** The slice of the WeaveClient this module uses. */
+export interface WeaveCloneApi {
+  createCloneCell(req: CreateCloneCellRequest, publicToGroupMembers: boolean): Promise<ClonedCell>;
+}
+
+/**
+ * Creates the `ndo` clone for one NDO through the WeaveClient. Inside Moss the
+ * applet client refuses `createCloneCell` ("use the createCloneCell method on
+ * the WeaveClient instead"); the WeaveClient forwards to the same conductor.
+ * `properties` stays a plain object, as the conductor expects (see
+ * `HolochainClientService.createNdoCloneCell`).
+ */
+export function createNdoCloneViaWeave(
+  weave: WeaveCloneApi,
+  args: { networkSeed: string; properties: NdoDnaProperties },
+  publicToGroupMembers: boolean = PUBLIC_NDO_CLONES
+): Promise<ClonedCell> {
+  return weave.createCloneCell(
+    {
+      role_name: 'ndo',
+      modifiers: { network_seed: args.networkSeed, properties: args.properties },
+      name: args.properties.name
+    },
+    publicToGroupMembers
+  );
+}
diff --git a/ui/src/lib/moss/profile.spec.ts b/ui/src/lib/moss/profile.spec.ts
new file mode 100644
index 00000000..b4b164ae
--- /dev/null
+++ b/ui/src/lib/moss/profile.spec.ts
@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { loadMossProfile, loadMyRoles, strongestRole } from './profile';
+
+const agent = new Uint8Array([7, 7, 7]);
+const groupA = new Uint8Array([1, 1, 1]);
+const groupB = new Uint8Array([2, 2, 2]);
+
+describe('loadMossProfile', () => {
+  it('maps the Moss profile to the UI profile, nickname first', async () => {
+    const profiles = {
+      getAgentProfile: async () => ({ entry: { nickname: 'Alice', fields: { bio: 'Steward of tools' } } })
+    };
+    expect(await loadMossProfile(profiles, agent)).toEqual({ nickname: 'Alice', bio: 'Steward of tools' });
+  });
+
+  it('omits the bio when the Moss profile has none', async () => {
+    const profiles = { getAgentProfile: async () => ({ entry: { nickname: 'Bob', fields: {} } }) };
+    expect(await loadMossProfile(profiles, agent)).toEqual({ nickname: 'Bob' });
+  });
+
+  it('returns null when the agent has no Moss profile yet', async () => {
+    const profiles = { getAgentProfile: async () => undefined };
+    expect(await loadMossProfile(profiles, agent)).toBeNull();
+  });
+
+  it('returns null instead of throwing when the profile lookup fails', async () => {
+    const profiles = {
+      getAgentProfile: async () => {
+        throw new Error('profiles zome unreachable');
+      }
+    };
+    expect(await loadMossProfile(profiles, agent)).toBeNull();
+  });
+});
+
+describe('loadMyRoles', () => {
+  const weave = {
+    myAccountabilitiesPerGroup: async () =>
+      [
+        [groupA, [{ role: { name: 'Member' } }, { role: { name: 'Steward' } }]],
+        [groupB, [{ role: { name: 'Progenitor' } }]]
+      ] as never
+  };
+
+  it('returns the role names for the group the tool instance lives in', async () => {
+    expect(await loadMyRoles(weave, groupA)).toEqual(['Member', 'Steward']);
+    expect(await loadMyRoles(weave, groupB)).toEqual(['Progenitor']);
+  });
+
+  it('returns no roles for a group the agent has none in, or no group', async () => {
+    expect(await loadMyRoles(weave, new Uint8Array([3, 3, 3]))).toEqual([]);
+    expect(await loadMyRoles(weave, null)).toEqual([]);
+  });
+
+  it('ignores role names this tool does not know', async () => {
+    const odd = {
+      myAccountabilitiesPerGroup: async () => [[groupA, [{ role: { name: 'Janitor' } }]]] as never
+    };
+    expect(await loadMyRoles(odd, groupA)).toEqual([]);
+  });
+});
+
+describe('strongestRole', () => {
+  it('orders Progenitor over Steward over Member', () => {
+    expect(strongestRole(['Member', 'Steward'])).toBe('Steward');
+    expect(strongestRole(['Member', 'Progenitor', 'Steward'])).toBe('Progenitor');
+    expect(strongestRole(['Member'])).toBe('Member');
+  });
+
+  it('is null with no role', () => {
+    expect(strongestRole([])).toBeNull();
+  });
+});
diff --git a/ui/src/lib/moss/profile.ts b/ui/src/lib/moss/profile.ts
new file mode 100644
index 00000000..81cd4f1e
--- /dev/null
+++ b/ui/src/lib/moss/profile.ts
@@ -0,0 +1,64 @@
+import { encodeHashToBase64, type AgentPubKey, type DnaHash } from '@holochain/client';
+import type { LobbyUserProfile } from '@nondominium/shared-types';
+
+/** The Moss group roles this tool knows. */
+export type MossRoleName = 'Member' | 'Steward' | 'Progenitor';
+
+const ROLE_ORDER: readonly MossRoleName[] = ['Member', 'Steward', 'Progenitor'];
+
+/** The slice of the Moss profiles client this module uses. */
+export interface MossProfilesApi {
+  getAgentProfile(
+    agent: AgentPubKey
+  ): Promise<{ entry: { nickname: string; fields: Record<string, string> } } | undefined>;
+}
+
+/** The slice of the WeaveClient this module uses. */
+export interface MossAccountabilitiesApi {
+  myAccountabilitiesPerGroup(): Promise<Array<[DnaHash, Array<{ role: { name: string } }>]>>;
+}
+
+/**
+ * The agent's Moss profile, in the shape the UI already uses for the standalone
+ * Lobby profile. Null when there is none yet or Moss cannot answer: the caller
+ * falls back to a nickname rather than blocking on a profile.
+ */
+export async function loadMossProfile(
+  profiles: MossProfilesApi,
+  agent: AgentPubKey
+): Promise<LobbyUserProfile | null> {
+  try {
+    const record = await profiles.getAgentProfile(agent);
+    if (!record) return null;
+    const { nickname, fields } = record.entry;
+    return { nickname, ...(fields.bio ? { bio: fields.bio } : {}) };
+  } catch (error) {
+    console.warn('[moss] could not read the Moss profile:', error);
+    return null;
+  }
+}
+
+function isKnownRole(name: string): name is MossRoleName {
+  return (ROLE_ORDER as readonly string[]).includes(name);
+}
+
+/** The agent's roles in the Moss group the tool instance lives in. */
+export async function loadMyRoles(
+  weave: MossAccountabilitiesApi,
+  groupHash: DnaHash | null
+): Promise<MossRoleName[]> {
+  if (!groupHash) return [];
+  const wanted = encodeHashToBase64(groupHash);
+  const perGroup = await weave.myAccountabilitiesPerGroup();
+  const entry = perGroup.find(([hash]) => encodeHashToBase64(hash) === wanted);
+  if (!entry) return [];
+  return entry[1].map((accountability) => accountability.role.name).filter(isKnownRole);
+}
+
+export function strongestRole(roles: readonly MossRoleName[]): MossRoleName | null {
+  let best: MossRoleName | null = null;
+  for (const role of roles) {
+    if (best === null || ROLE_ORDER.indexOf(role) > ROLE_ORDER.indexOf(best)) best = role;
+  }
+  return best;
+}
diff --git a/ui/src/lib/services/holochain.service.svelte.ts b/ui/src/lib/services/holochain.service.svelte.ts
index d3a6aeb5..c3cf75bb 100644
--- a/ui/src/lib/services/holochain.service.svelte.ts
+++ b/ui/src/lib/services/holochain.service.svelte.ts
@@ -1,5 +1,6 @@
 import type { AgentPubKey, AppClient, AppInfoResponse, CellId, ClonedCell } from '@holochain/client';
 import type { MossConnection } from '../moss/connect';
+import { createNdoCloneViaWeave } from '../moss/ndo-clone';
 import { Context, Layer } from 'effect';
 import {
   authorizeCellSigning,
@@ -227,9 +228,11 @@ function createHolochainClientService(): HolochainClientService {
     if (!client) {
       throw new Error('Client not connected');
     }
-    const enabled = await client.enableCloneCell({
-      clone_cell_id: { type: 'dna_hash', value: dnaHash }
-    });
+    const request = { clone_cell_id: { type: 'dna_hash' as const, value: dnaHash } };
+    // Inside Moss the applet client refuses clone management; the WeaveClient does it.
+    const enabled = moss
+      ? await moss.weaveClient.enableCloneCell(request)
+      : await client.enableCloneCell(request);
     // Enabling changes cell topology — the cached AppInfo is now stale.
     invalidateAppInfoCache();
     await authorizeCloneCellSigning(enabled.cell_id);
@@ -269,11 +272,14 @@ function createHolochainClientService(): HolochainClientService {
     // binary variant; an AgentPubKey here hangs createCloneCell). The conductor
     // canonicalizes it to SerializedBytes so the DnaHash is value-deterministic
     // and the ADR-013 binding inside the cell fires.
-    const cloned = await client.createCloneCell({
-      role_name: 'ndo',
-      modifiers: { network_seed: args.networkSeed, properties: args.properties },
-      name: args.properties.name
-    });
+    // Inside Moss the applet client refuses createCloneCell; the WeaveClient does it.
+    const cloned = moss
+      ? await createNdoCloneViaWeave(moss.weaveClient, args)
+      : await client.createCloneCell({
+          role_name: 'ndo',
+          modifiers: { network_seed: args.networkSeed, properties: args.properties },
+          name: args.properties.name
+        });
     invalidateAppInfoCache();
     if (!cloned.enabled) {
       // enableGroupCloneCell is role-agnostic (keyed by DnaHash); it enables any
diff --git a/ui/src/lib/services/zomes/lobby.service.ts b/ui/src/lib/services/zomes/lobby.service.ts
index 7aeb6d9f..0167e4fe 100644
--- a/ui/src/lib/services/zomes/lobby.service.ts
+++ b/ui/src/lib/services/zomes/lobby.service.ts
@@ -13,6 +13,9 @@ import { HolochainClientServiceTag, HolochainClientServiceLive } from '../holoch
 import { wrapZomeCallWithErrorFactory } from '$lib/utils/zome-helpers';
 import { devStorageKey } from '$lib/utils/hc-connect';
 import { LobbyError } from '$lib/errors/lobby.errors';
+import { detectCurrentHost } from '$lib/moss/host';
+import { getMossGroupCell } from '$lib/moss/group-cell';
+import { createMossLobbyService } from './moss-lobby';
 import { enumerateGroupCells, getGroupCellHandleBySeed, type GroupCellInfo } from '../cell.manager';
 import {
   generateNetworkSeed,
@@ -621,6 +624,52 @@ export const LobbyServiceLive: Layer.Layer<LobbyServiceTag, never, HolochainClie
     })
   );
 
-export const LobbyServiceResolved: Layer.Layer<LobbyServiceTag> = LobbyServiceLive.pipe(
-  Layer.provide(HolochainClientServiceLive)
-);
+// ─── Moss Layer ───────────────────────────────────────────────────────────────
+
+/**
+ * The group context when the UI is hosted by Moss: the Moss group is the
+ * federation layer and the tool instance's group cell is the one group
+ * (`moss-lobby.ts`). Selected over `LobbyServiceLive` by `LobbyServiceResolved`.
+ */
+export const MossLobbyServiceLive: Layer.Layer<LobbyServiceTag, never, HolochainClientServiceTag> =
+  Layer.effect(
+    LobbyServiceTag,
+    E.gen(function* () {
+      const holochainClient = yield* HolochainClientServiceTag;
+
+      const moss = () => {
+        const connection = holochainClient.moss;
+        if (!connection) throw new Error('Not connected through Moss.');
+        return connection;
+      };
+
+      return createMossLobbyService({
+        getGroupCell: async () => {
+          if (!holochainClient.isConnected) await holochainClient.connectClient();
+          return getMossGroupCell(await holochainClient.getAppInfo());
+        },
+        callGroupZome: (cellId, fnName, payload) =>
+          holochainClient.callZome('zome_group', fnName, payload, undefined, undefined, cellId) as Promise<never>,
+        myAgentPubKey: () => holochainClient.getMyAgentPubKey(),
+        mossGroupName: async () => {
+          const { weaveClient, groupHash } = moss();
+          if (!groupHash) return 'Nondominium';
+          const profile = (await weaveClient.groupProfile(groupHash)) as { name?: string } | undefined;
+          return profile?.name?.trim() || 'Nondominium';
+        },
+        isToolInstaller: async () => {
+          const { weaveClient, appletHash, groupHash } = moss();
+          const installer = await weaveClient.toolInstaller(appletHash, groupHash ?? undefined);
+          if (!installer) return false;
+          const me = await holochainClient.getMyAgentPubKey();
+          return encodeHashToBase64(installer) === encodeHashToBase64(me);
+        },
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+      });
+    })
+  );
+
+/** Moss when the page is hosted by Moss, the Lobby and Group DNAs otherwise. */
+export const LobbyServiceResolved: Layer.Layer<LobbyServiceTag> = (
+  detectCurrentHost().mode === 'moss' ? MossLobbyServiceLive : LobbyServiceLive
+).pipe(Layer.provide(HolochainClientServiceLive));
diff --git a/ui/src/lib/services/zomes/moss-lobby.spec.ts b/ui/src/lib/services/zomes/moss-lobby.spec.ts
new file mode 100644
index 00000000..cd91e32c
--- /dev/null
+++ b/ui/src/lib/services/zomes/moss-lobby.spec.ts
@@ -0,0 +1,163 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Effect as E, Exit } from 'effect';
+import { encodeHashToBase64, type CellId } from '@holochain/client';
+import { MOSS_GROUP_ID } from '$lib/moss/group-cell';
+import { createMossLobbyService, type MossLobbyDeps } from './moss-lobby';
+
+const dna = new Uint8Array([1, 2, 3]);
+const me = new Uint8Array([9, 9, 9]);
+const cellId: CellId = [dna, me];
+const groupHash = new Uint8Array([5, 5, 5]);
+
+const cell = { networkSeed: 'instance-seed', dnaHash: dna, cellId, cloneId: 'group', enabled: true };
+
+function groupRecord(name: string) {
+  return {
+    signed_action: { hashed: { hash: groupHash, content: { header: { author: me, timestamp: 1 } } } },
+    entry: { Present: { entry: { name, description: 'Pilot group' } } }
+  };
+}
+
+interface Fake {
+  deps: MossLobbyDeps;
+  zomeCalls: Array<{ fn: string; payload: unknown }>;
+}
+
+/** A group cell that starts empty (or with a profile), recording every zome call. */
+function fake(options: { installer: boolean; existingProfile?: boolean; member?: boolean; appearsAfter?: number }): Fake {
+  const zomeCalls: Fake['zomeCalls'] = [];
+  let profilePresent = options.existingProfile ?? false;
+  let getMyGroupCalls = 0;
+  const deps: MossLobbyDeps = {
+    getGroupCell: async () => cell,
+    callGroupZome: (async (_cellId: CellId, fn: string, payload: unknown) => {
+      zomeCalls.push({ fn, payload });
+      if (fn === 'get_my_group') {
+        getMyGroupCalls += 1;
+        if (options.appearsAfter !== undefined && getMyGroupCalls > options.appearsAfter) profilePresent = true;
+        return profilePresent ? groupRecord('Nondominium Pilot') : null;
+      }
+      if (fn === 'create_group') {
+        profilePresent = true;
+        return groupRecord((payload as { name: string }).name);
+      }
+      if (fn === 'is_member') return options.member ?? false;
+      return groupRecord('Nondominium Pilot');
+    }) as MossLobbyDeps['callGroupZome'],
+    myAgentPubKey: async () => me,
+    mossGroupName: async () => 'Nondominium Pilot',
+    isToolInstaller: async () => options.installer,
+    sleep: vi.fn(async () => {})
+  };
+  return { deps, zomeCalls };
+}
+
+const run = <A, Err>(effect: E.Effect<A, Err>) => E.runPromiseExit(effect);
+
+describe('Moss lobby service', () => {
+  it('shows exactly one group, the tool instance group cell', async () => {
+    const { deps } = fake({ installer: true, existingProfile: true });
+    const groups = await E.runPromise(createMossLobbyService(deps).getMyGroups());
+    expect(groups).toHaveLength(1);
+    expect(groups[0]).toMatchObject({
+      id: MOSS_GROUP_ID,
+      name: 'Nondominium Pilot',
+      networkSeed: 'instance-seed',
+      groupHash: encodeHashToBase64(groupHash)
+    });
+  });
+
+  it('lets the tool installer create the group profile and join it, with no invite code', async () => {
+    const { deps, zomeCalls } = fake({ installer: true });
+    await E.runPromise(createMossLobbyService(deps).getMyGroups());
+    const fns = zomeCalls.map((c) => c.fn);
+    expect(fns).toContain('create_group');
+    expect(fns).toContain('join_group');
+    expect(zomeCalls.find((c) => c.fn === 'create_group')?.payload).toEqual({
+      name: 'Nondominium Pilot',
+      description: null
+    });
+  });
+
+  it('resolves the group once when every store asks at the same time, so commits never race', async () => {
+    const { deps, zomeCalls } = fake({ installer: true });
+    const service = createMossLobbyService(deps);
+    await Promise.all([
+      E.runPromise(service.getMyGroups()),
+      E.runPromise(service.getMyGroups()),
+      E.runPromise(service.ensureMembership(MOSS_GROUP_ID)),
+      E.runPromise(service.getMyGroups())
+    ]);
+    expect(zomeCalls.filter((c) => c.fn === 'create_group')).toHaveLength(1);
+    expect(zomeCalls.filter((c) => c.fn === 'join_group')).toHaveLength(1);
+    // A resolved group is kept: later calls touch the conductor no more.
+    const before = zomeCalls.length;
+    await E.runPromise(service.getMyGroups());
+    expect(zomeCalls.length).toBe(before);
+  });
+
+  it('never creates a second profile when the group already has one', async () => {
+    const { deps, zomeCalls } = fake({ installer: true, existingProfile: true });
+    await E.runPromise(createMossLobbyService(deps).getMyGroups());
+    expect(zomeCalls.map((c) => c.fn)).not.toContain('create_group');
+  });
+
+  it('makes a member wait for the installer profile to gossip, then join it automatically', async () => {
+    const { deps, zomeCalls } = fake({ installer: false, appearsAfter: 3 });
+    const groups = await E.runPromise(createMossLobbyService(deps).getMyGroups());
+    expect(groups).toHaveLength(1);
+    expect(zomeCalls.map((c) => c.fn)).not.toContain('create_group');
+    expect(deps.sleep).toHaveBeenCalled();
+    expect(zomeCalls.filter((c) => c.fn === 'join_group')).toHaveLength(1);
+  });
+
+  it('shows no group yet, without failing, while a member is still waiting for the profile', async () => {
+    const { deps } = fake({ installer: false });
+    const groups = await E.runPromise(createMossLobbyService(deps).getMyGroups());
+    expect(groups).toEqual([]);
+  });
+
+  it('refuses to create or join groups, which Moss owns', async () => {
+    const { deps } = fake({ installer: true });
+    const service = createMossLobbyService(deps);
+    const exits: Array<Exit.Exit<unknown, unknown>> = [
+      await run(service.createGroup('Another')),
+      await run(service.joinGroup('invite-code')),
+      await run(service.generateInviteLink(MOSS_GROUP_ID))
+    ];
+    for (const exit of exits) {
+      expect(Exit.isFailure(exit)).toBe(true);
+      expect(JSON.stringify(exit)).toMatch(/managed by Moss/i);
+    }
+  });
+
+  it('resolves the group cell and hash only for the Moss group id', async () => {
+    const { deps } = fake({ installer: true, existingProfile: true });
+    const service = createMossLobbyService(deps);
+    expect(await E.runPromise(service.getGroupCell(MOSS_GROUP_ID))).toEqual(cell);
+    expect(await E.runPromise(service.getGroupCell('some-clone-seed'))).toBeNull();
+    expect(await E.runPromise(service.getGroupHash(MOSS_GROUP_ID))).toBe(encodeHashToBase64(groupHash));
+    expect(await E.runPromise(service.getGroupHash('some-clone-seed'))).toBeNull();
+  });
+
+  it('joins the group once when membership is missing, and not again when present', async () => {
+    const missing = fake({ installer: false, existingProfile: true, member: false });
+    expect(await E.runPromise(createMossLobbyService(missing.deps).ensureMembership(MOSS_GROUP_ID))).toBe(true);
+    expect(missing.zomeCalls.filter((c) => c.fn === 'join_group')).toHaveLength(1);
+
+    const present = fake({ installer: false, existingProfile: true, member: true });
+    expect(await E.runPromise(createMossLobbyService(present.deps).ensureMembership(MOSS_GROUP_ID))).toBe(true);
+    expect(present.zomeCalls.map((c) => c.fn)).not.toContain('join_group');
+  });
+
+  it('answers the standalone Lobby DHT calls with nothing, since Moss replaces the Lobby', async () => {
+    const { deps, zomeCalls } = fake({ installer: true });
+    const service = createMossLobbyService(deps);
+    expect(await E.runPromise(service.getAllGroupAnnouncements())).toEqual([]);
+    expect(await E.runPromise(service.getMyGroupAnnouncements())).toEqual([]);
+    expect(await E.runPromise(service.getLobbyAgentProfile(me))).toBeNull();
+    await E.runPromise(service.announceGroup({} as never));
+    await E.runPromise(service.upsertLobbyAgentProfile({ handle: 'x' } as never));
+    expect(zomeCalls).toEqual([]);
+  });
+});
diff --git a/ui/src/lib/services/zomes/moss-lobby.ts b/ui/src/lib/services/zomes/moss-lobby.ts
new file mode 100644
index 00000000..49cb9303
--- /dev/null
+++ b/ui/src/lib/services/zomes/moss-lobby.ts
@@ -0,0 +1,167 @@
+import { Effect as E } from 'effect';
+import { decodeHashFromBase64, type ActionHash, type AgentPubKey, type CellId } from '@holochain/client';
+import type { GroupDescriptor } from '@nondominium/shared-types';
+import { LobbyError } from '$lib/errors/lobby.errors';
+import { MOSS_GROUP_ID } from '$lib/moss/group-cell';
+import { groupProfileFromRecord, type GroupCellInfo, type GroupHolochainRecord } from '../group-clone.helpers';
+import type { LobbyService } from './lobby.service';
+
+/**
+ * What the Moss group context needs from the outside, injected so the whole
+ * service runs in a unit test with a mocked WeaveClient.
+ */
+export interface MossLobbyDeps {
+  /** The tool instance's provisioned `group` cell. */
+  getGroupCell(): Promise<GroupCellInfo | null>;
+  callGroupZome<T>(cellId: CellId, fnName: string, payload: unknown): Promise<T>;
+  myAgentPubKey(): Promise<AgentPubKey>;
+  /** The Moss group's own name, used when the first member creates the profile. */
+  mossGroupName(): Promise<string>;
+  /** Whether this agent installed the tool into the Moss group. */
+  isToolInstaller(): Promise<boolean>;
+  sleep(ms: number): Promise<void>;
+}
+
+type GroupProfile = NonNullable<ReturnType<typeof groupProfileFromRecord>>;
+
+/** How long a member waits for the installer's GroupProfile to gossip into its cell. */
+const PROFILE_WAIT_ATTEMPTS = 20;
+const PROFILE_WAIT_MS = 1500;
+
+const managedByMoss = (context: string) =>
+  E.fail(LobbyError.create('Groups are managed by Moss inside Moss.', context));
+
+/**
+ * The group context inside Moss. The Moss group is the federation layer and
+ * the tool instance's `group` cell is the one Nondominium group of that Moss
+ * group, joined automatically: no Lobby, no invite codes, no clone per group.
+ * Everything below the group (NDO anchors, NDO clones) is the standalone code.
+ */
+export function createMossLobbyService(deps: MossLobbyDeps): LobbyService {
+  const lift = <T>(context: string, run: () => Promise<T>): E.Effect<T, LobbyError> =>
+    E.tryPromise({ try: run, catch: (error) => LobbyError.fromError(error, context) });
+
+  const fetchProfile = (cell: GroupCellInfo): Promise<GroupProfile | null> =>
+    deps
+      .callGroupZome<GroupHolochainRecord | null>(cell.cellId, 'get_my_group', null)
+      .then((record) => (record ? groupProfileFromRecord(record) : null));
+
+  const joinGroup = async (cell: GroupCellInfo, profile: GroupProfile): Promise<void> => {
+    const groupHash = decodeHashFromBase64(profile.groupHashB64) as ActionHash;
+    const me = await deps.myAgentPubKey();
+    const isMember = await deps
+      .callGroupZome<boolean>(cell.cellId, 'is_member', [me, groupHash])
+      .catch(() => false);
+    if (isMember) return;
+    // Non-fatal: membership self-heals through ensureMembership on a later load.
+    await deps.callGroupZome(cell.cellId, 'join_group', groupHash).catch((error) => {
+      console.warn('[moss-lobby] join_group failed (non-fatal):', error);
+    });
+  };
+
+  /**
+   * The group profile and cell. The installer creates the profile when it is
+   * missing; every other member waits for it to gossip, then joins. Null when
+   * a member is still waiting: the caller shows no group yet and a later load
+   * resolves it.
+   */
+  const resolveGroup = async (): Promise<{ cell: GroupCellInfo; profile: GroupProfile } | null> => {
+    const cell = await deps.getGroupCell();
+    if (!cell) throw new Error('The Moss tool instance has no group cell.');
+
+    let profile = await fetchProfile(cell).catch(() => null);
+    if (!profile && (await deps.isToolInstaller())) {
+      const record = await deps.callGroupZome<GroupHolochainRecord>(cell.cellId, 'create_group', {
+        name: await deps.mossGroupName(),
+        description: null
+      });
+      profile = groupProfileFromRecord(record);
+    }
+    for (let attempt = 1; !profile && attempt < PROFILE_WAIT_ATTEMPTS; attempt += 1) {
+      await deps.sleep(PROFILE_WAIT_MS);
+      profile = await fetchProfile(cell).catch(() => null);
+    }
+    if (!profile) return null;
+    await joinGroup(cell, profile);
+    return { cell, profile };
+  };
+
+  // The stores and the NDO service all ask for the group at once on load. Each
+  // resolution may commit to the source chain (create_group, join_group), and
+  // concurrent commits fail with "source chain head has moved", so one
+  // resolution runs at a time and a successful one is kept.
+  let resolved: { cell: GroupCellInfo; profile: GroupProfile } | null = null;
+  let inFlight: Promise<{ cell: GroupCellInfo; profile: GroupProfile } | null> | null = null;
+  const resolveOnce = () => {
+    if (resolved) return Promise.resolve(resolved);
+    inFlight ??= resolveGroup()
+      .then((result) => {
+        resolved = result;
+        return result;
+      })
+      .finally(() => {
+        inFlight = null;
+      });
+    return inFlight;
+  };
+
+  const descriptor = (cell: GroupCellInfo, profile: GroupProfile): GroupDescriptor => ({
+    id: MOSS_GROUP_ID,
+    networkSeed: cell.networkSeed,
+    name: profile.name,
+    description: profile.description,
+    createdAt: Date.now(),
+    dnaHash: cell.dnaHash,
+    groupHash: profile.groupHashB64
+  });
+
+  const forMossGroup = <T>(groupId: string, none: T, run: () => Promise<T>, context: string) =>
+    groupId === MOSS_GROUP_ID ? lift(context, run) : E.succeed(none);
+
+  return {
+    getMyGroups: () =>
+      lift('GET_MY_GROUPS', async () => {
+        const group = await resolveOnce();
+        return group ? [descriptor(group.cell, group.profile)] : [];
+      }),
+
+    getGroupCell: (groupId) =>
+      forMossGroup<GroupCellInfo | null>(groupId, null, () => deps.getGroupCell(), 'GET_GROUP_CELL'),
+
+    getGroupHash: (groupId) =>
+      forMossGroup<string | null>(
+        groupId,
+        null,
+        async () => {
+          if (resolved) return resolved.profile.groupHashB64;
+          const cell = await deps.getGroupCell();
+          if (!cell) return null;
+          return (await fetchProfile(cell).catch(() => null))?.groupHashB64 ?? null;
+        },
+        'GET_GROUP_HASH'
+      ),
+
+    ensureMembership: (groupId) =>
+      forMossGroup<boolean>(
+        groupId,
+        false,
+        // Resolving the group includes joining it, so membership is ensured by the same pass.
+        async () => (await resolveOnce()) !== null,
+        'ENSURE_MEMBERSHIP'
+      ),
+
+    // Moss owns group creation, invitations and the member profile.
+    createGroup: () => managedByMoss('CREATE_GROUP'),
+    joinGroup: () => managedByMoss('JOIN_GROUP'),
+    generateInviteLink: () => managedByMoss('GENERATE_INVITE_LINK'),
+    saveGroupMemberProfile: () => E.void,
+
+    // The Lobby DHT does not exist as a shared network inside Moss: every tool
+    // instance is its own network, so there is nothing to announce to or read.
+    announceGroup: () => E.succeed(undefined),
+    getAllGroupAnnouncements: () => E.succeed([]),
+    getMyGroupAnnouncements: () => E.succeed([]),
+    upsertLobbyAgentProfile: () => E.succeed(new Uint8Array()),
+    getLobbyAgentProfile: () => E.succeed(null)
+  };
+}
diff --git a/ui/src/lib/stores/moss.store.svelte.ts b/ui/src/lib/stores/moss.store.svelte.ts
new file mode 100644
index 00000000..f733445a
--- /dev/null
+++ b/ui/src/lib/stores/moss.store.svelte.ts
@@ -0,0 +1,49 @@
+import type { LobbyUserProfile } from '@nondominium/shared-types';
+import holochainClientService from '$lib/services/holochain.service.svelte';
+import { loadMossProfile, loadMyRoles, strongestRole, type MossRoleName } from '$lib/moss/profile';
+
+/**
+ * Identity and role inside Moss. Inside Moss the Moss group already holds
+ * membership and profiles, so the standalone Lobby profile form is replaced by
+ * the Moss profile, and the role comes from `myAccountabilitiesPerGroup()`.
+ * Everything is empty when the UI runs standalone.
+ */
+export type MossStore = {
+  readonly isMoss: boolean;
+  readonly profile: LobbyUserProfile | null;
+  readonly roles: readonly MossRoleName[];
+  readonly role: MossRoleName | null;
+  load: () => Promise<void>;
+};
+
+let profile = $state<LobbyUserProfile | null>(null);
+let roles = $state<MossRoleName[]>([]);
+
+export const mossStore: MossStore = {
+  get isMoss() {
+    return holochainClientService.moss !== null;
+  },
+  get profile() {
+    return profile;
+  },
+  get roles() {
+    return roles;
+  },
+  get role() {
+    return strongestRole(roles);
+  },
+  async load() {
+    const moss = holochainClientService.moss;
+    if (!moss || moss.weaveClient.renderInfo.type !== 'applet-view') return;
+    const me = await holochainClientService.getMyAgentPubKey();
+    const [loadedProfile, loadedRoles] = await Promise.all([
+      loadMossProfile(moss.weaveClient.renderInfo.profilesClient, me),
+      loadMyRoles(moss.weaveClient, moss.groupHash).catch((error) => {
+        console.warn('[moss] could not read the group roles:', error);
+        return [] as MossRoleName[];
+      })
+    ]);
+    profile = loadedProfile;
+    roles = loadedRoles;
+  }
+};
diff --git a/ui/src/routes/+layout.svelte b/ui/src/routes/+layout.svelte
index 33ec216d..4c86af62 100644
--- a/ui/src/routes/+layout.svelte
+++ b/ui/src/routes/+layout.svelte
@@ -8,6 +8,7 @@
   import { lobbyStore } from '$lib/stores/lobby.store.svelte';
   import { appContext } from '$lib/stores/app.context.svelte';
   import { connectionStore } from '$lib/stores/connection.store.svelte';
+  import { mossStore } from '$lib/stores/moss.store.svelte';
 
   let { children } = $props();
 
@@ -25,6 +26,11 @@
       } catch {
         appContext.myAgentPubKey = null;
       }
+      if (mossStore.isMoss) {
+        // Inside Moss the profile comes from the Moss group, not from a form.
+        await mossStore.load();
+        appContext.lobbyUserProfile = mossStore.profile ?? { nickname: 'Member' };
+      }
       await lobbyStore.loadLobby();
       if (!appContext.lobbyUserProfile) {
         showProfileModal = true;