diff --git a/README.md b/README.md
index 1905411..fa04ef1 100644
--- a/README.md
+++ b/README.md
@@ -42,7 +42,7 @@ liplus-chat は、人間と複数の独立した AI / Li+ セッションが、
 
 ### 未実装
 
-- 複数の AI セッションを同一の部屋へ参加させる運用（同時発話の抑制を含む）
+- 複数の AI セッションを同一の部屋へ参加させる運用（同時発話の抑制を含む）。経路は通っていますが、実機での往復は未確認です
 - 会話ログの永続化と観測 UI
 - plugin としての allowlist 掲載（配布の第二段階）
 
@@ -54,11 +54,13 @@ npm run tauri dev
 
 起動すると Tauri の窓が開き、部屋ソケットが待ち受けを始めます。フロントエンドの dev サーバは `vite.config.ts` で 1420 番に固定しています（`src-tauri/tauri.conf.json` の `devUrl` と一致させる必要があるため）。
 
-タブの下に「起動オプション」の入力欄があります。`--dangerously-skip-permissions` のように、CLI へ渡したいオプションをそのまま書けます。アプリは部屋の channel エントリ（`server:liplus-chat-room`）をここへ統合するので、別の channel サーバを指定しても部屋の入力路は残ります。実際に起動する行は入力欄の右に表示されます。
+タブの下に「起動オプション」の入力欄があります。`--dangerously-skip-permissions` のように、CLI へ渡したいオプションをそのまま書けます。アプリは部屋の channel エントリ（`server:liplus-chat-room-<名前>-<hash>`）をここへ統合するので、別の channel サーバを指定しても部屋の入力路は残ります。実際に起動する行は入力欄の右に表示されます。
+
+タブの隣に「名前」と「色」があります。これはそのセッションが部屋で名乗る名前と、発言に付く色です。**起動のたびに選びます。** タブに固定された属性ではないので、同じタブから 2 つのセッションを、別々の名前と色で立てられます。色を選ばずに参加することもでき、その場合は名前から色が決まります。タイトルバーの「名前」「色」は同じものの人間側です。
 
 作業ディレクトリの入力欄があります。初回はホームディレクトリが入っているので、セッションを動かしたいディレクトリへ変更してください。この値はタブ設定として保存されます。
 
-右の参加者パネルに、部屋にいる参加者と、セッションの裏の値（部屋ソケット、セッションの生死、接続方法、起動コマンド、作業ディレクトリ、開始時刻、ウィンドウ）が出ます。発言の色は参加者ごとに違い、名簿の点と同じ色です。自分の色は accent（青）で、名簿では自分の行に「（あなた）」が付きます。
+右の参加者パネルに、部屋にいる参加者と、セッションの裏の値（部屋ソケット、セッションの生死、接続方法、起動コマンド、作業ディレクトリ、開始時刻、ウィンドウ）が出ます。発言の色は参加者ごとに違い、名簿の点と同じ色です。色は選んだものが優先され、選んでいなければ自分は accent（青）、他の参加者は名前から決まります。名簿では自分の行に「（あなた）」が付きます。
 
 「診断」を開くと**起動した CLI の端末**が出ます。端末はそのまま操作できます。CLI はフォルダごとに初回の信頼確認を出すため、最初の一回はここから答えてください。
 
@@ -66,8 +68,8 @@ npm run tauri dev
 
 タイトルバーでセッションを選び「セッション参加」を押すと、次の 2 つが行われます。
 
-1. そのタブの作業ディレクトリの `.mcp.json` へ、部屋のサイドカーを `liplus-chat-room` という名前で登録します。**既存の内容はマージして保持します**が、あなたのリポジトリのファイルを書き換える操作です。
-2. `--dangerously-load-development-channels server:liplus-chat-room` を付けて CLI を PTY 上の対話セッションとして起動します。
+1. そのタブの作業ディレクトリの `.mcp.json` へ、部屋のサイドカーを `liplus-chat-room-<名前>-<hash>` という名前で登録します。**既存の内容はマージして保持します**が、あなたのリポジトリのファイルを書き換える操作です。登録鍵を参加者ごとに分けているのは、同じ作業ディレクトリへ 2 つのセッションを立てたときに互いの登録を潰さないためです。前回の起動で書かれたエントリ（もう繋がらないポートを指しているもの）は、このとき掃除します。
+2. `--dangerously-load-development-channels server:liplus-chat-room-<名前>-<hash>` を付けて CLI を PTY 上の対話セッションとして起動します。
 
 > [!NOTE]
 > このフラグはローカルの channel 開発専用であり、起動ごとに警告バナーが出ます。一般配布には plugin として allowlist に載せる必要があり、そちらは未対応です。
diff --git a/crates/mcp-config/src/lib.rs b/crates/mcp-config/src/lib.rs
index ca42612..bbf5be6 100644
--- a/crates/mcp-config/src/lib.rs
+++ b/crates/mcp-config/src/lib.rs
@@ -17,9 +17,63 @@
 use serde_json::{json, Map, Value};
 use std::path::{Path, PathBuf};
 
-/// The name the sidecar is registered under in `.mcp.json`. The launch flag
-/// carries the same name (`server:<name>`), so the two must not drift apart.
-pub const SERVER_NAME: &str = "liplus-chat-room";
+/// Prefix of the name the sidecar is registered under in `.mcp.json`.
+///
+/// The full name is per participant (`server_name_for`), not one fixed key. Two
+/// sessions pointed at the same working directory write into the same file, and
+/// a single key means the second launch overwrites the first one's name, hue
+/// and room address — the identity the first session was launched with is gone
+/// while that session is still running (#40).
+pub const SERVER_PREFIX: &str = "liplus-chat-room";
+
+/// The `.mcp.json` key, and the `server:<name>` tag, for one participant.
+///
+/// A function of the declared name alone, so relaunching under the same name
+/// reuses its entry rather than accumulating a new one per launch. The readable
+/// half is a slug of the name; the hash is what makes the key total — a name
+/// with no ASCII in it (`マスター`) slugs to nothing, and two names can slug
+/// alike (`Lin` and `lin!`), and a key that collides is the collision this whole
+/// function exists to remove.
+pub fn server_name_for(agent_name: &str) -> String {
+    let slug = slugify(agent_name);
+    let hash = fnv1a(agent_name);
+    if slug.is_empty() {
+        format!("{SERVER_PREFIX}-{hash:08x}")
+    } else {
+        format!("{SERVER_PREFIX}-{slug}-{hash:08x}")
+    }
+}
+
+/// Lowercase ASCII alphanumerics, everything else a single separator.
+///
+/// This rides in a command-line flag (`server:<name>`) as well as in JSON, so
+/// it stays inside the character set every shell and console on the way leaves
+/// alone. Legibility only — `server_name_for` carries the uniqueness.
+fn slugify(name: &str) -> String {
+    let mut out = String::new();
+    for ch in name.chars() {
+        if ch.is_ascii_alphanumeric() {
+            out.push(ch.to_ascii_lowercase());
+        } else if !out.ends_with('-') && !out.is_empty() {
+            out.push('-');
+        }
+        if out.len() >= 24 {
+            break;
+        }
+    }
+    out.trim_matches('-').to_string()
+}
+
+/// FNV-1a, 32-bit. The same stable-spread hash the frontend derives a hue with;
+/// one hash idea in the codebase rather than two.
+fn fnv1a(text: &str) -> u32 {
+    let mut hash: u32 = 2_166_136_261;
+    for byte in text.as_bytes() {
+        hash ^= u32::from(*byte);
+        hash = hash.wrapping_mul(16_777_619);
+    }
+    hash
+}
 
 /// Flags that silently stop channel pushes from arriving.
 pub const INCOMPATIBLE_FLAGS: &[&str] =
@@ -34,6 +88,11 @@ pub struct RoomRegistration<'a> {
     pub token: &'a str,
     /// Display name this session speaks under.
     pub agent_name: &'a str,
+    /// Hue this session declared, in oklch degrees, or `None` when it declared
+    /// none. Absent rather than a default: the room derives a hue from the name
+    /// for an undeclared participant, and a value written here would be a
+    /// declaration the person never made.
+    pub agent_hue: Option<f64>,
     /// Absolute path of the sidecar entry point.
     pub sidecar_entry: &'a Path,
     /// Absolute path of the TypeScript runner that executes the entry point.
@@ -66,8 +125,12 @@ pub const CHANNEL_FLAG: &str = "--dangerously-load-development-channels";
 /// and takes the whole room down, and two copies of this flag is the same
 /// shape. Merging also means the room's input path cannot be dropped by
 /// configuring a different server — losing it is losing the room.
-pub fn channel_launch_args(base: &[String]) -> Vec<String> {
-    let room = format!("server:{SERVER_NAME}");
+///
+/// `server_name` is this participant's own (`server_name_for`), so the flag and
+/// the `.mcp.json` key stay one fact even though that fact now differs per
+/// session.
+pub fn channel_launch_args(base: &[String], server_name: &str) -> Vec<String> {
+    let room = format!("server:{server_name}");
     let mut args = base.to_vec();
 
     if args.iter().any(|arg| *arg == room) {
@@ -148,6 +211,7 @@ fn spawn_form(runner: &Path, entry: &Path) -> (&'static str, Vec<String>) {
 /// touched; existing servers and unrelated top-level keys survive verbatim.
 pub fn register_sidecar(dir: &Path, room: &RoomRegistration<'_>) -> Result<PathBuf, String> {
     let (command, args) = spawn_form(room.sidecar_runner, room.sidecar_entry);
+    let server_name = server_name_for(room.agent_name);
 
     let path = dir.join(".mcp.json");
     let mut root: Value = if path.exists() {
@@ -175,17 +239,42 @@ pub fn register_sidecar(dir: &Path, room: &RoomRegistration<'_>) -> Result<PathB
         return Err(format!("{} has a non-object mcpServers.", path.display()));
     }
 
-    servers.as_object_mut().expect("checked above").insert(
-        SERVER_NAME.to_string(),
+    let servers = servers.as_object_mut().expect("checked above");
+
+    // Entries this app wrote in an earlier run can never connect: the room
+    // binds a fresh port every run, so their address is dead. Left in place
+    // they would have every CLI started in this directory spawn a sidecar that
+    // retries nothing forever, and the file would grow by one key per name ever
+    // used here. Entries carrying the current address are live siblings — the
+    // other sessions of this run — and stay. Entries with no `LIPLUS_ROOM_URL`
+    // at all are not ours to judge, whatever they are named.
+    servers.retain(|name, entry| {
+        if !name.starts_with(SERVER_PREFIX) {
+            return true;
+        }
+        match entry.get("env").and_then(|env| env.get("LIPLUS_ROOM_URL")) {
+            Some(Value::String(url)) => url == room.room_url,
+            _ => true,
+        }
+    });
+
+    let mut env = Map::new();
+    env.insert("LIPLUS_ROOM_URL".into(), json!(room.room_url));
+    env.insert("LIPLUS_ROOM_TOKEN".into(), json!(room.token));
+    env.insert("LIPLUS_AGENT_NAME".into(), json!(room.agent_name));
+    env.insert("LIPLUS_ROOM_ID".into(), json!("liplus-chat"));
+    // Only when declared. An undeclared participant is a participant the room
+    // derives a hue for, which is not the same state as one who chose that hue.
+    if let Some(hue) = room.agent_hue {
+        env.insert("LIPLUS_AGENT_HUE".into(), json!(format!("{hue:.1}")));
+    }
+
+    servers.insert(
+        server_name,
         json!({
             "command": command,
             "args": args,
-            "env": {
-                "LIPLUS_ROOM_URL": room.room_url,
-                "LIPLUS_ROOM_TOKEN": room.token,
-                "LIPLUS_AGENT_NAME": room.agent_name,
-                "LIPLUS_ROOM_ID": "liplus-chat",
-            },
+            "env": Value::Object(env),
         }),
     );
 
@@ -228,6 +317,7 @@ mod tests {
             room_url: "ws://127.0.0.1:1234",
             token: "tok",
             agent_name: "Lin",
+            agent_hue: None,
             sidecar_entry: entry,
             sidecar_runner: runner,
         }
@@ -246,11 +336,20 @@ mod tests {
             register_sidecar(scratch.path(), &registration(&entry, &runner)).expect("register");
 
         let json = read(&path);
-        let server = &json["mcpServers"][SERVER_NAME];
+        let server = &json["mcpServers"][server_name_for("Lin")];
         assert_eq!(server["env"]["LIPLUS_ROOM_URL"], "ws://127.0.0.1:1234");
         assert_eq!(server["env"]["LIPLUS_ROOM_TOKEN"], "tok");
         assert_eq!(server["env"]["LIPLUS_AGENT_NAME"], "Lin");
         assert_eq!(server["env"]["LIPLUS_ROOM_ID"], "liplus-chat");
+        // Undeclared is the key absent, not a default value: a hue written here
+        // would be a declaration this participant never made.
+        assert!(
+            !server["env"]
+                .as_object()
+                .expect("env")
+                .contains_key("LIPLUS_AGENT_HUE"),
+            "an undeclared hue must leave no key behind"
+        );
 
         // Absolute paths and nothing looked up by name: the CLI runs this from
         // the user's own directory, where `npx tsx` found no tsx and asked to
@@ -284,34 +383,128 @@ mod tests {
         let json = read(&path);
         assert_eq!(json["mcpServers"]["theirs"]["command"], "their-server");
         assert_eq!(json["unrelated"], 42);
-        assert!(json["mcpServers"][SERVER_NAME].is_object());
+        assert!(json["mcpServers"][server_name_for("Lin")].is_object());
     }
 
     #[test]
-    fn re_registering_replaces_only_its_own_entry() {
+    fn re_registering_the_same_name_replaces_its_own_entry() {
         let scratch = Scratch::new();
         let entry = PathBuf::from(ENTRY);
         let runner = PathBuf::from(RUNNER);
 
         register_sidecar(scratch.path(), &registration(&entry, &runner)).expect("first");
         let second = RoomRegistration {
-            room_url: "ws://127.0.0.1:9999",
+            room_url: "ws://127.0.0.1:1234",
             token: "tok2",
-            agent_name: "Lay",
+            agent_name: "Lin",
+            agent_hue: Some(145.0),
             sidecar_entry: &entry,
             sidecar_runner: &runner,
         };
         let path = register_sidecar(scratch.path(), &second).expect("second");
 
         let json = read(&path);
-        let server = &json["mcpServers"][SERVER_NAME];
-        assert_eq!(server["env"]["LIPLUS_ROOM_URL"], "ws://127.0.0.1:9999");
-        assert_eq!(server["env"]["LIPLUS_AGENT_NAME"], "Lay");
+        let server = &json["mcpServers"][server_name_for("Lin")];
+        assert_eq!(server["env"]["LIPLUS_ROOM_TOKEN"], "tok2");
+        assert_eq!(server["env"]["LIPLUS_AGENT_HUE"], "145.0");
         assert_eq!(
             json["mcpServers"].as_object().expect("servers").len(),
             1,
-            "re-registering must not accumulate entries"
+            "relaunching under one name must not accumulate entries"
+        );
+    }
+
+    #[test]
+    fn two_participants_in_one_directory_keep_separate_entries() {
+        // The failure this key scheme exists for: two sessions pointed at the
+        // same working directory. Under one fixed key the second launch
+        // overwrote the first one's name while that session was still running,
+        // so the room heard one identity twice (#40).
+        let scratch = Scratch::new();
+        let entry = PathBuf::from(ENTRY);
+        let runner = PathBuf::from(RUNNER);
+
+        register_sidecar(scratch.path(), &registration(&entry, &runner)).expect("Lin");
+        let lay = RoomRegistration {
+            room_url: "ws://127.0.0.1:1234",
+            token: "tok",
+            agent_name: "Lay",
+            agent_hue: Some(25.0),
+            sidecar_entry: &entry,
+            sidecar_runner: &runner,
+        };
+        let path = register_sidecar(scratch.path(), &lay).expect("Lay");
+
+        let json = read(&path);
+        assert_eq!(
+            json["mcpServers"][server_name_for("Lin")]["env"]["LIPLUS_AGENT_NAME"],
+            "Lin",
+            "the first session's identity must survive the second launch"
+        );
+        assert_eq!(
+            json["mcpServers"][server_name_for("Lay")]["env"]["LIPLUS_AGENT_NAME"],
+            "Lay"
+        );
+        assert_eq!(json["mcpServers"].as_object().expect("servers").len(), 2);
+    }
+
+    #[test]
+    fn entries_from_a_previous_run_go_and_foreign_ones_stay() {
+        // The room binds a fresh port every run, so an entry carrying another
+        // address is one no sidecar can reach. Left behind, every CLI started
+        // in this directory would spawn one more sidecar retrying a dead port,
+        // and the file would grow by one key per name ever used here.
+        let scratch = Scratch::new();
+        std::fs::write(
+            scratch.path().join(".mcp.json"),
+            r#"{"mcpServers":{
+                 "liplus-chat-room": {"env":{"LIPLUS_ROOM_URL":"ws://127.0.0.1:1"}},
+                 "liplus-chat-room-lay-00000000": {"env":{"LIPLUS_ROOM_URL":"ws://127.0.0.1:1234"}},
+                 "liplus-chat-room-theirs": {"command":"not-ours"},
+                 "theirs": {"command":"their-server"}
+               }}"#,
+        )
+        .expect("seed");
+
+        let entry = PathBuf::from(ENTRY);
+        let runner = PathBuf::from(RUNNER);
+        let path =
+            register_sidecar(scratch.path(), &registration(&entry, &runner)).expect("register");
+
+        let json = read(&path);
+        let servers = json["mcpServers"].as_object().expect("servers");
+        assert!(
+            !servers.contains_key("liplus-chat-room"),
+            "an entry from a previous run must go"
+        );
+        assert!(
+            servers.contains_key("liplus-chat-room-lay-00000000"),
+            "a live sibling of this run must stay"
+        );
+        assert!(
+            servers.contains_key("liplus-chat-room-theirs"),
+            "an entry with no room address of ours is not ours to remove"
         );
+        assert!(servers.contains_key("theirs"));
+        assert!(servers.contains_key(&server_name_for("Lin")));
+    }
+
+    #[test]
+    fn a_server_name_is_a_function_of_the_declared_name() {
+        // Readable where the name has ASCII in it, and total where it has none:
+        // a name that slugged to nothing would put every such participant back
+        // on one key, which is the collision this replaces.
+        assert_eq!(server_name_for("Lin"), server_name_for("Lin"));
+        assert_ne!(server_name_for("Lin"), server_name_for("Lay"));
+        assert!(server_name_for("Lin").starts_with("liplus-chat-room-lin-"));
+        assert!(server_name_for("マスター").starts_with("liplus-chat-room-"));
+        assert_ne!(server_name_for("マスター"), server_name_for("ますたー"));
+        // Two names that slug alike are still two entries.
+        assert_ne!(server_name_for("Lin"), server_name_for("lin!"));
+        // Nothing outside the set a console and a JSON key both leave alone.
+        assert!(server_name_for("Lin さん / 2")
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '-'));
     }
 
     #[test]
@@ -365,13 +558,14 @@ mod tests {
         .map(|s| s.to_string())
         .collect();
 
-        let merged = channel_launch_args(&base);
+        let room = server_name_for("Lin");
+        let merged = channel_launch_args(&base, &room);
         assert_eq!(
             merged,
             vec![
                 "--dangerously-skip-permissions".to_string(),
                 CHANNEL_FLAG.to_string(),
-                format!("server:{SERVER_NAME}"),
+                format!("server:{room}"),
                 "server:github-webhook-mcp".to_string(),
             ]
         );
@@ -384,8 +578,9 @@ mod tests {
 
     #[test]
     fn does_not_add_the_room_twice() {
-        let base = vec![CHANNEL_FLAG.to_string(), format!("server:{SERVER_NAME}")];
-        assert_eq!(channel_launch_args(&base), base);
+        let room = server_name_for("Lin");
+        let base = vec![CHANNEL_FLAG.to_string(), format!("server:{room}")];
+        assert_eq!(channel_launch_args(&base, &room), base);
     }
 
     #[test]
@@ -416,13 +611,26 @@ mod tests {
     fn the_launch_flag_names_the_server_the_config_registers() {
         // The flag and the `.mcp.json` key are one fact in two places; a drift
         // between them fails as a room that never receives anything.
-        let args = channel_launch_args(&["--verbose".to_string()]);
+        let scratch = Scratch::new();
+        let entry = PathBuf::from(ENTRY);
+        let runner = PathBuf::from(RUNNER);
+        let path =
+            register_sidecar(scratch.path(), &registration(&entry, &runner)).expect("register");
+        let registered = read(&path)["mcpServers"]
+            .as_object()
+            .expect("servers")
+            .keys()
+            .next()
+            .expect("one entry")
+            .clone();
+
+        let args = channel_launch_args(&["--verbose".to_string()], &server_name_for("Lin"));
         assert_eq!(
             args,
             vec![
                 "--verbose".to_string(),
                 "--dangerously-load-development-channels".to_string(),
-                format!("server:{SERVER_NAME}"),
+                format!("server:{registered}"),
             ]
         );
     }
diff --git a/docs/0-requirements.md b/docs/0-requirements.md
index 654c029..8ad1c80 100644
--- a/docs/0-requirements.md
+++ b/docs/0-requirements.md
@@ -13,6 +13,8 @@
 - **参加者はひと種類である。** 人間もセッションも同じ参加者であり、違いは名前だけである。名簿は両者を同じ列に並べる。
 - **発言はひとつの行為である。** 誰が出しても同じフレームで、同じ経路を通り、全員へ配られる。発言者ごとに別の行為を用意しない。
 - **自分の発言は自分へ戻らない。** 抑止は接続の同一性で判定する。名前で判定すると、名前が衝突している間は他人の発言まで落ちる。
+- **参加者の同一性は接続にある。** 名簿は接続ごとに 1 席を持つ。名前は表示と宛先のための属性であって識別子ではなく、同名の 2 参加者はやはり 2 参加者である。
+- **名乗りは参加の時点で行う。** 名前も色も、参加者が場に加わるその瞬間に宣言する。人間もセッションも同じ形であり、設定ファイルに固定された属性ではない。
 - **宛先は誰でも名指せる。** 人間も宛先の選択肢に並ぶ。宛先は配送を絞らない（constraints の「単一ベンダー構成」参照）。
 
 この前提は後付けではない。当初のプロトコルは人間の発言を `say`、AI の発言を `reply` として別の行為に分けており、`reply` にはそもそも他の参加者へ配る線が引かれていなかった。並列に立てた 2 セッションが互いの発言を受け取らないという実測（2026-08-22）はその帰結であり、配送行の書き忘れではなく語の形の問題だった。統一フレーム `post` はこの是正である（#39）。
@@ -128,7 +130,7 @@ push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/in
 
 | 向き | type | フィールド |
 |---|---|---|
-| サイドカー → 部屋 | `hello` | `protocol` / `name` |
+| サイドカー → 部屋 | `hello` | `protocol` / `name` / `hue`（任意） |
 | サイドカー → 部屋 | `post` | `message_id` / `content` / `to`（任意） / `ts` |
 | 部屋 → サイドカー | `post` | `message_id` / `speaker` / `content` / `to`（任意） / `ts` |
 
@@ -136,10 +138,14 @@ push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/in
 
 `speaker` はサイドカーが送らない。部屋が、フレームの届いた接続に紐づく名前（`hello` の `name`）から刻む。送信側が名乗れる欄を持たないため、他の参加者を騙る余地が構造上無く、名簿と表示が食い違うこともない。宛先は名指せるが自分は名乗れない、という非対称がこの性質を作っている。
 
-未知の `type` は拒否せず無視する。部屋側がフレーム種別を増やしても、旧サイドカーが壊れないため。`protocol` はフレームの形が変わり、サイドカー側が気づく必要があるときに上げる。`say` / `reply` から `post` への統合で `protocol` を 2 へ上げた。サイドカーはアプリが `.mcp.json` へ書く同梱パスから起動するため、部屋とサイドカーの版が食い違う形が構造上無く、旧フレームとの互換は残していない。
+未知の `type` は拒否せず無視する。部屋側がフレーム種別を増やしても、旧サイドカーが壊れないため。`protocol` はフレームの形が変わり、サイドカー側が気づく必要があるときに上げる。`say` / `reply` から `post` への統合で `protocol` を 2 へ、`hello` への `hue` の追加で 3 へ上げた。サイドカーはアプリが `.mcp.json` へ書く同梱パスから起動するため、部屋とサイドカーの版が食い違う形が構造上無く、旧フレームとの互換は残していない。
 
 `to` は両方向で同じ語彙であり、宛先となる参加者の表示名を入れる。任意であり、無いときは `null` ではなくキーごと省く。
 
+`hello` は参加者の名乗りである。部屋での名前と、任意で色相を運ぶ。どちらも参加の時点の宣言であり、起動のたびに決まる。色相を宣言しない参加者は `hue` をキーごと省いて送る。既定値を入れると宣言と導出を部屋が区別できなくなり、色を選ばずに参加している状態が消えるためである。人間の側は同じ組を `room_join` で渡す。着席の経路は 1 本であり、人間とセッションで分かれない。
+
+**名簿の同一性は接続に置く。** 部屋は接続ごとに 1 席を持ち、切断ではその席だけを外す。名前を鍵にしていた間は、同名の 2 参加者が 1 エントリに畳まれ、片方の切断が両方を名簿から消していた（#40）。席は名乗り直しで置き換わる——名前を変えた参加者は同じ参加者である。
+
 **自分の発言の抑止**は部屋側で行う。部屋は接続ごとに origin を採番し、fan-out のときにその発言を出した接続だけを飛ばす。origin はフレームの外側をタグとして流れ、wire には出ない。したがって送信側は自分の origin を設定することも他人の origin を騙ることもできない。名前で判定しないのは、名前が衝突している間に他の参加者の発言まで落ちるためである（#40）。サイドカー側に自己判定は置かない。
 
 どの参加者の発言も、フロントエンドへは同一の `room-message` イベントとして届く。並び順の権威を 1 箇所に保つためであり、送信時にフロント側でローカルに追記しない。イベントは `own`（自分の発言かどうか）を伴う。表示上の区別を残す場合の軸はこれであり、人間か AI かではない。
@@ -191,10 +197,12 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 - タブ設定とセッションデータの JSON 永続化
 - MCP channel サーバ（Node サイドカー、`sidecar/`）
 - 部屋ソケット（Rust、`127.0.0.1` 任意ポート、Bearer トークン必須）
-- サーバの `.mcp.json` 登録（既存内容はマージして保持）と、成立条件を満たす CLI 起動フラグの適用
+- サーバの `.mcp.json` 登録（既存内容はマージして保持、登録鍵は参加者ごと、前回起動のエントリは掃除）と、成立条件を満たす CLI 起動フラグの適用
 - 部屋の作法（`instructions`）の初版
 - 発言の宛先（部屋 → `post.to` → channel の `meta.to`、送信は `say_to_room` の `to`）と、それを判定材料として名指しする `instructions`
-- 参加者モデル（統一 `post` フレーム、発言者以外の全参加者への配送、接続同一性による自分の発言の抑止、人間を含む名簿）
+- 参加者モデル（統一 `post` フレーム、発言者以外の全参加者への配送、接続同一性による自分の発言の抑止と名簿の同一性、人間を含む名簿）
+- 参加の時点の名乗り（起動ごとに選ぶ名前と色。人間側の名前欄と同じ形、`localStorage` に保持）
+- 宣言色（`hello` の `hue` / `room_join` の `hue`。宣言 > 自分の accent > 名前からの導出）
 - チャットルーム UI（メッセージ一覧、発言者表示、入力欄、参加者から選ぶ宛先）
 - 参加者パネル（名簿、参加者ごとの色、部屋ソケット、セッションの生死と終了コード、接続方法・起動コマンド・作業ディレクトリ・開始時刻・ウィンドウ）
 - 診断面（CLI の端末表示と入力）
@@ -209,7 +217,7 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 ### 未実装
 
-- 複数の AI セッションを同一の部屋へ参加させる運用（同時発話の抑制を含む）。参加者間で発言が届く経路は実装済みだが、実機での往復はまだ確認していない。2026-08-22 の実測（2 セッションが互いの発言を受け取らない）は #39 の修正前のものであり、修正後の再計測は済んでいない。
+- 複数の AI セッションを同一の部屋へ参加させる運用（同時発話の抑制を含む）。参加者間で発言が届く経路、起動ごとの名乗り、参加者ごとの登録鍵はいずれも実装済みだが、実機での往復はまだ確認していない。2026-08-22 の実測（2 セッションが互いの発言を受け取らない / 2 セッションがどちらも `Claude Code` を名乗る）は #39 と #40 の修正前のものであり、修正後の再計測は済んでいない。
 - 会話ログの永続化と観測 UI
 - plugin としての allowlist 掲載（配布の第二段階）
 
@@ -228,9 +236,19 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 | ライト（`#3a6ea5`） | 0.528 | 0.104 |
 | ダーク（`#7aa7d8`） | 0.715 | 0.087 |
 
-色相は参加者名から決まる。到着順ではない。順で決めると、再接続した参加者が別の色で戻り、色が「誰か」ではなく「いつ入ったか」を表すことになる。
+色相の出所は 3 段の梯子であり、上から順に決まる。
+
+1. **宣言** — 参加者が参加の時点で選んだ色相。
+2. **自分の accent** — 宣言が無く、かつ自分自身のとき。
+3. **名前からの導出** — それ以外。到着順ではない。順で決めると、再接続した参加者が別の色で戻り、色が「誰か」ではなく「いつ入ったか」を表すことになる。
+
+導出だけでは足りないことは実測で判明した。`Lin` 130.5 度 / `Lay` 165.5 度 / `マスター` 205.5 度と、実際に使う 3 名が 75 度の帯に収まる。accent と同じ低彩度では 35 度差を見分けられず、色で追うという目的が、まさに使う名前の組で弱まる。名前由来かつ安定という性質と、任意の 2 名の分離保証は両立しない。分離を得るには色を導出ではなく宣言にする必要がある（#40）。
+
+宣言できるのは色相だけである。明度と彩度は上表のまま動かさない。選んだ色相によらずライト / ダークの両方で読める、という条件を保つためである。宣言は 8 色から選ぶ。連続した色相環にしない。買う必要があるのは「任意の 2 名を見分けられること」であって、度数を人間に判断させることではない。
 
-自分は色相を振らず `--accent` そのものを使い、名前から derive される色相は accent の周囲 50 度を空ける。以前の色分けは自分 / 他人の二値であり（#39）、自分以外の全員が同じ色になっていた。参加者ごとの色相へ移したあとも自分の発言が自分のものと分かるのは、この 1 色が予約されているためである。名簿の自分の行には「（あなた）」が付く。
+宣言が accent より上にあるのは、宣言した本人にだけ出ない色は宣言した色ではないからである。以前の色分けは自分 / 他人の二値であり（#39）、自分以外の全員が同じ色になっていた。accent は自分の**既定**として残るため、色を宣言しない参加者の見え方はこれまでと変わらない。宣言した場合に自分を自分と判じる手段は、名簿の「（あなた）」と、行に出ている自分の名前である。色はその 3 つのうち最も速い経路であって、唯一の経路ではなかった。宣言によって、色は割り当てられるものから選ぶものへ移る。
+
+名前から導出する色相は accent の周囲 50 度を空ける。宣言した色相は空けない。空けるのは名前がたまたま自分の色に当たることを避けるためであり、選んだ結果として当たるのは選択である。
 
 端末はこのパネルへ畳まない。設計キャンバスは右下へ同居させているが、パネルの幅では CLI が枠を描けない（下記「診断面」）。
 
@@ -261,11 +279,13 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 セッションの起動オプションは画面から編集でき、タブ設定として保存する。
 
-アプリ自身の channel エントリ（`server:liplus-chat-room`）は、利用者が書いたものへ**統合**する。利用者が `--dangerously-load-development-channels` を書いていればその直後へ挿入し、書いていなければフラグごと足す。第二のフラグとしては足さない。同一フラグの二重指定は `--channels` 併記と同じ形であり、成立条件が壊れる。
+アプリ自身の channel エントリ（`server:liplus-chat-room-<slug>-<hash>`）は、利用者が書いたものへ**統合**する。利用者が `--dangerously-load-development-channels` を書いていればその直後へ挿入し、書いていなければフラグごと足す。第二のフラグとしては足さない。同一フラグの二重指定は `--channels` 併記と同じ形であり、成立条件が壊れる。
 
 統合であって上書きではない。利用者が別の channel サーバを指定しても、部屋のエントリは落ちない。落ちれば部屋の入力路そのものが消える。
 
-実際に起動する行は画面に表示する。書いた行と走る行が違う以上、結果を見せるほうが説明より安い。
+このエントリの名前は参加者ごとに異なる。`.mcp.json` の登録鍵と `server:` タグは同じ 1 つの事実であり、鍵が分かれればタグも分かれる（下記「`.mcp.json` の登録単位」）。
+
+実際に起動する行は画面に表示する。書いた行と走る行が違う以上、結果を見せるほうが説明より安い。表示は名前の入力に追従する。エントリ名がその名前から決まるためであり、これは副作用ではなく要点である——この起動がいま選んでいるのは、そのセッションが名乗る identity そのものである。
 
 **実測済み（2026-08-21）**: 複数の channel サーバを同時に有効化した状態で往復が成立した。`--print` での確認は無意味である（channel の読み込み自体が走らないため）ことも実測しており、確認は対話セッションでのみ可能。
 
@@ -275,6 +295,32 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 `npm run tauri dev` ではアプリのプロセス cwd が `src-tauri/` になるため、暗黙のフォールバックはセッションを `src-tauri/` で起動させ、`.mcp.json` もそこへ書く。作業ディレクトリはユーザーの選択であって、アプリのプロセスがたまたま居た場所ではない。初回はホームディレクトリを prefill するが、これは既定値ではなく prefill である。画面に出ていないディレクトリでセッションを起動しない。
 
+### 参加の時点の名乗り
+
+参加者は名前と色を、参加のその時点で宣言する。
+
+人間の側は以前からこの形だった。タイトルバーの名前欄に書いた名前が `localStorage` に残り、`room_join` で着席する。エージェントの側にこの形が無かったことが #40 の中身である。
+
+セッションの名前はタブの属性ではない。タブは「どの CLI を起動するか」を言うものであり、部屋で誰として加わるかは起動のたびに選ぶ。名前をタブに置いていた間は、既定のタブが 1 つ・その名前が `Claude Code` の 1 つだけで、タブを増やす UI も名前を編集する UI も無かった。したがって何回起動しても全員が `Claude Code` を名乗り、作業ディレクトリを分けても変わらなかった。宛先（#31）が名指す先を区別できなかったのはこの帰結である。
+
+名前は人間が読んで選ぶものである。UUID などの機械的な一意化で置き換えない。宛先の選択肢に出るのはこの名前であり、そこから 1 名を選べることが目的である。
+
+名前と色はランチャの入力欄と選択で決め、`localStorage` に残す。人間側と同じ場所・同じ形であり、タブ設定（`config.json`）には入れない。タブに保存すると、それは再び「設定ファイルに固定された名前」になる。ランチャの名前欄にはタブのラベルを prefill するが、これは既定値ではなく prefill である——画面に出ていて編集できることが、以前と違う点そのものである。
+
+名前が空のままの起動は拒否する。黙ってタブのラベルへ落とすと、この面が塞ごうとしている状態がそのまま戻る。
+
+### `.mcp.json` の登録単位
+
+`.mcp.json` の登録鍵は参加者ごとに分ける。名前は `liplus-chat-room-<slug>-<hash>` であり、宣言された名前だけから決まる。
+
+鍵が 1 つに固定されていたときは、同じ作業ディレクトリを指す 2 セッションが同じ鍵を上書きした。2 つめの起動が 1 つめの名前・色・部屋アドレスを書き換え、1 つめのセッションがまだ動いている間にその識別が消える（#40）。2026-08-22 の実測では作業ディレクトリが分かれていたためこの経路は発火していないが、名前を起動ごとに選べるようにすると露出する。
+
+鍵を起動ごとの id にはしない。それでは起動のたびに 1 つ増え、ユーザーのリポジトリのファイルが際限なく伸びる。名前だけの関数にすることで、同じ名前で立て直したときは同じエントリを使い回す。
+
+slug は読みやすさのためだけにあり、ASCII 英数字と `-` に落とす。一意性は hash が担う。ASCII を含まない名前（`マスター`）は slug が空になり、異なる名前が同じ slug に落ちること（`Lin` と `lin!`）もあるためである。slug が空のときは hash だけで鍵を作る。
+
+登録のたびに、`liplus-chat-room` で始まり `LIPLUS_ROOM_URL` が現在の部屋アドレスと異なるエントリを削除する。部屋は起動ごとに新しいポートを取るため、それらは前回起動の残りであり、どのサイドカーも到達できない。残しておくと、この作業ディレクトリで CLI を起動するたびに死んだポートへ再試行するサイドカーが 1 つずつ増える。現在のアドレスを持つエントリは同一起動の別セッションであるから残す。`LIPLUS_ROOM_URL` を持たないエントリは、名前が前方一致しても他人のものとして触らない。
+
 ## テストの配置
 
 `.mcp.json` への登録と起動フラグの検査は、`crates/mcp-config/` という tauri 非依存の crate に置く。
@@ -299,10 +345,10 @@ CI が実行するもの:
 
 1. **部屋ソケットが待ち受けているか。** 右の参加者パネルの部屋ソケットの行を見る。`127.0.0.1:<port>` が accent 色で出ていなければ以降はすべて不成立。
 2. **セッションが生きているか。** 同じパネルのセッション行を見る。`終了（終了コード N）` なら CLI が落ちている。理由はタイトルバーの「診断」を開いた先の端末に残る。CLI が確認プロンプトで止まっている場合は、端末へ直接答える。
-3. **サイドカーが接続したか。** パネルの名簿に**セッション名**が出る。自分（人間）は発言前から名簿に載っているため、名簿が空でないことは接続の根拠にならない。セッション名が出ない場合は端末に `room socket: connected as "<name>"` があるかを見る。
+3. **サイドカーが接続したか。** パネルの名簿に**そのセッションが名乗った名前**が出る。起動時にランチャで入れた名前である。自分（人間）は発言前から名簿に載っているため、名簿が空でないことは接続の根拠にならない。名前が出ない場合は端末に `room socket: connected as "<name>"` があるかを見る。
 4. **サイドカー単体が壊れていないか。** `npm run sidecar:test` を実行する。偽の部屋ソケットを立てて両面を駆動するため、通ればサイドカーではなくアプリ側の問題に絞れる。
-5. **`.mcp.json` の登録が効いているか。** セッションの作業ディレクトリの `.mcp.json` に `liplus-chat-room` が入っているかを見る。`--mcp-config` によるファイル渡しでは channel 側が名前を解決できないため、正式登録以外の経路は成立しない。
-6. **起動フラグが単独指定になっているか。** `--dangerously-load-development-channels server:liplus-chat-room` 以外に `--channels` が付いていると、同一サーバが二重登録され全体が不通になる。タブ設定に `--channels` / `--print` / `--input-format` / `--output-format` がある場合、セッション起動はエラーで止まる（黙って外すと動いたように見えるため）。
+5. **`.mcp.json` の登録が効いているか。** セッションの作業ディレクトリの `.mcp.json` に、そのセッションの名前の `liplus-chat-room-<slug>-<hash>` が入っているかを見る。鍵は参加者ごとであり、固定の `liplus-chat-room` は前回起動の残りとして掃除される側である。`--mcp-config` によるファイル渡しでは channel 側が名前を解決できないため、正式登録以外の経路は成立しない。
+6. **起動フラグが単独指定になっているか。** `--dangerously-load-development-channels server:liplus-chat-room-<slug>-<hash>` 以外に `--channels` が付いていると、同一サーバが二重登録され全体が不通になる。タブ設定に `--channels` / `--print` / `--input-format` / `--output-format` がある場合、セッション起動はエラーで止まる（黙って外すと動いたように見えるため）。
 7. **対話セッションになっているか。** `--print` 系では push が届かない。PTY 経由の対話起動であることを確認する。
 
 ## UI の方向（2026-08-21 時点、暫定）
@@ -311,7 +357,7 @@ CI が実行するもの:
 
 2 枚のアートボードを並べ、その差分をロードマップとして読む形にしてある。
 
-- **次の一手** — 現在の実装に参加者パネルと宛先を足した、実装可能な範囲。両方とも実装済みになったため、この 1 枚と実装の差は操作ボタン（端末 / リサイズ / 終了）と宛先の見た目（削除可能なチップ）だけである。宛先は `<select>` で機能的に等価であり、形の差は追っていない。
+- **次の一手** — 現在の実装に参加者パネルと宛先を足した、実装可能な範囲。両方とも実装済みである。この 1 枚と実装の差は、操作ボタン（端末 / リサイズ / 終了）、宛先の見た目（削除可能なチップ）、そして #40 でランチャとタイトルバーに入った名乗り（名前欄と色の選択）である。宛先は `<select>` で機能的に等価であり、形の差は追っていない。名乗りの側はキャンバスが実装より古い。
 - **全体像** — ルーム一覧 / ダイレクト / 参加者・セッション状態パネル
 
 色と寸法は `src/styles.css` の実値をそのまま使っている（`--accent: #3a6ea5` / `--surface: #f4f4f7` / 角丸 4・6px / system-ui + Yu Gothic UI）。参加者ごとの色は accent と同じ彩度・明度で色相だけ変えたもの。絵と実装が同じトークンの上に乗るため、キャンバスの値をそのまま実装へ移せる。
@@ -323,7 +369,8 @@ CI が実行するもの:
 - 会話面はメッセージ単位を保つ。端末は診断面側に置き、会話面には置かない。
 - 参加者パネルを持つ（実装済み。上記「参加者パネル」）。セッションの接続方法・起動コマンド・作業ディレクトリ・開始時刻を出す。操作（端末 / ミュート / 終了）は未実装であり、キャンバス側にのみある。
 - 発言に宛先を持たせる（実装済み。入力欄の左で参加者から選ぶ。既定は全体宛）。
-- 参加者ごとの色（実装済み。accent と同じ明度・彩度で色相のみ）。
+- 参加者ごとの色（実装済み。accent と同じ明度・彩度で色相のみ）。色相は宣言でき、宣言が導出に優先する（上記「参加者パネル」の梯子）。
+- 名前と色は参加の時点で決める（実装済み。人間はタイトルバー、セッションはランチャ。タブ属性にしない）。
 
 ### 決まっていないこと
 
diff --git a/index.html b/index.html
index b85d88c..bacc398 100644
--- a/index.html
+++ b/index.html
@@ -15,15 +15,35 @@
              participant panel's list now: two renderings of one roster is one
              surface too many, and the panel is always on screen. -->
         <span class="spacer"></span>
+        <!-- Who this screen's person is in the room: the name they answer to
+             and the colour they are drawn in. One pair, declared together,
+             because they are one declaration — this is who I am here. The
+             launcher below carries the same pair for a session. -->
         <label class="who">
           名前
           <input id="display-name" type="text" value="human" spellcheck="false" />
         </label>
+        <label class="who">
+          色
+          <select id="display-hue"></select>
+        </label>
         <button id="toggle-diagnostics" type="button" aria-expanded="false">診断</button>
       </header>
 
       <div id="launcher">
         <select id="tab-select" aria-label="起動するセッション"></select>
+        <!-- The name and colour this session joins under. Not the tab's: the
+             tab says which CLI to run, and every launch off one tab used to
+             answer to that one name, which left two sessions indistinguishable
+             and unaddressable (#40). -->
+        <label class="who">
+          名前
+          <input id="session-name" type="text" spellcheck="false" />
+        </label>
+        <label class="who">
+          色
+          <select id="session-hue"></select>
+        </label>
         <label class="cwd">
           作業ディレクトリ
           <input id="session-cwd" type="text" spellcheck="false" />
diff --git a/sidecar/src/index.ts b/sidecar/src/index.ts
index d688cc8..a919a04 100644
--- a/sidecar/src/index.ts
+++ b/sidecar/src/index.ts
@@ -38,7 +38,23 @@ const AGENT_NAME = process.env.LIPLUS_AGENT_NAME ?? "session";
 const ROOM_TOKEN = process.env.LIPLUS_ROOM_TOKEN ?? "";
 const CHAT_ID = process.env.LIPLUS_ROOM_ID ?? "liplus-chat";
 
-const PROTOCOL_VERSION = 2;
+/**
+ * The hue this session was launched under, in oklch degrees, or null when it
+ * was launched without one.
+ *
+ * Null rather than a default. An undeclared participant is one the room derives
+ * a colour for from their name, and a number invented here would be indelible:
+ * the room cannot tell a declaration from a fallback once it is on the wire.
+ */
+const AGENT_HUE = readHue(process.env.LIPLUS_AGENT_HUE);
+
+function readHue(raw: string | undefined): number | null {
+  if (raw === undefined || raw.trim() === "") return null;
+  const hue = Number(raw);
+  return Number.isFinite(hue) ? hue : null;
+}
+
+const PROTOCOL_VERSION = 3;
 
 function log(line: string): void {
   process.stderr.write(`[liplus-chat sidecar] ${line}\n`);
@@ -47,7 +63,7 @@ function log(line: string): void {
 // ── Room frames ──────────────────────────────────────────────────────────────
 //
 // Sidecar -> room:
-//   { type: "hello", protocol, name }
+//   { type: "hello", protocol, name, hue? }
 //   { type: "post",  message_id, content, to?, ts }
 // Room -> sidecar:
 //   { type: "post",  message_id, speaker, content, to?, ts }
@@ -61,6 +77,12 @@ function log(line: string): void {
 // everyone regardless — whether an utterance is yours to answer is decided
 // here, by the agent, not by the room narrowing its delivery.
 //
+// `hello` is where this session says who it is: the name it answers to and,
+// when it was launched with one, the hue it is drawn in. Both arrive from the
+// launch (`LIPLUS_AGENT_NAME` / `LIPLUS_AGENT_HUE`) rather than from anything
+// this file decides, because both are the person's declaration, made at the
+// moment of joining.
+//
 // A participant never receives its own post. The room drops it on the way out,
 // judged on the connection it arrived on, so nothing here has to recognise
 // itself — and a name collision cannot make this side swallow someone else's
@@ -269,7 +291,14 @@ function connectRoom(): void {
     retryCount = 0;
     lastError = "";
     log(`room socket: connected as "${AGENT_NAME}"`);
-    sendToRoom({ type: "hello", protocol: PROTOCOL_VERSION, name: AGENT_NAME });
+    // The hue key is omitted when none was declared, for the same reason `to`
+    // is: the room must be able to tell "declared nothing" from a value.
+    sendToRoom({
+      type: "hello",
+      protocol: PROTOCOL_VERSION,
+      name: AGENT_NAME,
+      ...(AGENT_HUE === null ? {} : { hue: AGENT_HUE }),
+    });
     pingTimer = setInterval(() => {
       if (socket.readyState === WebSocket.OPEN) socket.ping();
     }, PING_INTERVAL);
diff --git a/sidecar/test/round-trip.test.mjs b/sidecar/test/round-trip.test.mjs
index d4c891b..3ea2815 100644
--- a/sidecar/test/round-trip.test.mjs
+++ b/sidecar/test/round-trip.test.mjs
@@ -71,6 +71,7 @@ test("a room post reaches the channel, and say_to_room reaches the room", async
         ...process.env,
         LIPLUS_ROOM_URL: `ws://127.0.0.1:${port}`,
         LIPLUS_AGENT_NAME: "test-agent",
+        LIPLUS_AGENT_HUE: "145",
         LIPLUS_ROOM_ID: "test-room",
       },
       stdio: ["pipe", "pipe", "pipe"],
@@ -189,8 +190,13 @@ test("a room post reaches the channel, and say_to_room reaches the room", async
   // ── room -> agent ──────────────────────────────────────────────────────────
   await withTimeout(connected.promise, "sidecar to connect to the room");
   const hello = await withTimeout(helloSeen.promise, "hello frame");
+  // Who this session is in the room, declared at the moment of joining: the
+  // name it answers to, and the hue it is drawn in. Both come from the launch,
+  // not from a stored tab attribute — a stored one made every session answer to
+  // the same name (#40).
   assert.equal(hello.name, "test-agent");
-  assert.equal(hello.protocol, 2);
+  assert.equal(hello.hue, 145);
+  assert.equal(hello.protocol, 3);
 
   roomSocket.send(
     JSON.stringify({
@@ -303,3 +309,52 @@ test("a room post reaches the channel, and say_to_room reaches the room", async
     "a send with no room attached must report failure, not silence",
   );
 });
+
+test("a session launched without a declared hue says so by omission", async (t) => {
+  // The undeclared state has to survive the wire. The room derives a colour
+  // from the name for a participant who chose none, and it can only do that
+  // while "chose none" is still distinguishable from a number a default put
+  // there (#40).
+  const http = createServer();
+  const wss = new WebSocketServer({ server: http });
+  await new Promise((r) => http.listen(0, "127.0.0.1", r));
+  const port = http.address().port;
+
+  const helloSeen = deferred();
+  wss.on("connection", (socket) => {
+    socket.on("message", (raw) => {
+      const frame = JSON.parse(raw.toString());
+      if (frame.type === "hello") helloSeen.resolve(frame);
+    });
+  });
+
+  const child = spawn(
+    process.execPath,
+    [join(REPO, "node_modules", "tsx", "dist", "cli.mjs"), ENTRY],
+    {
+      cwd: REPO,
+      env: {
+        ...process.env,
+        LIPLUS_ROOM_URL: `ws://127.0.0.1:${port}`,
+        LIPLUS_AGENT_NAME: "no-colour",
+        LIPLUS_AGENT_HUE: "",
+        LIPLUS_ROOM_ID: "test-room",
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+    },
+  );
+  // Nothing reads either pipe in this test, and a full one would block the
+  // sidecar before it ever reaches the socket.
+  child.stdout.resume();
+  child.stderr.resume();
+
+  t.after(() => {
+    child.kill();
+    wss.close();
+    http.close();
+  });
+
+  const hello = await withTimeout(helloSeen.promise, "hello frame");
+  assert.equal(hello.name, "no-colour");
+  assert.equal("hue" in hello, false, "an undeclared hue must carry no key");
+});
diff --git a/src-tauri/src/config.rs b/src-tauri/src/config.rs
index 7573617..4ef400a 100644
--- a/src-tauri/src/config.rs
+++ b/src-tauri/src/config.rs
@@ -6,6 +6,11 @@ use tauri::Manager;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TabConfig {
     pub id: String,
+    /// The tab's label — which CLI this launches. Not the name a session speaks
+    /// under in the room: that is declared per launch and passed to
+    /// `start_session` beside the tab. A tab is a launch recipe and lives in
+    /// this file; who joins the room is a choice made at the moment of joining,
+    /// and a stored one made every session answer to the same name (#40).
     pub name: String,
     pub command: String,
     pub args: Vec<String>,
@@ -50,6 +55,10 @@ impl Default for AppConfig {
         // spec drops the second vendor to keep that premise out of the
         // design. Shipping a tab that cannot join the room by default would
         // present a session that never speaks. See docs/0-requirements.md.
+        //
+        // `Claude Code` names the CLI, and that is all it names now. It used to
+        // be the name the session took in the room as well, which is why every
+        // session took that one.
         AppConfig {
             tabs: vec![TabConfig {
                 id: "tab-1".to_string(),
diff --git a/src-tauri/src/room.rs b/src-tauri/src/room.rs
index e5e706a..f0db8e8 100644
--- a/src-tauri/src/room.rs
+++ b/src-tauri/src/room.rs
@@ -6,7 +6,7 @@
 //!
 //! Frames on the wire are the room protocol:
 //!
-//!   sidecar -> room : { type: "hello", protocol, name }
+//!   sidecar -> room : { type: "hello", protocol, name, hue? }
 //!   both ways       : { type: "post", message_id, speaker, content, to?, ts }
 //!
 //! One frame kind carries speech, whoever produced it. A person and a session
@@ -24,13 +24,23 @@
 //! never read off the frame. A sender cannot claim to be someone else, and the
 //! roster and the attribution cannot disagree.
 //!
+//! `hello` carries who this participant is in the room: the name they answer to
+//! and, optionally, the hue they chose to be drawn in. Both are declarations
+//! made at the moment of joining, which is the one moment a participant has to
+//! make them — the same moment, and the same pair, the screen's own person
+//! declares through `room_join`.
+//!
+//! Roster identity is the connection, not the name. Two participants may answer
+//! to one name; they are still two, and one of them leaving must not take the
+//! other off the roster (#40).
+//!
 //! Everything the frontend needs arrives as a `room-message` event. The room
 //! never reads a CLI's terminal output; that is not a message source.
 
 use futures_util::{SinkExt, StreamExt};
 use parking_lot::Mutex;
 use serde::{Deserialize, Serialize};
-use std::collections::BTreeSet;
+use std::collections::BTreeMap;
 use std::sync::Arc;
 use tauri::{AppHandle, Emitter};
 use tokio::net::TcpListener;
@@ -43,7 +53,8 @@ use uuid::Uuid;
 /// Bumped when a frame's shape changes in a way a sidecar must notice.
 ///
 /// 2: `say` and `reply` collapsed into one `post` frame; `agent` became `name`.
-pub const PROTOCOL_VERSION: u32 = 2;
+/// 3: `hello` carries the declared `hue` beside the name.
+pub const PROTOCOL_VERSION: u32 = 3;
 
 /// One post of the room, as the frontend sees it.
 ///
@@ -55,6 +66,11 @@ pub struct RoomMessage {
     pub message_id: String,
     /// Display name of the speaker.
     pub speaker: String,
+    /// The hue the speaker declared, in oklch degrees, or `None` when they
+    /// declared none. Carried on the message rather than looked up by name on
+    /// the screen: a name is not an identity here, so a lookup by name is the
+    /// wrong participant as soon as two answer to one name.
+    pub hue: Option<f64>,
     pub content: String,
     pub to: Option<String>,
     pub ts: String,
@@ -62,6 +78,23 @@ pub struct RoomMessage {
     pub own: bool,
 }
 
+/// One participant of the room, as the roster shows them.
+///
+/// `id` is the connection, and it is what the roster is keyed on. `name` is
+/// what they are called and what a post can be addressed to — a display and
+/// addressing attribute, never the identity.
+#[derive(Debug, Clone, Serialize)]
+pub struct Participant {
+    pub id: String,
+    pub name: String,
+    /// Declared at join; `None` when this participant declared none, which the
+    /// screen answers by deriving one from the name.
+    pub hue: Option<f64>,
+    /// True for this screen's own person. Viewer-relative, like a message's
+    /// `own`, and there is one screen.
+    pub own: bool,
+}
+
 /// A post as it happened, before any viewer-relative framing.
 struct Post {
     message_id: String,
@@ -89,19 +122,28 @@ struct IncomingFrame {
     kind: String,
     message_id: Option<String>,
     name: Option<String>,
+    hue: Option<f64>,
     content: Option<String>,
     to: Option<String>,
     ts: Option<String>,
     protocol: Option<u32>,
 }
 
+/// What the room holds about one seated participant.
+#[derive(Debug, Clone)]
+struct Seat {
+    name: String,
+    hue: Option<f64>,
+}
+
 struct RoomInner {
     port: Option<u16>,
-    /// Everyone in the room, people and sessions alike.
-    participants: BTreeSet<String>,
-    /// The name this screen's person currently answers to, so a rename
-    /// replaces the roster entry rather than adding a second one.
-    local_name: Option<String>,
+    /// Everyone in the room, people and sessions alike, keyed by the connection
+    /// they are in it on. Keyed on the connection rather than the name because
+    /// a name is not unique: under a name-keyed roster two participants called
+    /// `Claude Code` were one entry, and either of them disconnecting removed
+    /// both (#40).
+    participants: BTreeMap<String, Seat>,
 }
 
 /// Shared handle to the room socket. Cloneable; all clones share one room.
@@ -124,8 +166,7 @@ impl RoomState {
         RoomState {
             inner: Arc::new(Mutex::new(RoomInner {
                 port: None,
-                participants: BTreeSet::new(),
-                local_name: None,
+                participants: BTreeMap::new(),
             })),
             to_participants,
             token: Uuid::new_v4().to_string(),
@@ -141,39 +182,69 @@ impl RoomState {
         self.inner.lock().port
     }
 
-    pub fn participants(&self) -> Vec<String> {
-        self.inner.lock().participants.iter().cloned().collect()
-    }
-
-    fn set_port(&self, port: u16) {
-        self.inner.lock().port = Some(port);
+    /// The roster, in name order.
+    ///
+    /// Ordered by name because that is what is read, and tie-broken on the id
+    /// so two participants sharing a name hold a stable order rather than
+    /// swapping places between emits.
+    pub fn participants(&self) -> Vec<Participant> {
+        let inner = self.inner.lock();
+        let mut roster: Vec<Participant> = inner
+            .participants
+            .iter()
+            .map(|(id, seat)| Participant {
+                id: id.clone(),
+                name: seat.name.clone(),
+                hue: seat.hue,
+                own: *id == self.local_origin,
+            })
+            .collect();
+        roster.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.id.cmp(&b.id)));
+        roster
     }
 
-    fn add_participant(&self, name: &str) {
-        self.inner.lock().participants.insert(name.to_string());
+    /// The hue declared by whoever is on `origin`, for stamping onto a post.
+    fn hue_of(&self, origin: &str) -> Option<f64> {
+        self.inner.lock().participants.get(origin).and_then(|seat| seat.hue)
     }
 
-    fn remove_participant(&self, name: &str) {
-        self.inner.lock().participants.remove(name);
+    fn set_port(&self, port: u16) {
+        self.inner.lock().port = Some(port);
     }
 
-    /// Seat this screen's person in the room under `name`, replacing an
-    /// earlier seat.
+    /// Seat a participant on the connection they arrived on.
     ///
-    /// Returns true when the roster changed, so a rename that is not a rename
-    /// does not emit a roster event.
-    fn seat_local(&self, name: &str) -> bool {
+    /// One seat per connection, so re-seating replaces rather than adds: a
+    /// participant who renames themselves is the same participant.
+    ///
+    /// Returns true when the roster changed, so a declaration that declares
+    /// nothing new does not emit a roster event.
+    fn seat(&self, origin: &str, name: &str, hue: Option<f64>) -> bool {
         let mut inner = self.inner.lock();
-        if inner.local_name.as_deref() == Some(name) {
-            return false;
-        }
-        if let Some(previous) = inner.local_name.take() {
-            inner.participants.remove(&previous);
+        let seat = Seat {
+            name: name.to_string(),
+            hue,
+        };
+        match inner.participants.get(origin) {
+            Some(current) if current.name == seat.name && current.hue == seat.hue => false,
+            _ => {
+                inner.participants.insert(origin.to_string(), seat);
+                true
+            }
         }
-        inner.participants.insert(name.to_string());
-        inner.local_name = Some(name.to_string());
-        true
     }
+
+    fn unseat(&self, origin: &str) {
+        self.inner.lock().participants.remove(origin);
+    }
+}
+
+/// A hue is a position on the colour wheel, so it is taken modulo a turn rather
+/// than rejected. `None` for a value that is not a number at all: an undeclared
+/// hue and an unusable one are the same state to the screen, which derives one.
+fn normalize_hue(hue: Option<f64>) -> Option<f64> {
+    hue.filter(|value| value.is_finite())
+        .map(|value| value.rem_euclid(360.0))
 }
 
 /// Absent is the key omitted, never an empty one: a participant matching `to`
@@ -253,6 +324,9 @@ fn deliver(app: &AppHandle, room: &RoomState, origin: &str, post: Post) {
         RoomMessage {
             message_id: post.message_id,
             speaker: post.speaker,
+            // Read off the seat on this connection, so the colour of a line and
+            // the colour of its author's roster entry are the one declaration.
+            hue: room.hue_of(origin),
             content: post.content,
             to: post.to,
             ts: post.ts,
@@ -368,7 +442,9 @@ async fn serve_participant(
                         frame.protocol
                     );
                 }
-                room.add_participant(&name);
+                // Seated on this connection. A second session answering to the
+                // same name is a second seat, not the same one.
+                room.seat(&origin, &name, normalize_hue(frame.hue));
                 joined_as = Some(name);
                 let _ = app.emit("room-participants", room.participants());
             }
@@ -396,8 +472,11 @@ async fn serve_participant(
     }
 
     pump.abort();
-    if let Some(name) = joined_as {
-        room.remove_participant(&name);
+    if joined_as.is_some() {
+        // By connection. Removing by name took every participant answering to
+        // that name off the roster, so one session ending emptied the other's
+        // seat too (#40).
+        room.unseat(&origin);
         let _ = app.emit("room-participants", room.participants());
     }
     Ok(())
@@ -411,26 +490,32 @@ pub fn room_port(state: tauri::State<RoomState>) -> Option<u16> {
 }
 
 #[tauri::command]
-pub fn room_participants(state: tauri::State<RoomState>) -> Vec<String> {
+pub fn room_participants(state: tauri::State<RoomState>) -> Vec<Participant> {
     state.participants()
 }
 
-/// Seat this screen's person in the room under `name`.
+/// Seat this screen's person in the room, under the name and hue they declared.
 ///
 /// A person is in the room by being there, not by speaking: without this the
 /// roster would list only sessions until the first utterance, and nobody could
 /// address someone who had not spoken yet.
+///
+/// `hue` is optional and the same declaration a session makes in its `hello`.
+/// The screen's person and a session take one seat of the same kind, and there
+/// is one path to it.
 #[tauri::command]
 pub fn room_join(
     app: AppHandle,
     state: tauri::State<RoomState>,
     name: String,
+    hue: Option<f64>,
 ) -> Result<(), String> {
     let name = name.trim().to_string();
     if name.is_empty() {
         return Err("name is empty".to_string());
     }
-    if state.seat_local(&name) {
+    let local_origin = state.local_origin.clone();
+    if state.seat(&local_origin, &name, normalize_hue(hue)) {
         let _ = app.emit("room-participants", state.participants());
     }
     Ok(())
@@ -459,13 +544,16 @@ pub fn room_post(
         return Err("speaker is empty".to_string());
     }
     // Speaking is being present. A post under a name the roster has not seen
-    // seats it, so the two cannot disagree.
-    if state.seat_local(&speaker) {
+    // seats it, so the two cannot disagree. The hue is left as it stands: the
+    // composer declares nothing, and passing `None` here would silently
+    // withdraw a declaration the person made in the titlebar.
+    let local_origin = state.local_origin.clone();
+    let seated_hue = state.hue_of(&local_origin);
+    if state.seat(&local_origin, &speaker, seated_hue) {
         let _ = app.emit("room-participants", state.participants());
     }
 
     let message_id = Uuid::new_v4().to_string();
-    let local_origin = state.local_origin.clone();
     deliver(
         &app,
         &state,
diff --git a/src-tauri/src/session.rs b/src-tauri/src/session.rs
index f608edb..09246b0 100644
--- a/src-tauri/src/session.rs
+++ b/src-tauri/src/session.rs
@@ -11,7 +11,10 @@
 use crate::config::TabConfig;
 use crate::pty::{self, PtyState};
 use crate::room::RoomState;
-use mcp_config::{channel_launch_args, register_sidecar, reject_incompatible_flags, RoomRegistration};
+use mcp_config::{
+    channel_launch_args, register_sidecar, reject_incompatible_flags, server_name_for,
+    RoomRegistration,
+};
 use std::path::PathBuf;
 use tauri::AppHandle;
 
@@ -83,9 +86,14 @@ pub fn parse_launch_options(text: String) -> Vec<String> {
 ///
 /// The app merges its own channel entry into what the person wrote, so the
 /// line they typed is not the line that runs. This returns the line that runs.
+///
+/// The entry names this session's own server, which is a function of the name
+/// being launched under, so the preview moves as the name field is typed in.
+/// That is the point rather than a side effect: the identity a session is about
+/// to take is the thing this launch is now choosing.
 #[tauri::command]
-pub fn preview_launch_args(args: Vec<String>) -> Vec<String> {
-    channel_launch_args(&args)
+pub fn preview_launch_args(args: Vec<String>, name: String) -> Vec<String> {
+    channel_launch_args(&args, &server_name_for(name.trim()))
 }
 
 /// What the caller gets back after a session joins.
@@ -104,15 +112,34 @@ pub struct StartedSession {
     pub started_at: String,
 }
 
+/// Launch one session under a declared identity.
+///
+/// `name` and `hue` are the session's own, not the tab's. A tab is which CLI to
+/// run; who joins the room is chosen at the moment of joining, the same way the
+/// screen's person chooses theirs. Under the tab-attribute form every launch
+/// answered to the one name in the default config, so two sessions were both
+/// `Claude Code` and neither could be addressed (#40).
 #[tauri::command]
+#[allow(clippy::too_many_arguments)]
 pub fn start_session(
     app: AppHandle,
     room: tauri::State<RoomState>,
     pty_state: tauri::State<PtyState>,
     tab: TabConfig,
+    name: String,
+    hue: Option<f64>,
     cols: u16,
     rows: u16,
 ) -> Result<StartedSession, String> {
+    let name = name.trim().to_string();
+    if name.is_empty() {
+        return Err(
+            "This session has no name. Give it one before starting: it is what the room \
+             lists it under and what a post is addressed to."
+                .to_string(),
+        );
+    }
+
     if let Err(flag) = reject_incompatible_flags(&tab.args) {
         return Err(format!(
             "Tab \"{}\" passes {flag}, which stops channel pushes from arriving. \
@@ -143,12 +170,16 @@ pub fn start_session(
     }
 
     let (sidecar_entry, sidecar_runner) = resolve_sidecar_paths()?;
+    // Keyed on the name, so two sessions launched into one working directory
+    // write two entries instead of overwriting each other's identity (#40).
+    let server_name = server_name_for(&name);
     let mcp_config = register_sidecar(
         &cwd,
         &RoomRegistration {
             room_url: &room_url,
             token: &room.token(),
-            agent_name: &tab.name,
+            agent_name: &name,
+            agent_hue: hue,
             sidecar_entry: &sidecar_entry,
             sidecar_runner: &sidecar_runner,
         },
@@ -159,7 +190,7 @@ pub fn start_session(
         app,
         pty_state,
         tab.command.clone(),
-        channel_launch_args(&tab.args),
+        channel_launch_args(&tab.args, &server_name),
         cols,
         rows,
         Some(cwd.to_string_lossy().to_string()),
diff --git a/src/main.ts b/src/main.ts
index efff01d..62c0d53 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -20,6 +20,10 @@ import "@xterm/xterm/css/xterm.css";
 interface RoomMessage {
   message_id: string;
   speaker: string;
+  /** The hue the speaker declared, or null when they declared none. Stamped by
+   *  the room from the connection the post arrived on, so it is that speaker's
+   *  and not whoever else currently answers to the same name. */
+  hue: number | null;
   content: string;
   to: string | null;
   ts: string;
@@ -28,8 +32,24 @@ interface RoomMessage {
   own: boolean;
 }
 
+/**
+ * One participant of the room, as the roster lists them.
+ *
+ * `id` is the connection they are in the room on, and it is the identity. The
+ * name is what they are called and what a post is addressed to; two
+ * participants may answer to one name and are still two.
+ */
+interface Participant {
+  id: string;
+  name: string;
+  hue: number | null;
+  own: boolean;
+}
+
 interface TabConfig {
   id: string;
+  /** The tab's label — which CLI it launches. Not the name a session takes in
+   *  the room: that is chosen per launch, in the launcher. */
   name: string;
   command: string;
   args: string[];
@@ -49,6 +69,32 @@ interface StartedSession {
 }
 
 const NAME_KEY = "liplus-chat.display-name";
+const HUE_KEY = "liplus-chat.display-hue";
+const SESSION_NAME_KEY = "liplus-chat.session-name";
+const SESSION_HUE_KEY = "liplus-chat.session-hue";
+
+/**
+ * The hues a participant can declare.
+ *
+ * Hue only. Lightness and chroma stay the accent's in whichever theme is
+ * showing, so a declared colour sits at the same weight on the page as every
+ * other participant's and stays readable in both themes (#43). Offering a full
+ * colour picker would ask for two values and silently discard them.
+ *
+ * A short list rather than a continuous dial: what this has to buy is that any
+ * two participants can be told apart, and eight positions spread round the
+ * wheel buy it without asking anyone to judge degrees.
+ */
+const HUES: { label: string; hue: number }[] = [
+  { label: "赤", hue: 25 },
+  { label: "橙", hue: 55 },
+  { label: "黄", hue: 95 },
+  { label: "緑", hue: 145 },
+  { label: "青緑", hue: 195 },
+  { label: "青", hue: 250 },
+  { label: "紫", hue: 300 },
+  { label: "桃", hue: 350 },
+];
 
 /**
  * Hue of `--accent`, and the arc the other participants are drawn from.
@@ -64,7 +110,10 @@ const DERIVED_ARC = 360 - RESERVED_ARC * 2;
 const roomEl = document.getElementById("room") as HTMLElement;
 const rosterEl = document.getElementById("roster") as HTMLElement;
 const nameEl = document.getElementById("display-name") as HTMLInputElement;
+const hueEl = document.getElementById("display-hue") as HTMLSelectElement;
 const tabEl = document.getElementById("tab-select") as HTMLSelectElement;
+const sessionNameEl = document.getElementById("session-name") as HTMLInputElement;
+const sessionHueEl = document.getElementById("session-hue") as HTMLSelectElement;
 const startEl = document.getElementById("start-session") as HTMLButtonElement;
 const inputEl = document.getElementById("input") as HTMLTextAreaElement;
 const sendEl = document.getElementById("send") as HTMLButtonElement;
@@ -86,7 +135,7 @@ const previewEl = document.getElementById("launch-preview") as HTMLElement;
 
 let tabs: TabConfig[] = [];
 /** Everyone in the room, this screen's person included. */
-let participants: string[] = [];
+let participants: Participant[] = [];
 /** The session the terminal is attached to, once one is running. */
 let activePtyId: string | null = null;
 
@@ -164,13 +213,46 @@ async function refreshPreview(): Promise<void> {
   }
   try {
     const parsed = await invoke<string[]>("parse_launch_options", { text: optionsEl.value });
-    const merged = await invoke<string[]>("preview_launch_args", { args: parsed });
+    // The channel entry names this session's own server, which follows the
+    // name being launched under, so the preview moves as that field is typed.
+    const merged = await invoke<string[]>("preview_launch_args", {
+      args: parsed,
+      name: sessionName(),
+    });
     previewEl.textContent = `${tab.command} ${joinArgs(merged)}`;
   } catch {
     previewEl.textContent = "";
   }
 }
 
+/**
+ * Fill a hue picker, with "not declared" first.
+ *
+ * Both pickers are filled from the one list, because a person and a session
+ * declare a colour from the same set. Not declaring is an option rather than an
+ * omission: a participant who chose no colour still joins, and the room derives
+ * one for them from their name.
+ */
+function fillHues(select: HTMLSelectElement, saved: string | null): void {
+  const none = document.createElement("option");
+  none.value = "";
+  none.textContent = "既定（名前から）";
+  select.appendChild(none);
+
+  for (const { label, hue } of HUES) {
+    const option = document.createElement("option");
+    option.value = String(hue);
+    option.textContent = label;
+    select.appendChild(option);
+  }
+  select.value = saved !== null && HUES.some(({ hue }) => String(hue) === saved) ? saved : "";
+}
+
+/** The hue a picker currently declares, or null for "not declared". */
+function declaredHue(select: HTMLSelectElement): number | null {
+  return select.value === "" ? null : Number(select.value);
+}
+
 /**
  * The hue a participant's name lands on.
  *
@@ -193,11 +275,26 @@ function hueFor(name: string): number {
  * The colour a participant is drawn in.
  *
  * Lightness and chroma are the accent's, in whichever theme is showing; only
- * the hue turns. Oneself is the accent itself rather than a hue derived from
- * one's own name, which is what keeps one colour in the room recognisably
- * one's own now that colour no longer runs on the self/other axis.
+ * the hue turns. One ladder, in this order:
+ *
+ *   declared > oneself's accent > derived from the name
+ *
+ * A declaration outranks both. Derivation is stable but not choosable, and the
+ * three names actually in use landed inside a 75° band — at the accent's low
+ * chroma that is not a difference anyone can read, so colour stopped doing the
+ * one job it was added for (#40).
+ *
+ * That the accent is below the declaration is the deliberate half. Oneself
+ * keeps it while nothing is declared, so nothing changes for a participant who
+ * declares nothing; declaring a colour takes it, because a declared colour that
+ * showed to everyone except the person who declared it is not the colour they
+ * declared. What then says which participant is oneself is the roster's
+ * 「（あなた）」 and the name on the line — colour was the faster of the three
+ * carriers, never the only one, and it is the one that is now chosen rather
+ * than assigned.
  */
-function speakerColor(name: string, own: boolean): string {
+function speakerColor(name: string, hue: number | null, own: boolean): string {
+  if (hue !== null) return `oklch(var(--speaker-l) var(--speaker-c) ${hue.toFixed(1)})`;
   if (own) return "var(--accent)";
   return `oklch(var(--speaker-l) var(--speaker-c) ${hueFor(name).toFixed(1)})`;
 }
@@ -217,7 +314,10 @@ function appendMessage(message: RoomMessage): void {
   line.className = "message";
   // `own` rather than a name test: the room decides self on the connection a
   // post arrived on, which a rename cannot blur (#40).
-  line.style.setProperty("--speaker", speakerColor(message.speaker, message.own));
+  line.style.setProperty(
+    "--speaker",
+    speakerColor(message.speaker, message.hue, message.own),
+  );
 
   const head = document.createElement("div");
   head.className = "meta";
@@ -259,9 +359,8 @@ function appendMessage(message: RoomMessage): void {
  * in the room, which is what makes the panel a legend for the conversation
  * rather than a second copy of the same names.
  */
-function renderRoster(joined: string[]): void {
+function renderRoster(joined: Participant[]): void {
   participants = joined;
-  const mine = localName();
   rosterEl.replaceChildren();
 
   if (!joined.length) {
@@ -271,21 +370,25 @@ function renderRoster(joined: string[]): void {
     rosterEl.appendChild(empty);
   }
 
-  for (const name of joined) {
-    const own = name === mine;
+  for (const participant of joined) {
+    // `own` comes from the room, decided on the connection. A name test here
+    // would mark every participant answering to this screen's name as oneself.
     const entry = document.createElement("li");
-    entry.style.setProperty("--speaker", speakerColor(name, own));
+    entry.style.setProperty(
+      "--speaker",
+      speakerColor(participant.name, participant.hue, participant.own),
+    );
 
     const dot = document.createElement("span");
     dot.className = "dot";
 
     const who = document.createElement("span");
     who.className = "who";
-    who.textContent = name;
-    who.title = name;
+    who.textContent = participant.name;
+    who.title = participant.name;
 
     entry.append(dot, who);
-    if (own) {
+    if (participant.own) {
       const you = document.createElement("span");
       you.className = "self";
       you.textContent = "（あなた）";
@@ -302,16 +405,25 @@ function localName(): string {
   return nameEl.value.trim() || "human";
 }
 
+/** The name the next session will join under. */
+function sessionName(): string {
+  return sessionNameEl.value.trim();
+}
+
 /**
- * Take a seat in the room under the current name.
+ * Take a seat in the room under the current name and colour.
  *
  * Being in the room is not the same as having spoken in it: without this the
  * roster would list only the sessions, and nobody could address someone who
  * had not spoken yet.
+ *
+ * The colour goes with the name because they are one declaration, and because
+ * a seat carries both — sending the name alone on a rename would withdraw a
+ * colour nobody withdrew.
  */
 async function join(): Promise<void> {
   try {
-    await invoke("room_join", { name: localName() });
+    await invoke("room_join", { name: localName(), hue: declaredHue(hueEl) });
   } catch {
     // Failing to seat is not worth interrupting anything: the first post
     // seats the name anyway.
@@ -332,8 +444,12 @@ async function join(): Promise<void> {
  */
 function renderAddressees(): void {
   const chosen = toEl.value;
-  const mine = localName();
-  const addressable = participants.filter((name) => name !== mine);
+  // Names, deduplicated: `to` carries a display name, so two participants
+  // answering to one name are one option — listing it twice would offer a
+  // choice between two identical things that address the same pair anyway.
+  const addressable = [
+    ...new Set(participants.filter((one) => !one.own).map((one) => one.name)),
+  ];
   toEl.replaceChildren();
 
   const everyone = document.createElement("option");
@@ -377,8 +493,12 @@ async function send(): Promise<void> {
  * the room simply stays empty. Without this the screen is identical whether
  * the CLI is running or was never there.
  */
-async function followSession(tab: TabConfig, started: StartedSession): Promise<void> {
-  sessionStateEl.textContent = `${tab.name} 起動中`;
+async function followSession(
+  tab: TabConfig,
+  name: string,
+  started: StartedSession,
+): Promise<void> {
+  sessionStateEl.textContent = `${name} 起動中`;
   sessionStateEl.dataset.kind = "ok";
   activePtyId = started.pty_id;
 
@@ -397,9 +517,9 @@ async function followSession(tab: TabConfig, started: StartedSession): Promise<v
   await listen<number | null>(`pty-exit-${started.pty_id}`, (event) => {
     const code = event.payload;
     const detail = code === null ? "終了コード不明" : `終了コード ${code}`;
-    sessionStateEl.textContent = `${tab.name} 終了（${detail}）`;
+    sessionStateEl.textContent = `${name} 終了（${detail}）`;
     sessionStateEl.dataset.kind = "error";
-    status(`${tab.name} が終了しました（${detail}）。診断を確認してください。`, "error");
+    status(`${name} が終了しました（${detail}）。診断を確認してください。`, "error");
     activePtyId = null;
     revealDiagnostics();
   });
@@ -417,6 +537,18 @@ async function startSession(): Promise<void> {
     return;
   }
 
+  // The identity this session joins under. Refused rather than defaulted: an
+  // unnamed session is the state this whole surface exists to end, and quietly
+  // falling back to the tab's label is how every session came to answer to
+  // `Claude Code` (#40).
+  const name = sessionName();
+  if (!name) {
+    status("セッションの名前を入力してください。部屋での名乗りになります。", "error");
+    sessionNameEl.focus();
+    return;
+  }
+  const hue = declaredHue(sessionHueEl);
+
   const cwd = cwdEl.value.trim();
   if (!cwd) {
     status("作業ディレクトリを入力してください。", "error");
@@ -435,10 +567,12 @@ async function startSession(): Promise<void> {
   fitAddon.fit();
 
   startEl.disabled = true;
-  status(`${tab.name} を起動しています…`);
+  status(`${name} を起動しています…`);
   try {
     const started = await invoke<StartedSession>("start_session", {
       tab: launching,
+      name,
+      hue,
       cols: terminal.cols,
       rows: terminal.rows,
     });
@@ -449,11 +583,16 @@ async function startSession(): Promise<void> {
       // launch: the session is already up.
       status("作業ディレクトリを保存できませんでした。", "error");
     });
-    status(`${tab.name} を起動しました。${started.mcp_config} に登録済み。`);
-    await followSession(tab, started);
+    // Remembered next to this screen's own name and colour, and in the same
+    // place — the identity a launch declares is not a property of the tab, and
+    // storing it there is what fixed every launch to one name.
+    localStorage.setItem(SESSION_NAME_KEY, name);
+    localStorage.setItem(SESSION_HUE_KEY, sessionHueEl.value);
+    status(`${name} を起動しました。${started.mcp_config} に登録済み。`);
+    await followSession(tab, name, started);
   } catch (err) {
-    status(`${tab.name} を起動できませんでした: ${err}`, "error");
-    sessionStateEl.textContent = `${tab.name} 起動失敗`;
+    status(`${name} を起動できませんでした: ${err}`, "error");
+    sessionStateEl.textContent = `${name} 起動失敗`;
     sessionStateEl.dataset.kind = "error";
     revealDiagnostics();
   } finally {
@@ -519,12 +658,20 @@ async function main(): Promise<void> {
   setUpTerminal();
 
   nameEl.value = localStorage.getItem(NAME_KEY) ?? "human";
-  nameEl.addEventListener("change", () => {
+  fillHues(hueEl, localStorage.getItem(HUE_KEY));
+  fillHues(sessionHueEl, localStorage.getItem(SESSION_HUE_KEY));
+
+  // One handler for both halves of the declaration: a rename and a recolour are
+  // the same act on the same seat, and the room takes them together.
+  const redeclare = (): void => {
     localStorage.setItem(NAME_KEY, localName());
+    localStorage.setItem(HUE_KEY, hueEl.value);
     // The roster entry follows the name, and the addressee list follows the
     // roster: a rename must not leave the old name sitting in either.
     void join().then(() => renderAddressees());
-  });
+  };
+  nameEl.addEventListener("change", redeclare);
+  hueEl.addEventListener("change", redeclare);
 
   toggleEl.addEventListener("click", () => {
     if (diagnosticsEl.hidden) {
@@ -536,7 +683,7 @@ async function main(): Promise<void> {
   });
 
   await listen<RoomMessage>("room-message", (event) => appendMessage(event.payload));
-  await listen<string[]>("room-participants", (event) => renderRoster(event.payload));
+  await listen<Participant[]>("room-participants", (event) => renderRoster(event.payload));
   // The socket binds after the frontend loads, so the event is the authority
   // and the poll below is only for a listener that attached too late.
   await listen<number>("room-ready", (event) => renderSocket(event.payload));
@@ -564,6 +711,9 @@ async function main(): Promise<void> {
     void refreshPreview();
   };
   optionsEl.addEventListener("input", () => void refreshPreview());
+  // The launched line carries this session's own channel entry, which follows
+  // the name, so the preview has to follow it too.
+  sessionNameEl.addEventListener("input", () => void refreshPreview());
 
   try {
     const config = await invoke<AppConfig>("load_config");
@@ -574,6 +724,11 @@ async function main(): Promise<void> {
       option.textContent = tab.name;
       tabEl.appendChild(option);
     }
+    // A prefill, not a default. The tab's label is a legible starting point for
+    // the first launch; what makes it safe is that it is sitting in an editable
+    // field on screen, which is exactly what it was not before (#40).
+    sessionNameEl.value =
+      localStorage.getItem(SESSION_NAME_KEY) ?? tabs[0]?.name ?? "";
     showTab();
     tabEl.addEventListener("change", showTab);
   } catch (err) {
@@ -582,7 +737,7 @@ async function main(): Promise<void> {
 
   try {
     await join();
-    renderRoster(await invoke<string[]>("room_participants"));
+    renderRoster(await invoke<Participant[]>("room_participants"));
     const port = await invoke<number | null>("room_port");
     if (port !== null) renderSocket(port);
   } catch (err) {
diff --git a/src/styles.css b/src/styles.css
index be204af..a4b5638 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -10,7 +10,10 @@
   /* One participant is told from another by hue alone: every participant
      colour is the accent's own lightness and chroma with the hue turned. The
      pair below is #3a6ea5 measured in oklch, not a value chosen next to it, so
-     a participant sits at the same weight on the page as the accent does. */
+     a participant sits at the same weight on the page as the accent does.
+     This pair is what a participant may not choose — declaring a colour
+     declares a hue, and these two hold whatever hue lands on them readable in
+     this theme. */
   --speaker-l: 0.528;
   --speaker-c: 0.104;
 }
@@ -137,13 +140,16 @@ body {
 
 /* Speaker attribution is the load-bearing distinction in this room, so one
    participant is separated from another by colour as well as by name. The axis
-   is the participant: `--speaker` is set per line from the name on it, so the
-   colour beside a line and the dot beside that name in the panel are the same
+   is the participant: `--speaker` is set per line from that participant, so the
+   colour beside a line and the dot beside their name in the panel are the same
    colour, and a line can be traced to a participant without reading it.
    Self/other was the earlier axis (#39) and is a two-valued one — it gave every
-   participant but oneself one shared colour. Oneself keeps the accent, and the
-   derived hues leave a gap around it, so that one colour still reads as one's
-   own. */
+   participant but oneself one shared colour.
+   Where the hue comes from is a ladder, resolved in src/main.ts: a hue the
+   participant declared, else the accent for oneself, else one derived from the
+   name. The derived hues leave a gap around the accent so that colour still
+   reads as one's own; a declared one is free of that gap, because it was
+   chosen. */
 .message {
   max-width: 46rem;
   border-left: 3px solid var(--speaker, var(--line));
@@ -388,6 +394,20 @@ body {
   font-size: 0.8rem;
 }
 
+/* The name and colour this session joins under. The same pair the titlebar
+   carries for this screen's person, in the row where a launch is set up: both
+   are declared at the moment of joining, so both are set where joining is. */
+#launcher .who {
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+  color: var(--muted);
+}
+
+#launcher .who input {
+  width: 7rem;
+}
+
 #launcher .cwd {
   display: flex;
   align-items: center;