diff --git a/README.md b/README.md
index fa04ef1..9b57ec9 100644
--- a/README.md
+++ b/README.md
@@ -25,7 +25,7 @@ liplus-chat は、人間と複数の独立した AI / Li+ セッションが、
 
 - Tauri 2 による Windows デスクトップアプリの基盤
 - プロセスの起動、入力、リサイズ、終了を扱う Rust の PTY コマンド
-- タブ設定とセッションデータを JSON へ保存・読込する Tauri コマンド
+- アカウント設定とセッションデータを JSON へ保存・読込する Tauri コマンド
 - MCP channel サーバ（Node サイドカー、`sidecar/`）
 - 部屋ソケット（`127.0.0.1` の任意ポート、Bearer トークン必須）
 - `.mcp.json` への登録と、channel が成立する条件を満たした CLI 起動
@@ -54,22 +54,26 @@ 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-<名前>-<hash>`）をここへ統合するので、別の channel サーバを指定しても部屋の入力路は残ります。実際に起動する行は入力欄の右に表示されます。
+上の行が**アカウント**です。「＋」で作り、「−」で削除します。アカウントは起動していなくても存在するもので、名前・色・作業ディレクトリ・起動オプションを持ちます。編集はその場で保存されます。
 
-タブの隣に「名前」と「色」があります。これはそのセッションが部屋で名乗る名前と、発言に付く色です。**起動のたびに選びます。** タブに固定された属性ではないので、同じタブから 2 つのセッションを、別々の名前と色で立てられます。色を選ばずに参加することもでき、その場合は名前から色が決まります。タイトルバーの「名前」「色」は同じものの人間側です。
+「名前」と「色」は、そのアカウントが部屋で名乗る名前と、発言に付く色です。**いつでも変えられます。** 同一性は名前ではなく内部の id にあるため、改名しても稼働中のセッションの登録は追随します。色を選ばずに参加することもでき、その場合は名前から色が決まります。タイトルバーの「名前」「色」は同じものの人間側です（人間はアカウントではなく、この画面の話者として参加します）。
 
-作業ディレクトリの入力欄があります。初回はホームディレクトリが入っているので、セッションを動かしたいディレクトリへ変更してください。この値はタブ設定として保存されます。
+「起動オプション」には `--dangerously-skip-permissions` のように、CLI へ渡したいオプションをそのまま書けます。アプリは部屋の channel エントリ（`server:liplus-chat-room-<slug>-<hash>`）をここへ統合するので、別の channel サーバを指定しても部屋の入力路は残ります。実際に起動する行は入力欄の右に表示されます。
 
-右の参加者パネルに、部屋にいる参加者と、セッションの裏の値（部屋ソケット、セッションの生死、接続方法、起動コマンド、作業ディレクトリ、開始時刻、ウィンドウ）が出ます。発言の色は参加者ごとに違い、名簿の点と同じ色です。色は選んだものが優先され、選んでいなければ自分は accent（青）、他の参加者は名前から決まります。名簿では自分の行に「（あなた）」が付きます。
+作業ディレクトリの入力欄があります。初回はホームディレクトリが入っているので、セッションを動かしたいディレクトリへ変更してください。
+
+右の参加者パネルに、部屋にいる参加者と、まだ起動していないアカウント（「未起動」）が並びます。その下にセッションの裏の値（部屋ソケット、セッションの生死、接続方法、起動コマンド、作業ディレクトリ、開始時刻、ウィンドウ）が出ます。発言の色は参加者ごとに違い、名簿の点と同じ色です。色は選んだものが優先され、選んでいなければ自分は accent（青）、他の参加者は名前から決まります。名簿では自分の行に「（あなた）」が付きます。宛先に選べるのは部屋に居る参加者だけで、未起動のアカウントは出ません。
 
 「診断」を開くと**起動した CLI の端末**が出ます。端末はそのまま操作できます。CLI はフォルダごとに初回の信頼確認を出すため、最初の一回はここから答えてください。
 
 この端末は表示と操作のためのものです。ここに映る内容が部屋の発言になることはありません。部屋に並ぶのは channel 経由の発言だけです。
 
-タイトルバーでセッションを選び「セッション参加」を押すと、次の 2 つが行われます。
+アカウントを選び「セッション参加」を押すと、次の 2 つが行われます。
+
+1. そのアカウントの作業ディレクトリの `.mcp.json` へ、部屋のサイドカーを `liplus-chat-room-<slug>-<hash>` という名前で登録します。**既存の内容はマージして保持します**が、あなたのリポジトリのファイルを書き換える操作です。登録鍵はアカウント id から決まります。アカウントごとに分けているのは同じ作業ディレクトリへ 2 つのセッションを立てたときに互いの登録を潰さないためで、名前ではなく id から導くのは改名で鍵が動かないようにするためです。前回の起動で書かれたエントリ（もう繋がらないポートを指しているもの）は、このとき掃除します。
+2. `--dangerously-load-development-channels server:liplus-chat-room-<slug>-<hash>` を付けて 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 bbf5be6..e67f921 100644
--- a/crates/mcp-config/src/lib.rs
+++ b/crates/mcp-config/src/lib.rs
@@ -19,24 +19,34 @@ use std::path::{Path, PathBuf};
 
 /// 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
+/// The full name is per account (`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.
+/// The `.mcp.json` key, and the `server:<name>` tag, for one account.
 ///
-/// 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);
+/// A function of the account id alone. The id is what an account is; the name
+/// is an attribute of it, and a key derived from the name moved every time the
+/// name was edited — the registration a running session was launched against
+/// would be orphaned under the old key while the CLI holding that session still
+/// names the old tag on its command line (#53). Deriving from the id makes a
+/// rename cost nothing, which is what makes the name editable at all.
+///
+/// Per account rather than per launch: relaunching one account reuses its
+/// entry, rather than growing the user's file by one key per launch.
+///
+/// The slug half is legibility and the hash half is what makes the key total,
+/// as it was under the name. An id is opaque, so the slug reads less well than
+/// a name did; which account an entry belongs to is read from
+/// `LIPLUS_AGENT_NAME` in its own env instead. Legibility loses to identity
+/// here — a key that reads oddly costs one lookup, and a key that moves is a
+/// registration nobody can find.
+pub fn server_name_for(account_id: &str) -> String {
+    let slug = slugify(account_id);
+    let hash = fnv1a(account_id);
     if slug.is_empty() {
         format!("{SERVER_PREFIX}-{hash:08x}")
     } else {
@@ -49,9 +59,9 @@ pub fn server_name_for(agent_name: &str) -> String {
 /// 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 {
+fn slugify(text: &str) -> String {
     let mut out = String::new();
-    for ch in name.chars() {
+    for ch in text.chars() {
         if ch.is_ascii_alphanumeric() {
             out.push(ch.to_ascii_lowercase());
         } else if !out.ends_with('-') && !out.is_empty() {
@@ -86,7 +96,12 @@ pub struct RoomRegistration<'a> {
     pub room_url: &'a str,
     /// Bearer token the sidecar must present.
     pub token: &'a str,
-    /// Display name this session speaks under.
+    /// Id of the account being launched. The registration key derives from
+    /// this, so the entry stays put across a rename of the account.
+    pub account_id: &'a str,
+    /// Display name this session speaks under. Written into the env for the
+    /// sidecar to declare in `hello`, and it is what says whose entry this is
+    /// when the file is read by eye. Not the key: see `server_name_for`.
     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
@@ -118,7 +133,7 @@ pub fn reject_incompatible_flags(args: &[String]) -> Result<(), &'static str> {
 /// The flag that loads channel servers into a session.
 pub const CHANNEL_FLAG: &str = "--dangerously-load-development-channels";
 
-/// The launch arguments for a channel-enabled session, given the tab's own.
+/// The launch arguments for a channel-enabled session, given the account's own.
 ///
 /// The room's entry is merged into whatever the person wrote rather than added
 /// as a second flag: `--channels` alongside this one registers a server twice
@@ -126,9 +141,8 @@ pub const CHANNEL_FLAG: &str = "--dangerously-load-development-channels";
 /// shape. Merging also means the room's input path cannot be dropped by
 /// configuring a different server — losing it is losing the room.
 ///
-/// `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.
+/// `server_name` is this account's own (`server_name_for`), so the flag and the
+/// `.mcp.json` key stay one fact even though that fact differs per account.
 pub fn channel_launch_args(base: &[String], server_name: &str) -> Vec<String> {
     let room = format!("server:{server_name}");
     let mut args = base.to_vec();
@@ -211,7 +225,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 server_name = server_name_for(room.account_id);
 
     let path = dir.join(".mcp.json");
     let mut root: Value = if path.exists() {
@@ -244,10 +258,10 @@ pub fn register_sidecar(dir: &Path, room: &RoomRegistration<'_>) -> Result<PathB
     // 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.
+    // retries nothing forever, and the file would grow by one key per account
+    // ever launched 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;
@@ -311,11 +325,16 @@ mod tests {
 
     const ENTRY: &str = "C:/liplus-chat/sidecar/src/index.ts";
     const RUNNER: &str = "C:/liplus-chat/node_modules/tsx/dist/cli.mjs";
+    /// The account `Lin` is launched from. Opaque here as it is in the app: a
+    /// test that read a name out of it would be testing the wrong key.
+    const LIN: &str = "8f14e45f-ceea-467a-b160-6f14e45fceea";
+    const LAY: &str = "2b1c9a70-3d4e-4f80-91a2-b3c4d5e6f708";
 
     fn registration<'a>(entry: &'a Path, runner: &'a Path) -> RoomRegistration<'a> {
         RoomRegistration {
             room_url: "ws://127.0.0.1:1234",
             token: "tok",
+            account_id: LIN,
             agent_name: "Lin",
             agent_hue: None,
             sidecar_entry: entry,
@@ -336,7 +355,7 @@ mod tests {
             register_sidecar(scratch.path(), &registration(&entry, &runner)).expect("register");
 
         let json = read(&path);
-        let server = &json["mcpServers"][server_name_for("Lin")];
+        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");
@@ -383,11 +402,11 @@ mod tests {
         let json = read(&path);
         assert_eq!(json["mcpServers"]["theirs"]["command"], "their-server");
         assert_eq!(json["unrelated"], 42);
-        assert!(json["mcpServers"][server_name_for("Lin")].is_object());
+        assert!(json["mcpServers"][server_name_for(LIN)].is_object());
     }
 
     #[test]
-    fn re_registering_the_same_name_replaces_its_own_entry() {
+    fn re_registering_the_same_account_replaces_its_own_entry() {
         let scratch = Scratch::new();
         let entry = PathBuf::from(ENTRY);
         let runner = PathBuf::from(RUNNER);
@@ -396,6 +415,7 @@ mod tests {
         let second = RoomRegistration {
             room_url: "ws://127.0.0.1:1234",
             token: "tok2",
+            account_id: LIN,
             agent_name: "Lin",
             agent_hue: Some(145.0),
             sidecar_entry: &entry,
@@ -404,18 +424,51 @@ mod tests {
         let path = register_sidecar(scratch.path(), &second).expect("second");
 
         let json = read(&path);
-        let server = &json["mcpServers"][server_name_for("Lin")];
+        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,
-            "relaunching under one name must not accumulate entries"
+            "relaunching one account must not accumulate entries"
+        );
+    }
+
+    #[test]
+    fn renaming_an_account_leaves_its_registration_where_it_was() {
+        // The reason the key moved off the name (#53). An account's name is
+        // editable, and a key derived from it moved on every edit: the entry
+        // the running session was launched against would be orphaned under the
+        // old key, while the CLI holding that session still names the old
+        // `server:` tag on a command line nothing can go back and change.
+        let scratch = Scratch::new();
+        let entry = PathBuf::from(ENTRY);
+        let runner = PathBuf::from(RUNNER);
+
+        register_sidecar(scratch.path(), &registration(&entry, &runner)).expect("as Lin");
+        let renamed = RoomRegistration {
+            room_url: "ws://127.0.0.1:1234",
+            token: "tok",
+            account_id: LIN,
+            agent_name: "リン",
+            agent_hue: None,
+            sidecar_entry: &entry,
+            sidecar_runner: &runner,
+        };
+        let path = register_sidecar(scratch.path(), &renamed).expect("as リン");
+
+        let json = read(&path);
+        let servers = json["mcpServers"].as_object().expect("servers");
+        assert_eq!(servers.len(), 1, "a rename must not open a second entry");
+        assert_eq!(
+            json["mcpServers"][server_name_for(LIN)]["env"]["LIPLUS_AGENT_NAME"],
+            "リン",
+            "the new name belongs in the entry the id already had"
         );
     }
 
     #[test]
-    fn two_participants_in_one_directory_keep_separate_entries() {
+    fn two_accounts_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,
@@ -428,6 +481,7 @@ mod tests {
         let lay = RoomRegistration {
             room_url: "ws://127.0.0.1:1234",
             token: "tok",
+            account_id: LAY,
             agent_name: "Lay",
             agent_hue: Some(25.0),
             sidecar_entry: &entry,
@@ -437,12 +491,12 @@ mod tests {
 
         let json = read(&path);
         assert_eq!(
-            json["mcpServers"][server_name_for("Lin")]["env"]["LIPLUS_AGENT_NAME"],
+            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"],
+            json["mcpServers"][server_name_for(LAY)]["env"]["LIPLUS_AGENT_NAME"],
             "Lay"
         );
         assert_eq!(json["mcpServers"].as_object().expect("servers").len(), 2);
@@ -486,20 +540,20 @@ mod tests {
             "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")));
+        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-"));
+    fn a_server_name_is_a_function_of_the_account_id() {
+        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(SERVER_PREFIX));
+        // Total over whatever an id turns out to be, as it was over a name: an
+        // input that slugs to nothing still gets a key of its own, and two that
+        // slug alike still get two. The uniqueness lives in the hash, and the
+        // ids the app mints do not lean on the slug for it.
         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")
@@ -558,7 +612,7 @@ mod tests {
         .map(|s| s.to_string())
         .collect();
 
-        let room = server_name_for("Lin");
+        let room = server_name_for(LIN);
         let merged = channel_launch_args(&base, &room);
         assert_eq!(
             merged,
@@ -578,7 +632,7 @@ mod tests {
 
     #[test]
     fn does_not_add_the_room_twice() {
-        let room = server_name_for("Lin");
+        let room = server_name_for(LIN);
         let base = vec![CHANNEL_FLAG.to_string(), format!("server:{room}")];
         assert_eq!(channel_launch_args(&base, &room), base);
     }
@@ -624,7 +678,7 @@ mod tests {
             .expect("one entry")
             .clone();
 
-        let args = channel_launch_args(&["--verbose".to_string()], &server_name_for("Lin"));
+        let args = channel_launch_args(&["--verbose".to_string()], &server_name_for(LIN));
         assert_eq!(
             args,
             vec![
diff --git a/docs/0-requirements.md b/docs/0-requirements.md
index 2ebb90e..49b92f8 100644
--- a/docs/0-requirements.md
+++ b/docs/0-requirements.md
@@ -14,7 +14,7 @@
 - **発言はひとつの行為である。** 誰が出しても同じフレームで、同じ経路を通り、全員へ配られる。発言者ごとに別の行為を用意しない。
 - **自分の発言は自分へ戻らない。** 抑止は接続の同一性で判定する。名前で判定すると、名前が衝突している間は他人の発言まで落ちる。
 - **参加者の同一性は接続にある。** 名簿は接続ごとに 1 席を持つ。名前は表示と宛先のための属性であって識別子ではなく、同名の 2 参加者はやはり 2 参加者である。
-- **名乗りは参加の時点で行う。** 名前も色も、参加者が場に加わるその瞬間に宣言する。人間もセッションも同じ形であり、設定ファイルに固定された属性ではない。
+- **名乗りは参加の時点で行う。** 人間は名前と色を、場に加わるその瞬間に宣言する。セッションの側はアカウントが持つ名前と色で加わる（下記「アカウント」）。どちらも「この部屋での自分は誰か」の宣言であり、出所が違うだけである。
 - **宛先は誰でも名指せる。** 人間も宛先の選択肢に並ぶ。宛先は配送を絞らない（constraints の「単一ベンダー構成」参照）。
 
 この前提は後付けではない。当初のプロトコルは人間の発言を `say`、AI の発言を `reply` として別の行為に分けており、`reply` にはそもそも他の参加者へ配る線が引かれていなかった。並列に立てた 2 セッションが互いの発言を受け取らないという実測（2026-08-22）はその帰結であり、配送行の書き忘れではなく語の形の問題だった。統一フレーム `post` はこの是正である（#39）。
@@ -76,10 +76,10 @@
 liplus-chat (Tauri app)  =  部屋の壁
 ├── UI Layer (WebView)
 │   ├── チャットルーム（メッセージ一覧 / 発言者表示 / 入力欄）
-│   └── セッション制御（起動 / 停止 / タブ設定）
+│   └── アカウントとセッション制御（作成 / 編集 / 削除 / 起動）
 ├── App Layer (Rust)
 │   ├── PTY 管理（portable-pty: spawn / write / resize / kill）— 対話セッションの保持
-│   ├── config / sessions 永続化（JSON）
+│   ├── config（アカウント）/ sessions 永続化（JSON）
 │   └── Tauri IPC（invoke / emit）
 ├── MCP Channel Server（Node サイドカー）
 │   ├── initialize: capabilities.experimental["claude/channel"] を宣言
@@ -233,16 +233,17 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 - Tauri 2 による Windows デスクトップアプリの基盤
 - Rust の PTY コマンド（起動 / 入力 / リサイズ / 終了）
-- タブ設定とセッションデータの JSON 永続化
+- アカウント設定とセッションデータの 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`
 - 順番の作法（先に届いた答えを読んでから決める、送信直前の読み直し。`instructions` のみで、protocol もツールも増やしていない）
 - 床（`say_to_room` の `last_seen` と `post_result`、既存ロック内での判定と刻印、見落としがあるときの拒否と返却。ツールは 1 本のまま）
 - 参加者モデル（統一 `post` フレーム、発言者以外の全参加者への配送、接続同一性による自分の発言の抑止と名簿の同一性、人間を含む名簿）
-- 参加の時点の名乗り（起動ごとに選ぶ名前と色。人間側の名前欄と同じ形、`localStorage` に保持）
+- アカウント（作成・編集・削除、名前と色と作業ディレクトリと起動オプション、名簿でのオフライン表示、一つのアカウントは一つの部屋に一席まで、`config.json` からの移行）
+- 参加の時点の名乗り（人間側。タイトルバーの名前と色、`localStorage` に保持）
 - 宣言色（`hello` の `hue` / `room_join` の `hue`。宣言 > 自分の accent > 名前からの導出）
 - チャットルーム UI（メッセージ一覧、発言者表示、入力欄、参加者から選ぶ宛先）
 - 参加者パネル（名簿、参加者ごとの色、部屋ソケット、セッションの生死と終了コード、接続方法・起動コマンド・作業ディレクトリ・開始時刻・ウィンドウ）
@@ -260,6 +261,7 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 - 床を入れた後の同時発話の実機観測。参加者間で発言が届く経路、起動ごとの名乗り、参加者ごとの登録鍵、床の判定はいずれも実装済みである。2026-08-22 の実測（2 セッションが互いの発言を受け取らない / 2 セッションがどちらも `Claude Code` を名乗る）は #39 と #40 の修正前のものであり、2026-08-23 の二重応答（#47 の premise）は床の実装前のものである。いずれも修正後の再計測は済んでいない。
 - 順番の付与（弾くだけでなく「あなたは N 人め」を返す形）。戻り値の形は段差を残していないが、二重計算が痛むと測れてから判断する。
+- アカウント面の実機確認。作成・改名・削除、オフライン表示、二重起動の拒否、改名後の `.mcp.json` 登録の追随はいずれも実装済みで、CI の型検査とテストは通っているが、実機での操作は未確認である。
 - 会話ログの永続化と観測 UI
 - plugin としての allowlist 掲載（配布の第二段階）
 
@@ -269,7 +271,9 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 **読む値と、見る値を分ける。** ここに出るのは、詰まったときに読みに行く値である。折りたたみの下に置くと、開く操作を思いつくかどうかが読めるかどうかになる。CLI の端末だけは別で、あれは読む値ではなく映しているものであるから診断面に残る。
 
-名簿の出所は部屋の名簿（`room-participants`）だけである。画面側に第二の一覧を持たない。持てば、宛先に選べる名前と画面に並ぶ名前が食い違う余地ができる。
+**宛先の選択肢の出所は部屋の名簿（`room-participants`）だけである。** 画面側に第二の一覧を持たない。持てば、宛先に選べる名前と画面に並ぶ名前が食い違う余地ができる。
+
+名簿の列にはこれに加えて、席を持たないアカウントが「未起動」として並ぶ（上記「アカウント」）。第二の一覧ではない——出所は config のアカウント一覧であり、部屋の名簿とはアカウント id で突き合わせる。宛先には出ないため、選べる名前と届く相手が食い違う余地も増えていない。オフラインの行は色を落とし、点を塗りから輪郭へ変える。
 
 **参加者ごとの色。** 発言の縁の色と名簿の点の色は同じであり、参加者ごとに異なる。明度と彩度は `--accent` の実測値に固定し、色相だけを振る。
 
@@ -319,47 +323,67 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 ### 起動オプション
 
-セッションの起動オプションは画面から編集でき、タブ設定として保存する。
+セッションの起動オプションはアカウントの属性であり、画面で編集したその場で保存する。
 
 アプリ自身の channel エントリ（`server:liplus-chat-room-<slug>-<hash>`）は、利用者が書いたものへ**統合**する。利用者が `--dangerously-load-development-channels` を書いていればその直後へ挿入し、書いていなければフラグごと足す。第二のフラグとしては足さない。同一フラグの二重指定は `--channels` 併記と同じ形であり、成立条件が壊れる。
 
 統合であって上書きではない。利用者が別の channel サーバを指定しても、部屋のエントリは落ちない。落ちれば部屋の入力路そのものが消える。
 
-このエントリの名前は参加者ごとに異なる。`.mcp.json` の登録鍵と `server:` タグは同じ 1 つの事実であり、鍵が分かれればタグも分かれる（下記「`.mcp.json` の登録単位」）。
+このエントリの名前はアカウントごとに異なる。`.mcp.json` の登録鍵と `server:` タグは同じ 1 つの事実であり、鍵が分かれればタグも分かれる（下記「`.mcp.json` の登録単位」）。
 
-実際に起動する行は画面に表示する。書いた行と走る行が違う以上、結果を見せるほうが説明より安い。表示は名前の入力に追従する。エントリ名がその名前から決まるためであり、これは副作用ではなく要点である——この起動がいま選んでいるのは、そのセッションが名乗る identity そのものである。
+実際に起動する行は画面に表示する。書いた行と走る行が違う以上、結果を見せるほうが説明より安い。表示は選んでいるアカウントに追従し、そのアカウントの名前を編集しても動かない。エントリ名がアカウント id から決まるためであり、これは要点である——起動しているのはアカウントであって、改名はそれを別のものにしない。
 
 **実測済み（2026-08-21）**: 複数の channel サーバを同時に有効化した状態で往復が成立した。`--print` での確認は無意味である（channel の読み込み自体が走らないため）ことも実測しており、確認は対話セッションでのみ可能。
 
 ### 作業ディレクトリ
 
-セッションの作業ディレクトリは画面に表示し、変更でき、タブ設定として保存する。未設定のままアプリのプロセス cwd へ暗黙にフォールバックしない。
+セッションの作業ディレクトリは画面に表示し、変更でき、アカウントの属性として保存する。未設定のままアプリのプロセス cwd へ暗黙にフォールバックしない。
+
+`npm run tauri dev` ではアプリのプロセス cwd が `src-tauri/` になるため、暗黙のフォールバックはセッションを `src-tauri/` で起動させ、`.mcp.json` もそこへ書く。作業ディレクトリはユーザーの選択であって、アプリのプロセスがたまたま居た場所ではない。作業ディレクトリを持たないアカウントにはホームディレクトリを prefill するが、これは既定値ではなく prefill である。画面に出ていないディレクトリでセッションを起動しない。
+
+### アカウント
+
+アカウントは、起動していなくても存在する同一性である。作る、残る、起動する、止める。名簿は「今つながっている人」ではなく「誰が居るか」を示す面になる。
+
+**同一性は id にある。** アカウントは一意な id を構造的に持ち、それだけが同一性である。名前・色・作業ディレクトリ・起動オプションはすべて属性であり、編集できる。名前が識別子ではなくなったため、改名しても、名前が衝突しても、誰が誰かを見失うものが無い。
+
+**アカウントは #40 の機構を置き換え、目的を保つ。** #40 が直した欠陥は「タブが起動の手段でしかなく、同一性を持てなかった」ことである。同一性が無いところに名前を付ける唯一の形が「起動ごとに宣言する」だった。構造的な同一性ができたので、名前と色はそこへ移る——そして起動時宣言では持ちようがなかったものを得る。**動いていないアカウントにも名前と色がある。** #40 が守ろうとした「名指せること」は、より強い形で満たされている。
 
-`npm run tauri dev` ではアプリのプロセス cwd が `src-tauri/` になるため、暗黙のフォールバックはセッションを `src-tauri/` で起動させ、`.mcp.json` もそこへ書く。作業ディレクトリはユーザーの選択であって、アプリのプロセスがたまたま居た場所ではない。初回はホームディレクトリを prefill するが、これは既定値ではなく prefill である。画面に出ていないディレクトリでセッションを起動しない。
+**人間はアカウントではない。** 画面の話者は従来どおり `localStorage` の名前と色で参加する。アカウントへ統合するかは別の判断であり、統合しないことを選んだのではなく、ここでは決めていない。
 
-### 参加の時点の名乗り
+**名前は人間が読んで選ぶものである。** UUID などの機械的な一意化で置き換えない。宛先の選択肢に出るのはこの名前であり、そこから 1 名を選べることが目的である。id が機械的な一意性を担うのは、名前をその責務から解放するためである。新規アカウントの既定名は既存と重ならない番号を取る——既定値が同じ名前の参加者を並べるのでは、#40 の欠陥を既定で再現することになる。
 
-参加者は名前と色を、参加のその時点で宣言する。
+名前が空のままの起動は拒否する。
 
-人間の側は以前からこの形だった。タイトルバーの名前欄に書いた名前が `localStorage` に残り、`room_join` で着席する。エージェントの側にこの形が無かったことが #40 の中身である。
+**アカウントの一覧と稼働中の名簿は、アカウント id で突き合わせる。** 名前で結ばない。名前は衝突しうるものになり、稼働中に改名されることもある。画面は部屋の名簿をそのまま並べ、席を持たないアカウントを「未起動」として足す。
 
-セッションの名前はタブの属性ではない。タブは「どの CLI を起動するか」を言うものであり、部屋で誰として加わるかは起動のたびに選ぶ。名前をタブに置いていた間は、既定のタブが 1 つ・その名前が `Claude Code` の 1 つだけで、タブを増やす UI も名前を編集する UI も無かった。したがって何回起動しても全員が `Claude Code` を名乗り、作業ディレクトリを分けても変わらなかった。宛先（#31）が名指す先を区別できなかったのはこの帰結である。
+**オフラインのアカウントは名簿に出し、宛先の選択肢には出さない。** 宛先の選択肢の出所は部屋の名簿だけであり（上記「参加者パネル」）、席の無いアカウントはそこに存在しない。届かない相手を名指せる状態は、宛先を名簿から引くという判断（#43）の理由に反する。
 
-名前は人間が読んで選ぶものである。UUID などの機械的な一意化で置き換えない。宛先の選択肢に出るのはこの名前であり、そこから 1 名を選べることが目的である。
+#### 一つのアカウントは一つの部屋に一席まで
 
-名前と色はランチャの入力欄と選択で決め、`localStorage` に残す。人間側と同じ場所・同じ形であり、タブ設定（`config.json`）には入れない。タブに保存すると、それは再び「設定ファイルに固定された名前」になる。ランチャの名前欄にはタブのラベルを prefill するが、これは既定値ではなく prefill である——画面に出ていて編集できることが、以前と違う点そのものである。
+同じアカウントの二重起動は拒否する。アカウントは「誰か」であり、同じ誰かが一つの部屋に二つの接続で居ることを認めない。名簿に同じ同一性が二度並び、その名前への宛先が二つの着地点を持つことになる。
 
-名前が空のままの起動は拒否する。黙ってタブのラベルへ落とすと、この面が塞ごうとしている状態がそのまま戻る。
+**この規則は部屋に対して閉じている。** 現在ルームは 1 つ（サイドカーの `LIPLUS_ROOM_ID` は `liplus-chat` 固定）であるため、実装上は「アカウントが一度だけ動く」と見分けが付かないが、同じ規則ではない。ルームを複数にすることは検討事項として残っており（「決まっていないこと」）、一つのアカウントが二つのルームでそれぞれ席を持つのは意図した形であって違反ではない。機構だけからはこの射程が読めないため、ここに書いておく。
+
+判定は席の台帳（`src-tauri/src/session.rs` の `RoomSeats`）が持つ。掃除と確保は一度のロック取得の中で行う——先に確認して後から確保する形では、二つの起動が同じ空席を通り抜ける。
+
+稼働の有無は PTY へ問う。解放を誰かが呼び忘れると、そのアカウントはアプリを再起動するまで部屋へ入れなくなる——終了したセッションが PTY の一覧から外れることを稼働の定義にすることで、忘れうる解放そのものを無くしている。
+
+#### 既存設定からの移行
+
+`config.json` の `tabs` は `accounts` として読む。id・名前・起動コマンド・起動オプション・作業ディレクトリはそのまま持ち越し、読み手の居なかった `cli_kind` は未知フィールドとして落ちる（#17）。色はまだ宣言されていない状態になる。次回の保存で `accounts` として書き戻す。移行手続きは持たない——別名で読めることが移行のすべてであり、失われて困る値（作業ディレクトリと起動オプション）は形が変わっていない。
 
 ### `.mcp.json` の登録単位
 
-`.mcp.json` の登録鍵は参加者ごとに分ける。名前は `liplus-chat-room-<slug>-<hash>` であり、宣言された名前だけから決まる。
+`.mcp.json` の登録鍵はアカウントごとに分ける。名前は `liplus-chat-room-<slug>-<hash>` であり、**アカウント id だけから決まる**。
+
+鍵が 1 つに固定されていたときは、同じ作業ディレクトリを指す 2 セッションが同じ鍵を上書きした。2 つめの起動が 1 つめの名前・色・部屋アドレスを書き換え、1 つめのセッションがまだ動いている間にその識別が消える（#40）。
 
-鍵が 1 つに固定されていたときは、同じ作業ディレクトリを指す 2 セッションが同じ鍵を上書きした。2 つめの起動が 1 つめの名前・色・部屋アドレスを書き換え、1 つめのセッションがまだ動いている間にその識別が消える（#40）。2026-08-22 の実測では作業ディレクトリが分かれていたためこの経路は発火していないが、名前を起動ごとに選べるようにすると露出する。
+鍵を名前から導出しない理由は改名である。名前が編集できるようになったため、名前由来の鍵は編集のたびに動く。稼働中のセッションが起動時に指した登録は古い鍵の下に取り残され、そのセッションを持つ CLI のコマンドラインには古い `server:` タグが載ったままで、後から書き換える経路が無い。id は不変であるから、改名の費用がゼロになる——名前を編集可能にできるのはこの性質による。
 
-鍵を起動ごとの id にはしない。それでは起動のたびに 1 つ増え、ユーザーのリポジトリのファイルが際限なく伸びる。名前だけの関数にすることで、同じ名前で立て直したときは同じエントリを使い回す。
+鍵を起動ごとの id にもしない。それでは起動のたびに 1 つ増え、ユーザーのリポジトリのファイルが際限なく伸びる。アカウント id の関数にすることで、同じアカウントで立て直したときは同じエントリを使い回す。
 
-slug は読みやすさのためだけにあり、ASCII 英数字と `-` に落とす。一意性は hash が担う。ASCII を含まない名前（`マスター`）は slug が空になり、異なる名前が同じ slug に落ちること（`Lin` と `lin!`）もあるためである。slug が空のときは hash だけで鍵を作る。
+slug は読みやすさのためだけにあり、ASCII 英数字と `-` に落とす。一意性は hash が担う。id は不透明であるため、名前を鍵にしていたときより読みにくい——どのアカウントのエントリかは、そのエントリ自身の `LIPLUS_AGENT_NAME` から読む。読みやすさより同一性を採る。鍵が読みにくいのは 1 回の参照で済み、鍵が動くのは登録が行方不明になることであるから。
 
 登録のたびに、`liplus-chat-room` で始まり `LIPLUS_ROOM_URL` が現在の部屋アドレスと異なるエントリを削除する。部屋は起動ごとに新しいポートを取るため、それらは前回起動の残りであり、どのサイドカーも到達できない。残しておくと、この作業ディレクトリで CLI を起動するたびに死んだポートへ再試行するサイドカーが 1 つずつ増える。現在のアドレスを持つエントリは同一起動の別セッションであるから残す。`LIPLUS_ROOM_URL` を持たないエントリは、名前が前方一致しても他人のものとして触らない。
 
@@ -388,10 +412,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-<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` がある場合、セッション起動はエラーで止まる（黙って外すと動いたように見えるため）。
+5. **`.mcp.json` の登録が効いているか。** セッションの作業ディレクトリの `.mcp.json` に `liplus-chat-room-<slug>-<hash>` が入っているかを見る。鍵はアカウント id から決まるため名前では引けない。どのアカウントのものかはエントリ内の `LIPLUS_AGENT_NAME` で読む。固定の `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 時点、暫定）
@@ -400,7 +424,7 @@ CI が実行するもの:
 
 2 枚のアートボードを並べ、その差分をロードマップとして読む形にしてある。
 
-- **次の一手** — 現在の実装に参加者パネルと宛先を足した、実装可能な範囲。両方とも実装済みである。この 1 枚と実装の差は、操作ボタン（端末 / リサイズ / 終了）、宛先の見た目（削除可能なチップ）、そして #40 でランチャとタイトルバーに入った名乗り（名前欄と色の選択）である。宛先は `<select>` で機能的に等価であり、形の差は追っていない。名乗りの側はキャンバスが実装より古い。
+- **次の一手** — 現在の実装に参加者パネルと宛先を足した、実装可能な範囲。両方とも実装済みである。この 1 枚と実装の差は、操作ボタン（端末 / リサイズ / 終了）、宛先の見た目（削除可能なチップ）、#40 でランチャとタイトルバーに入った名乗り（名前欄と色の選択）、そして #53 のアカウント（作成・編集・削除、名簿のオフライン表示）である。宛先は `<select>` で機能的に等価であり、形の差は追っていない。名乗りとアカウントの側はキャンバスが実装より古く、差は #46 で追う。
 - **全体像** — ルーム一覧 / ダイレクト / 参加者・セッション状態パネル
 
 色と寸法は `src/styles.css` の実値をそのまま使っている（`--accent: #3a6ea5` / `--surface: #f4f4f7` / 角丸 4・6px / system-ui + Yu Gothic UI）。参加者ごとの色は accent と同じ彩度・明度で色相だけ変えたもの。絵と実装が同じトークンの上に乗るため、キャンバスの値をそのまま実装へ移せる。
@@ -413,7 +437,8 @@ CI が実行するもの:
 - 参加者パネルを持つ（実装済み。上記「参加者パネル」）。セッションの接続方法・起動コマンド・作業ディレクトリ・開始時刻を出す。操作（端末 / ミュート / 終了）は未実装であり、キャンバス側にのみある。
 - 発言に宛先を持たせる（実装済み。入力欄の左で参加者から選ぶ。既定は全体宛）。
 - 参加者ごとの色（実装済み。accent と同じ明度・彩度で色相のみ）。色相は宣言でき、宣言が導出に優先する（上記「参加者パネル」の梯子）。
-- 名前と色は参加の時点で決める（実装済み。人間はタイトルバー、セッションはランチャ。タブ属性にしない）。
+- 名前と色は「この部屋での自分は誰か」の宣言である（実装済み。人間はタイトルバーで参加の時点に、セッションはアカウントの属性として）。
+- アカウントは起動していなくても存在する（実装済み。上記「アカウント」）。同一性は id であり、名前は表示と宛先のための属性である。
 
 ### 決まっていないこと
 
@@ -424,6 +449,7 @@ CI が実行するもの:
 | 複数ルーム | サイドカーの `chat_id` は 1 つ固定。ルームごとにセッションを立てると利用枠がルーム数ぶん増え、1 セッションが複数ルームに属する形にすると push にルーム文脈を載せるプロトコル変更を伴う |
 | システム発言の出所 | エージェントが `say_to_room` で言うなら可。アプリがファイルや git を監視して言う形は「アプリは部屋であってランタイムではない」に当たる |
 | webhook を部屋へ流す | 未採用。判断材料は #32 に memo として残してある |
+| 人間をアカウントにするか | 画面の話者は `localStorage` の名前と色で参加している。アカウントへ統合すると名簿と宛先の出所が一本化されるが、人間の同一性を config のエントリとして持つことの是非を決めていない（#53 で対象外とした） |
 
 ## 配布
 
diff --git a/index.html b/index.html
index bacc398..cf0ecf4 100644
--- a/index.html
+++ b/index.html
@@ -30,19 +30,22 @@
         <button id="toggle-diagnostics" type="button" aria-expanded="false">診断</button>
       </header>
 
+      <!-- The accounts. An account exists whether or not it is running, so
+           this row is where one is made, named, coloured and pointed at a
+           working directory — not where a launch declares those (#53). Editing
+           any field here edits the account; the launch button starts the one
+           selected. -->
       <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). -->
+        <select id="account-select" aria-label="アカウント"></select>
+        <button id="account-new" type="button" title="アカウントを追加">＋</button>
+        <button id="account-delete" type="button" title="選択中のアカウントを削除">−</button>
         <label class="who">
           名前
-          <input id="session-name" type="text" spellcheck="false" />
+          <input id="account-name" type="text" spellcheck="false" />
         </label>
         <label class="who">
           色
-          <select id="session-hue"></select>
+          <select id="account-hue"></select>
         </label>
         <label class="cwd">
           作業ディレクトリ
@@ -107,7 +110,13 @@
         <!-- Who is in the room, and what the session under it was launched
              from. The values were all reachable before this panel existed;
              what was missing was a place that shows them without being
-             opened. -->
+             opened.
+
+             The list is the room's roster and the accounts that are not in it,
+             joined on the account id. An account that is not running is still
+             someone, so it is listed and marked offline rather than left out
+             (#53); it is not offered as an addressee, because a name that
+             cannot be reached is not one worth naming. -->
         <aside id="participants" aria-label="参加者">
           <h2 class="panel-title">参加者</h2>
           <!-- Seeded, because the roster only arrives once the room answers:
diff --git a/src-tauri/src/config.rs b/src-tauri/src/config.rs
index 4ef400a..ec852af 100644
--- a/src-tauri/src/config.rs
+++ b/src-tauri/src/config.rs
@@ -3,24 +3,53 @@ use std::path::PathBuf;
 use tauri::AppHandle;
 use tauri::Manager;
 
+/// One account: someone who exists in this app whether or not they are running.
+///
+/// The identity is `id`, and only `id`. It is minted once and never changes;
+/// everything else here is an attribute the person edits, the name included.
+///
+/// That is the whole of what an account adds over the launch recipe it replaces
+/// (`TabConfig`). A tab was a way of starting something, so the only handle
+/// anyone had on a session was the name it took — and two launches off one tab
+/// took the same name, which left them indistinguishable and unaddressable
+/// (#40). With a structural identity underneath, the name can come down to
+/// being a display attribute: it may be edited, and it may collide, without
+/// anything losing track of who is who.
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct TabConfig {
+pub struct Account {
+    /// Immutable, and the only identity. The `.mcp.json` registration key
+    /// derives from this rather than from the name, so a rename cannot move the
+    /// key out from under a session already running under it.
     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).
+    /// What the room lists this account under and what a post is addressed to.
+    /// Display and addressing; never identity.
     pub name: String,
     pub command: String,
     pub args: Vec<String>,
     pub cwd: Option<String>,
-    pub cli_kind: String,
+    /// The hue this account is drawn in, in oklch degrees, or `None` when none
+    /// was chosen — the screen derives one from the name in that case. Absent
+    /// rather than defaulted: chosen and derived are different states (#45).
+    ///
+    /// Stored here rather than declared per launch, which is where #40 put both
+    /// this and the name. #40 was fixing that a session could not be named at
+    /// all, and with no identity to hang a name on, declaring at the moment of
+    /// joining was the way to reach that. There is an identity now, so the pair
+    /// moves onto it and gains what the launch-time form could not have: an
+    /// account is named and coloured while it is not running.
+    #[serde(default)]
+    pub hue: Option<f64>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AppConfig {
-    pub tabs: Vec<TabConfig>,
+    /// Also read from `tabs`, the name this key had while an account was a
+    /// launch recipe. That alias is the whole migration: id, name, command,
+    /// args and working directory carry over as they are, `cli_kind` is
+    /// dropped on the floor by serde because nothing is left to read it (#17),
+    /// and a hue is simply not declared yet. The next save writes `accounts`.
+    #[serde(alias = "tabs")]
+    pub accounts: Vec<Account>,
 }
 
 // ---------------------------------------------------------------------------
@@ -53,20 +82,23 @@ impl Default for AppConfig {
         // One vendor, by decision rather than by omission: the room is built
         // on a channel capability only this CLI is known to have, and the
         // 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.
+        // design. Shipping an account 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.
+        // One account, and its name is the CLI's. That is a starting point
+        // sitting in an editable field, not the fixed label it used to be:
+        // every session answered to this one name because there was nowhere to
+        // change it and nothing else to tell two launches apart (#40). A second
+        // account is created on screen and is named there.
         AppConfig {
-            tabs: vec![TabConfig {
-                id: "tab-1".to_string(),
+            accounts: vec![Account {
+                id: "account-1".to_string(),
                 name: "Claude Code".to_string(),
                 command: "claude".to_string(),
                 args: vec![],
                 cwd: None,
-                cli_kind: "claude".to_string(),
+                hue: None,
             }],
         }
     }
@@ -101,9 +133,15 @@ pub fn load_config(app: AppHandle) -> Result<AppConfig, String> {
     let content =
         std::fs::read_to_string(&path).map_err(|e| format!("Failed to read config: {e}"))?;
 
-    // No legacy migration path exists. liplus-chat has never shipped a
-    // release, and its app data directory is keyed to its own identifier
-    // (org.liplus-project.liplus-chat), so no config in the older
+    // A config written before accounts existed parses here as it stands: the
+    // `tabs` alias on `AppConfig` reads the old key, and `cli_kind` is an
+    // unknown field serde ignores. No migration step runs, because there is
+    // nothing left for one to do — the person's own working directory and
+    // launch options are what would have been lost, and they carry over.
+    //
+    // No path exists for anything older than that. liplus-chat has never
+    // shipped a release, and its app data directory is keyed to its own
+    // identifier (org.liplus-project.liplus-chat), so no config in the older
     // left/right pane format from liplus-desktop can reach this app.
     serde_json::from_str::<AppConfig>(&content)
         .map_err(|e| format!("Failed to parse config: {e}"))
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 9661425..1759614 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -5,6 +5,7 @@ mod session;
 
 use pty::PtyState;
 use room::RoomState;
+use session::RoomSeats;
 use tauri::Manager;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
@@ -14,6 +15,9 @@ pub fn run() {
         .plugin(tauri_plugin_clipboard_manager::init())
         .manage(PtyState::new())
         .manage(RoomState::new())
+        // Which account is in the room, so a second launch of one account is
+        // refused rather than seating one identity twice (session::RoomSeats).
+        .manage(RoomSeats::new())
         .setup(|app| {
             // The room has to be listening before any session is started: the
             // port goes into the `.mcp.json` a session launch writes.
@@ -41,6 +45,7 @@ pub fn run() {
             room::room_participants,
             room::room_join,
             room::room_post,
+            session::seated_accounts,
             session::parse_launch_options,
             session::preview_launch_args,
             session::start_session,
diff --git a/src-tauri/src/pty.rs b/src-tauri/src/pty.rs
index 4ed7d9b..16cf706 100644
--- a/src-tauri/src/pty.rs
+++ b/src-tauri/src/pty.rs
@@ -26,6 +26,18 @@ impl PtyState {
             procs: Arc::new(Mutex::new(HashMap::new())),
         }
     }
+
+    /// Whether the session on `id` is still running.
+    ///
+    /// Membership is liveness, not history: a session is taken out of the map
+    /// by its own reader thread the moment it is reaped. That is what lets a
+    /// seat in the room release itself (`session::RoomSeats`) instead of
+    /// depending on someone remembering to call for its release — a release
+    /// that never came would lock an account out of the room for the rest of
+    /// the run, with no way back short of restarting the app.
+    pub fn is_running(&self, id: &str) -> bool {
+        self.procs.lock().contains_key(id)
+    }
 }
 
 #[tauri::command]
@@ -109,14 +121,25 @@ pub fn spawn_pty(
                 Err(_) => break,
             }
         }
-        // Collect exit code before emitting exit event
-        let exit_code: Option<u32> = {
-            let mut map = ptys_clone.lock();
-            if let Some(pty) = map.get_mut(&id_clone) {
-                pty.child.wait().ok().map(|status| status.exit_code())
-            } else {
-                None
-            }
+        // Collect exit code before emitting exit event.
+        //
+        // Taken out of the map first, for two reasons. The map is what says a
+        // session is running, and a session that has ended must stop saying so
+        // — a seat in the room is held for exactly as long as this entry is
+        // here. And the wait happens outside the lock, so a child that is slow
+        // to be reaped no longer blocks every other session's input.
+        //
+        // The instance is dropped after the wait, never before: dropping the
+        // master closes the PTY, and closing it under a child that has not been
+        // reaped is how an exit code goes missing.
+        // Bound before the match: a guard held in the scrutinee lives as long
+        // as the match does, which would put the wait back inside the lock.
+        let ended = ptys_clone.lock().remove(&id_clone);
+        let exit_code: Option<u32> = match ended {
+            Some(mut pty) => pty.child.wait().ok().map(|status| status.exit_code()),
+            // Already removed: `kill_pty` took it. The exit is this thread's to
+            // announce either way; the code is not knowable from here.
+            None => None,
         };
         // Emit exit event with exit code payload (None if killed by signal/unknown)
         let _ = app_clone.emit(&format!("pty-exit-{}", id_clone), exit_code);
diff --git a/src-tauri/src/session.rs b/src-tauri/src/session.rs
index 09246b0..b8fafbf 100644
--- a/src-tauri/src/session.rs
+++ b/src-tauri/src/session.rs
@@ -8,14 +8,17 @@
 //!
 //! The session must be interactive: `--print` never receives a push.
 
-use crate::config::TabConfig;
+use crate::config::Account;
 use crate::pty::{self, PtyState};
 use crate::room::RoomState;
 use mcp_config::{
     channel_launch_args, register_sidecar, reject_incompatible_flags, server_name_for,
     RoomRegistration,
 };
-use std::path::PathBuf;
+use parking_lot::Mutex;
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
 use tauri::AppHandle;
 
 /// The sidecar entry point and the runner that executes it.
@@ -72,6 +75,104 @@ fn resolve_sidecar_paths() -> Result<(PathBuf, PathBuf), String> {
         .to_string())
 }
 
+/// Which seat in the room each account is holding.
+///
+/// **One account, one seat per room.** An account is who someone is, and the
+/// same someone cannot be in one room twice: two connections under one account
+/// would put one identity in the roster twice, and a post addressed to that
+/// name would have two places to land.
+///
+/// The rule is scoped to the room, not to the account. There is one room today
+/// — the sidecar's `LIPLUS_ROOM_ID` is fixed to `liplus-chat` — so this map
+/// needs no room in its key yet, and with one room the refusal is
+/// indistinguishable from "an account runs once". They are not the same rule.
+/// Rooms are meant to become plural (`design/Vision.dc.html`), and one account
+/// holding a seat in each of two rooms is the intended shape rather than a
+/// violation of this one. The scope is written down here because the mechanism
+/// cannot show it: a rule remembered as "an account runs once" would outlive
+/// the reason for it and block that case later, when nobody remembers why the
+/// line was drawn.
+#[derive(Clone)]
+pub struct RoomSeats {
+    seats: Arc<Mutex<BTreeMap<String, Seat>>>,
+}
+
+/// One account's seat, from the launch being decided to the session ending.
+enum Seat {
+    /// A launch is in flight: the registration is being written, or the CLI is
+    /// being spawned. Held so that two launches racing for one account cannot
+    /// both find the seat empty — the loser is refused before a second process
+    /// exists, rather than after.
+    Starting,
+    /// A session is running. The PTY id is what says so, and asking the PTY is
+    /// the only liveness question anyone asks here.
+    Running(String),
+}
+
+impl RoomSeats {
+    pub fn new() -> Self {
+        RoomSeats {
+            seats: Arc::new(Mutex::new(BTreeMap::new())),
+        }
+    }
+
+    /// The accounts holding a seat right now.
+    ///
+    /// Liveness is read off the PTY rather than from a release call anyone has
+    /// to remember to make. A seat whose session has exited is a free seat, and
+    /// a release that never arrived would otherwise lock an account out of the
+    /// room for the rest of the run with no way back short of restarting.
+    pub fn seated(&self, ptys: &PtyState) -> Vec<String> {
+        let mut seats = self.seats.lock();
+        seats.retain(|_, seat| match seat {
+            Seat::Starting => true,
+            Seat::Running(pty_id) => ptys.is_running(pty_id),
+        });
+        seats.keys().cloned().collect()
+    }
+
+    /// Claim the seat for `account_id`, or fail because it is taken.
+    ///
+    /// The sweep and the claim are one acquisition of the lock: checking first
+    /// and claiming after would let two launches pass the same empty seat.
+    fn claim(&self, account_id: &str, ptys: &PtyState) -> Result<(), ()> {
+        let mut seats = self.seats.lock();
+        let taken = match seats.get(account_id) {
+            Some(Seat::Starting) => true,
+            Some(Seat::Running(pty_id)) => ptys.is_running(pty_id),
+            None => false,
+        };
+        if taken {
+            return Err(());
+        }
+        seats.insert(account_id.to_string(), Seat::Starting);
+        Ok(())
+    }
+
+    /// The launch got a session up; the seat is now held by that session.
+    fn hold(&self, account_id: &str, pty_id: &str) {
+        self.seats
+            .lock()
+            .insert(account_id.to_string(), Seat::Running(pty_id.to_string()));
+    }
+
+    /// The launch failed. Nothing is running, so nothing holds the seat.
+    fn release(&self, account_id: &str) {
+        self.seats.lock().remove(account_id);
+    }
+}
+
+/// The accounts with a session in the room, for the screen to draw against its
+/// own list of accounts.
+///
+/// Account ids, never names. The screen matches these against its accounts by
+/// id, so an account renamed while its session runs is still the same account
+/// on both sides, and two accounts sharing a name are still two.
+#[tauri::command]
+pub fn seated_accounts(pty_state: tauri::State<PtyState>, seats: tauri::State<RoomSeats>) -> Vec<String> {
+    seats.seated(&pty_state)
+}
+
 /// Split a launch-options string into arguments.
 ///
 /// The splitter lives in `mcp-config` so it is covered by tests; this is the
@@ -87,13 +188,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.
+/// The entry names this account's own server, which is a function of the
+/// account id, so the preview changes when a different account is selected and
+/// holds still while that account's name is edited. Holding still is the point:
+/// the identity being launched is the account, and renaming it does not make it
+/// something else (#53).
 #[tauri::command]
-pub fn preview_launch_args(args: Vec<String>, name: String) -> Vec<String> {
-    channel_launch_args(&args, &server_name_for(name.trim()))
+pub fn preview_launch_args(args: Vec<String>, account_id: String) -> Vec<String> {
+    channel_launch_args(&args, &server_name_for(account_id.trim()))
 }
 
 /// What the caller gets back after a session joins.
@@ -112,39 +214,37 @@ pub struct StartedSession {
     pub started_at: String,
 }
 
-/// Launch one session under a declared identity.
+/// Put one account into the room.
 ///
-/// `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).
+/// The account carries who this is: its id is the identity, and its name and
+/// hue are what the room lists it under. Both used to be declared per launch,
+/// beside a tab that said only which CLI to run — the way to name a session at
+/// all before there was anything durable to hang a name on (#40). The account
+/// is that durable thing, so the launch no longer declares anything; it starts
+/// someone who already exists.
 #[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>,
+    seats: tauri::State<RoomSeats>,
+    account: Account,
     cols: u16,
     rows: u16,
 ) -> Result<StartedSession, String> {
-    let name = name.trim().to_string();
+    let name = account.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 \
+            "This account 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) {
+    if let Err(flag) = reject_incompatible_flags(&account.args) {
         return Err(format!(
-            "Tab \"{}\" passes {flag}, which stops channel pushes from arriving. \
-             Remove it from the tab configuration.",
-            tab.name
+            "Account \"{name}\" passes {flag}, which stops channel pushes from arriving. \
+             Remove it from the launch options."
         ));
     }
 
@@ -156,30 +256,75 @@ pub fn start_session(
     // No fallback to the app's own process directory. Under `tauri dev` that
     // is `src-tauri`, and a session silently launched there is a session the
     // person never chose and cannot see they got (#20).
-    let cwd = match tab.cwd.as_deref().map(str::trim) {
+    let cwd = match account.cwd.as_deref().map(str::trim) {
         Some(dir) if !dir.is_empty() => PathBuf::from(dir),
         _ => {
             return Err(format!(
-                "Tab \"{}\" has no working directory. Set one before starting a session.",
-                tab.name
+                "Account \"{name}\" has no working directory. Set one before starting a session."
             ))
         }
     };
     if !cwd.is_dir() {
-        return Err(format!("Tab \"{}\" points at a missing directory: {}", tab.name, cwd.display()));
+        return Err(format!(
+            "Account \"{name}\" points at a missing directory: {}",
+            cwd.display()
+        ));
+    }
+
+    // One account, one seat per room (`RoomSeats`). Claimed before anything is
+    // written or spawned, so a refusal costs nothing and leaves nothing behind.
+    seats.claim(&account.id, &pty_state).map_err(|()| {
+        format!(
+            "Account \"{name}\" already holds a seat in this room. One account holds one seat \
+             per room: stop its running session before starting it again."
+        )
+    })?;
+
+    match launch(app, &room, pty_state, &account, &name, &room_url, &cwd, cols, rows) {
+        Ok(started) => {
+            seats.hold(&account.id, &started.pty_id);
+            Ok(started)
+        }
+        Err(err) => {
+            // Nothing is running, so nothing holds the seat. Without this the
+            // account would stay locked out by a launch that never happened.
+            seats.release(&account.id);
+            Err(err)
+        }
     }
+}
 
+/// Write the registration and spawn the CLI, with the seat already claimed.
+///
+/// Split out so the seat has exactly one release point: every failure from here
+/// down leaves the account seatless, and the caller does not have to remember
+/// that at each `?`.
+#[allow(clippy::too_many_arguments)]
+fn launch(
+    app: AppHandle,
+    room: &RoomState,
+    pty_state: tauri::State<PtyState>,
+    account: &Account,
+    name: &str,
+    room_url: &str,
+    cwd: &Path,
+    cols: u16,
+    rows: u16,
+) -> Result<StartedSession, String> {
     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);
+    // Keyed on the account id, so two accounts launched into one working
+    // directory write two entries instead of overwriting each other's identity
+    // (#40), and renaming an account does not move the key out from under the
+    // session running on it (#53).
+    let server_name = server_name_for(&account.id);
     let mcp_config = register_sidecar(
-        &cwd,
+        cwd,
         &RoomRegistration {
-            room_url: &room_url,
+            room_url,
             token: &room.token(),
-            agent_name: &name,
-            agent_hue: hue,
+            account_id: &account.id,
+            agent_name: name,
+            agent_hue: account.hue,
             sidecar_entry: &sidecar_entry,
             sidecar_runner: &sidecar_runner,
         },
@@ -189,8 +334,8 @@ pub fn start_session(
     let pty_id = pty::spawn_pty(
         app,
         pty_state,
-        tab.command.clone(),
-        channel_launch_args(&tab.args, &server_name),
+        account.command.clone(),
+        channel_launch_args(&account.args, &server_name),
         cols,
         rows,
         Some(cwd.to_string_lossy().to_string()),
diff --git a/src/main.ts b/src/main.ts
index 096a3cc..84d8de4 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -68,19 +68,29 @@ interface Participant {
   own: boolean;
 }
 
-interface TabConfig {
+/**
+ * One account: someone who exists whether or not they are running.
+ *
+ * `id` is the identity and never changes. Everything else is an attribute the
+ * person edits — the name included, which is why an account can be renamed
+ * without anything losing track of it. The launch recipe this replaced had no
+ * identity of its own, so the name a session took was the only handle on it,
+ * and two launches off one recipe took the same name (#40).
+ */
+interface Account {
   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. */
+  /** What the room lists this account under, and what a post is addressed to. */
   name: string;
   command: string;
   args: string[];
   cwd: string | null;
-  cli_kind: string;
+  /** The hue chosen for this account, or null when none was — the derived one
+   *  from the name is used then. */
+  hue: number | null;
 }
 
 interface AppConfig {
-  tabs: TabConfig[];
+  accounts: Account[];
 }
 
 interface StartedSession {
@@ -92,8 +102,6 @@ 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.
@@ -133,9 +141,11 @@ 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 accountEl = document.getElementById("account-select") as HTMLSelectElement;
+const accountNameEl = document.getElementById("account-name") as HTMLInputElement;
+const accountHueEl = document.getElementById("account-hue") as HTMLSelectElement;
+const accountNewEl = document.getElementById("account-new") as HTMLButtonElement;
+const accountDeleteEl = document.getElementById("account-delete") as HTMLButtonElement;
 const startEl = document.getElementById("start-session") as HTMLButtonElement;
 const inputEl = document.getElementById("input") as HTMLTextAreaElement;
 const sendEl = document.getElementById("send") as HTMLButtonElement;
@@ -155,11 +165,23 @@ const cwdEl = document.getElementById("session-cwd") as HTMLInputElement;
 const optionsEl = document.getElementById("launch-options") as HTMLInputElement;
 const previewEl = document.getElementById("launch-preview") as HTMLElement;
 
-let tabs: TabConfig[] = [];
+let accounts: Account[] = [];
+/**
+ * The accounts holding a seat in the room, by id.
+ *
+ * Ids, never names: this is matched against the account list to decide who is
+ * offline, and a name match would tie the wrong account as soon as two share a
+ * name — which they may, now that a name is an editable attribute (#53). The
+ * app is the authority (`seated_accounts`); the screen re-reads it rather than
+ * keeping a count of its own launches.
+ */
+let seated = new Set<string>();
 /** Everyone in the room, this screen's person included. */
 let participants: Participant[] = [];
 /** The session the terminal is attached to, once one is running. */
 let activePtyId: string | null = null;
+/** Prefill for an account that has never been given a working directory. */
+let homeDir = "";
 /**
  * The newest post this screen has drawn, declared as `last_seen` when posting.
  *
@@ -231,6 +253,24 @@ function joinArgs(args: string[]): string {
   return args.map((arg) => (arg === "" || arg.includes(" ") ? `"${arg}"` : arg)).join(" ");
 }
 
+/** The account the launcher is pointed at, or null when there is none. */
+function selectedAccount(): Account | null {
+  return accounts.find((candidate) => candidate.id === accountEl.value) ?? null;
+}
+
+/**
+ * Write the account list back to disk.
+ *
+ * Every edit persists as it is made rather than at the next launch: an account
+ * is a thing that exists whether or not it runs, so a name typed and never
+ * launched is not a draft (#53).
+ */
+function saveAccounts(): void {
+  void invoke("save_config", { config: { accounts } }).catch(() => {
+    status("アカウントを保存できませんでした。", "error");
+  });
+}
+
 /**
  * Show the command that will actually run.
  *
@@ -239,20 +279,22 @@ function joinArgs(args: string[]): string {
  * cheaper than explaining the merge.
  */
 async function refreshPreview(): Promise<void> {
-  const tab = tabs.find((candidate) => candidate.id === tabEl.value);
-  if (!tab) {
+  const account = selectedAccount();
+  if (!account) {
     previewEl.textContent = "";
     return;
   }
   try {
     const parsed = await invoke<string[]>("parse_launch_options", { text: optionsEl.value });
-    // 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.
+    // The channel entry names this account's own server, which follows the
+    // account id. So the preview changes when another account is selected and
+    // holds still while this one is renamed — the identity being launched is
+    // the account, and renaming it does not make it something else (#53).
     const merged = await invoke<string[]>("preview_launch_args", {
       args: parsed,
-      name: sessionName(),
+      accountId: account.id,
     });
-    previewEl.textContent = `${tab.command} ${joinArgs(merged)}`;
+    previewEl.textContent = `${account.command} ${joinArgs(merged)}`;
   } catch {
     previewEl.textContent = "";
   }
@@ -388,65 +430,115 @@ function appendMessage(message: RoomMessage): void {
 }
 
 /**
- * Draw the roster into the panel.
+ * Draw one line of the panel's list.
  *
- * The list is the room's roster and nothing else: the screen keeps no second
- * list of who is present, so a name on this panel is a name a post can be
- * addressed to. Each entry carries the colour that participant's lines carry
- * in the room, which is what makes the panel a legend for the conversation
- * rather than a second copy of the same names.
+ * The colour is the one that participant's lines carry 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: Participant[]): void {
-  participants = joined;
+function rosterEntry(name: string, hue: number | null, own: boolean, note?: string): HTMLLIElement {
+  const entry = document.createElement("li");
+  entry.style.setProperty("--speaker", speakerColor(name, hue, own));
+
+  const dot = document.createElement("span");
+  dot.className = "dot";
+
+  const who = document.createElement("span");
+  who.className = "who";
+  who.textContent = name;
+  who.title = name;
+
+  entry.append(dot, who);
+  if (note) {
+    const tag = document.createElement("span");
+    tag.className = "note";
+    tag.textContent = note;
+    entry.appendChild(tag);
+  }
+  return entry;
+}
+
+/**
+ * Draw the panel's list: who is in the room, and who exists but is not.
+ *
+ * The two halves are joined **on the account id**. The live half is the room's
+ * roster verbatim — the screen keeps no second list of who is present, so a
+ * name on a live line is a name a post can be addressed to. The offline half is
+ * every account with no seat, which the app answers by id (`seated_accounts`).
+ *
+ * By id and never by name. A name is an editable attribute now, so two accounts
+ * may answer to one name and a running account may have been renamed since it
+ * joined; matching the two halves by name would tie the wrong pair in both
+ * cases, which is the failure #40 was about in another shape.
+ *
+ * An account that is not running is still someone, so it is listed rather than
+ * left out — that is the whole point of an account existing while it is off
+ * (#53). It does not become an addressee: `renderAddressees` reads the live
+ * roster only, because a name that cannot be reached is not worth naming.
+ */
+function renderPanel(): void {
   rosterEl.replaceChildren();
 
-  if (!joined.length) {
+  const offline = accounts.filter((account) => !seated.has(account.id));
+  if (!participants.length && !offline.length) {
     const empty = document.createElement("li");
     empty.className = "empty";
     empty.textContent = "参加者なし";
     rosterEl.appendChild(empty);
   }
 
-  for (const participant of joined) {
+  for (const participant of participants) {
     // `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(participant.name, participant.hue, participant.own),
+    rosterEl.appendChild(
+      rosterEntry(
+        participant.name,
+        participant.hue,
+        participant.own,
+        participant.own ? "（あなた）" : undefined,
+      ),
     );
+  }
 
-    const dot = document.createElement("span");
-    dot.className = "dot";
-
-    const who = document.createElement("span");
-    who.className = "who";
-    who.textContent = participant.name;
-    who.title = participant.name;
-
-    entry.append(dot, who);
-    if (participant.own) {
-      const you = document.createElement("span");
-      you.className = "self";
-      you.textContent = "（あなた）";
-      entry.appendChild(you);
-    }
+  for (const account of offline) {
+    const entry = rosterEntry(account.name, account.hue, false, "未起動");
+    entry.classList.add("offline");
     rosterEl.appendChild(entry);
   }
 
   renderAddressees();
 }
 
+/** Take the room's roster and redraw the panel around it. */
+function renderRoster(joined: Participant[]): void {
+  participants = joined;
+  renderPanel();
+}
+
+/**
+ * Re-read which accounts hold a seat, from the app.
+ *
+ * The app is the authority because it is what refuses a second launch; a count
+ * kept on this side would be a second opinion about the same fact. It is read
+ * after a launch and after a session exits, which are the two moments the
+ * answer changes.
+ */
+async function refreshSeats(): Promise<void> {
+  try {
+    seated = new Set(await invoke<string[]>("seated_accounts"));
+  } catch {
+    // The panel keeps the last answer rather than declaring everyone offline
+    // on a failed read.
+    return;
+  }
+  renderPanel();
+}
+
 /** The name this screen posts under, and is listed in the roster under. */
 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 and colour.
  *
@@ -477,7 +569,10 @@ async function join(): Promise<void> {
  * back to the whole room when they leave.
  *
  * Everyone but oneself is addressable — sessions and people alike, since the
- * roster no longer separates them.
+ * roster no longer separates them. The room's roster is the whole source, so an
+ * account with no session in it is absent from here by construction: naming a
+ * participant who cannot be reached is a post addressed to nobody, which is the
+ * reason addressees are picked from a roster at all (#43).
  */
 function renderAddressees(): void {
   const chosen = toEl.value;
@@ -550,11 +645,8 @@ 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,
-  name: string,
-  started: StartedSession,
-): Promise<void> {
+async function followSession(account: Account, started: StartedSession): Promise<void> {
+  const name = account.name;
   sessionStateEl.textContent = `${name} 起動中`;
   sessionStateEl.dataset.kind = "ok";
   activePtyId = started.pty_id;
@@ -564,9 +656,9 @@ async function followSession(
   // and the command it actually got, not against the ones that were intended.
   // They stay on screen after the session exits — the question is what ran.
   transportEl.textContent = "PTY";
-  commandEl.textContent = tab.command;
-  dirEl.textContent = tab.cwd ?? "—";
-  dirEl.title = tab.cwd ?? "";
+  commandEl.textContent = account.command;
+  dirEl.textContent = account.cwd ?? "—";
+  dirEl.title = account.cwd ?? "";
   startedEl.textContent = shortTime(started.started_at);
   showWindowSize();
 
@@ -578,6 +670,9 @@ async function followSession(
     sessionStateEl.dataset.kind = "error";
     status(`${name} が終了しました（${detail}）。診断を確認してください。`, "error");
     activePtyId = null;
+    // The seat this account held is free the moment its session ends, so the
+    // panel says 未起動 again and the account can be started once more.
+    void refreshSeats();
     revealDiagnostics();
   });
 
@@ -588,23 +683,29 @@ async function followSession(
 }
 
 async function startSession(): Promise<void> {
-  const tab = tabs.find((candidate) => candidate.id === tabEl.value);
-  if (!tab) {
-    status("起動するセッションが選ばれていません。", "error");
+  const account = selectedAccount();
+  if (!account) {
+    status("起動するアカウントが選ばれていません。", "error");
     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();
+  const name = account.name.trim();
   if (!name) {
-    status("セッションの名前を入力してください。部屋での名乗りになります。", "error");
-    sessionNameEl.focus();
+    status("アカウントの名前を入力してください。部屋での名乗りになります。", "error");
+    accountNameEl.focus();
+    return;
+  }
+
+  // One account, one seat per room. Said here so the reason is on screen in the
+  // language it is read in; the app refuses it as well, and that refusal is the
+  // authority — this check only gets there first (#53).
+  if (seated.has(account.id)) {
+    status(
+      `「${name}」は既にこの部屋に居ます。一つのアカウントが持てる席は一つの部屋につき一つです。起動中のセッションを終了してから、もう一度起動してください。`,
+      "error",
+    );
     return;
   }
-  const hue = declaredHue(sessionHueEl);
 
   const cwd = cwdEl.value.trim();
   if (!cwd) {
@@ -612,11 +713,12 @@ async function startSession(): Promise<void> {
     cwdEl.focus();
     return;
   }
-  // The directory is the person's choice, so it is carried on the tab and
-  // saved. Falling back to whatever directory the app process happens to sit
-  // in is what put a session in src-tauri (#20).
-  const args = await invoke<string[]>("parse_launch_options", { text: optionsEl.value });
-  const launching: TabConfig = { ...tab, cwd, args };
+  // The directory and the options are the person's choice, so they are the
+  // account's own and are saved. Falling back to whatever directory the app
+  // process happens to sit in is what put a session in src-tauri (#20).
+  account.cwd = cwd;
+  account.args = await invoke<string[]>("parse_launch_options", { text: optionsEl.value });
+  saveAccounts();
 
   // Size the PTY to the terminal that will display it, so the CLI's first
   // paint is not laid out for a window it does not have.
@@ -627,36 +729,132 @@ async function startSession(): Promise<void> {
   status(`${name} を起動しています…`);
   try {
     const started = await invoke<StartedSession>("start_session", {
-      tab: launching,
-      name,
-      hue,
+      account,
       cols: terminal.cols,
       rows: terminal.rows,
     });
-    tab.cwd = cwd;
-    tab.args = args;
-    void invoke("save_config", { config: { tabs } }).catch(() => {
-      // A directory that fails to persist is worth one line, not a failed
-      // launch: the session is already up.
-      status("作業ディレクトリを保存できませんでした。", "error");
-    });
-    // 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);
+    await refreshSeats();
+    await followSession(account, started);
   } catch (err) {
     status(`${name} を起動できませんでした: ${err}`, "error");
     sessionStateEl.textContent = `${name} 起動失敗`;
     sessionStateEl.dataset.kind = "error";
+    // A launch that failed after the app claimed the seat releases it there;
+    // this keeps the panel in step with that.
+    await refreshSeats();
     revealDiagnostics();
   } finally {
     startEl.disabled = false;
   }
 }
 
+/**
+ * A default name for a new account that no existing account already answers to.
+ *
+ * A constant default would put every new account on one name, which is the
+ * defect #40 removed — two participants answering alike, neither addressable.
+ * The identity is the id and would survive that, but being able to name one of
+ * them is the point of a name, so the default counts up past whatever is taken.
+ * It is a starting point in an editable field, not a value anyone is stuck with.
+ */
+function unusedAccountName(): string {
+  const taken = new Set(accounts.map((account) => account.name.trim()));
+  for (let n = accounts.length + 1; ; n += 1) {
+    const candidate = `アカウント ${n}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+
+/** Fill the account picker, keeping `selected` selected when it still exists. */
+function renderAccountOptions(selected: string): void {
+  accountEl.replaceChildren();
+  for (const account of accounts) {
+    const option = document.createElement("option");
+    option.value = account.id;
+    option.textContent = account.name || "（名前未設定）";
+    accountEl.appendChild(option);
+  }
+  accountEl.value = accounts.some((account) => account.id === selected)
+    ? selected
+    : (accounts[0]?.id ?? "");
+}
+
+/**
+ * Show the selected account's own values in the row that edits them.
+ *
+ * `homeDir` prefills a working directory an account has never had one for. A
+ * prefill, not a default: the app launches nothing in a directory the person
+ * has not seen on screen (#20).
+ */
+function showAccount(): void {
+  const account = selectedAccount();
+  accountNameEl.value = account?.name ?? "";
+  accountHueEl.value = account?.hue === null || account === null ? "" : String(account.hue);
+  cwdEl.value = account?.cwd ?? homeDir;
+  optionsEl.value = joinArgs(account?.args ?? []);
+  const missing = account === null;
+  accountNameEl.disabled = missing;
+  accountHueEl.disabled = missing;
+  cwdEl.disabled = missing;
+  optionsEl.disabled = missing;
+  accountDeleteEl.disabled = missing;
+  startEl.disabled = missing;
+  void refreshPreview();
+}
+
+/** Make an account, select it, and leave the cursor in its name. */
+function newAccount(): void {
+  const account: Account = {
+    // Opaque and minted once. Nothing reads a name out of it — the key in
+    // `.mcp.json` derives from it precisely so that renaming is free (#53).
+    id: crypto.randomUUID(),
+    name: unusedAccountName(),
+    // The one vendor the room is built on. See src-tauri/src/config.rs.
+    command: "claude",
+    args: [],
+    cwd: homeDir || null,
+    hue: null,
+  };
+  accounts.push(account);
+  renderAccountOptions(account.id);
+  showAccount();
+  saveAccounts();
+  renderPanel();
+  accountNameEl.focus();
+  accountNameEl.select();
+}
+
+/**
+ * Remove the selected account.
+ *
+ * Refused while it is running: the session in the room belongs to this account,
+ * and deleting the account under it would leave a participant on the roster
+ * that nothing on this screen can name or account for.
+ */
+function deleteAccount(): void {
+  const account = selectedAccount();
+  if (!account) return;
+  if (seated.has(account.id)) {
+    status(
+      `「${account.name}」は起動中です。セッションを終了してから削除してください。`,
+      "error",
+    );
+    return;
+  }
+  // Only an explicit cancel stops this. A host that answers nothing would
+  // otherwise make the button silently do nothing at all.
+  if (window.confirm(`アカウント「${account.name}」を削除します。よろしいですか。`) === false) {
+    return;
+  }
+  accounts = accounts.filter((candidate) => candidate.id !== account.id);
+  renderAccountOptions(accounts[0]?.id ?? "");
+  showAccount();
+  saveAccounts();
+  renderPanel();
+  status(`アカウント「${account.name}」を削除しました。`);
+}
+
 function renderSocket(port: number | null, error?: string): void {
   if (error) {
     socketStateEl.textContent = error;
@@ -716,7 +914,9 @@ async function main(): Promise<void> {
 
   nameEl.value = localStorage.getItem(NAME_KEY) ?? "human";
   fillHues(hueEl, localStorage.getItem(HUE_KEY));
-  fillHues(sessionHueEl, localStorage.getItem(SESSION_HUE_KEY));
+  // The account's colour is the account's, so nothing is restored into this
+  // picker — `showAccount` fills it from whichever account is selected.
+  fillHues(accountHueEl, null);
 
   // 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.
@@ -754,50 +954,68 @@ async function main(): Promise<void> {
   });
   startEl.addEventListener("click", () => void startSession());
 
-  let home = "";
   try {
-    home = await invoke<string>("home_dir");
+    homeDir = await invoke<string>("home_dir");
   } catch {
     // Only the prefill is lost; the field is still typed into by hand.
   }
 
-  const showTab = (): void => {
-    const tab = tabs.find((candidate) => candidate.id === tabEl.value);
-    cwdEl.value = tab?.cwd ?? home;
-    optionsEl.value = joinArgs(tab?.args ?? []);
-    void refreshPreview();
-  };
+  // Every field in this row edits the selected account. The name is written
+  // through as it is typed so the picker's label follows it, and persisted when
+  // the field is left — a rename is free, because the account's id is what the
+  // registration key and the seat are both keyed on (#53).
+  accountNameEl.addEventListener("input", () => {
+    const account = selectedAccount();
+    if (!account) return;
+    account.name = accountNameEl.value;
+    const option = accountEl.selectedOptions[0];
+    if (option) option.textContent = account.name || "（名前未設定）";
+    renderPanel();
+  });
+  accountNameEl.addEventListener("change", () => saveAccounts());
+  accountHueEl.addEventListener("change", () => {
+    const account = selectedAccount();
+    if (!account) return;
+    account.hue = declaredHue(accountHueEl);
+    saveAccounts();
+    renderPanel();
+  });
+  cwdEl.addEventListener("change", () => {
+    const account = selectedAccount();
+    if (!account) return;
+    account.cwd = cwdEl.value.trim() || null;
+    saveAccounts();
+  });
   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());
+  optionsEl.addEventListener("change", () => {
+    const account = selectedAccount();
+    if (!account) return;
+    void invoke<string[]>("parse_launch_options", { text: optionsEl.value }).then((args) => {
+      account.args = args;
+      saveAccounts();
+    });
+  });
+  accountEl.addEventListener("change", showAccount);
+  accountNewEl.addEventListener("click", () => newAccount());
+  accountDeleteEl.addEventListener("click", () => deleteAccount());
 
   try {
     const config = await invoke<AppConfig>("load_config");
-    tabs = config.tabs;
-    for (const tab of tabs) {
-      const option = document.createElement("option");
-      option.value = tab.id;
-      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);
+    accounts = config.accounts;
+    renderAccountOptions(accounts[0]?.id ?? "");
+    showAccount();
   } catch (err) {
     status(`設定を読み込めませんでした: ${err}`, "error");
   }
 
   try {
     await join();
-    renderRoster(await invoke<Participant[]>("room_participants"));
+    participants = await invoke<Participant[]>("room_participants");
+    await refreshSeats();
     const port = await invoke<number | null>("room_port");
     if (port !== null) renderSocket(port);
   } catch (err) {
+    renderPanel();
     renderSocket(null, `取得できませんでした: ${err}`);
   }
 }
diff --git a/src/styles.css b/src/styles.css
index a4b5638..421f41b 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -326,12 +326,27 @@ body {
   white-space: nowrap;
 }
 
-/* The name this screen posts under. Colour alone would say it, but only to
-   someone who already knows which colour is theirs. */
-#participants .self {
+/* What a line says about itself beyond the name: 「（あなた）」 for the name
+   this screen posts under, 「未起動」 for an account with no session in the
+   room. Colour alone would say the first of those, but only to someone who
+   already knows which colour is theirs. */
+#participants .note {
   color: var(--muted);
 }
 
+/* An account that exists but is not in the room. Dimmed rather than dropped:
+   it is still someone, and this list is where the person reads who they have
+   (#53). It is not an addressee — that list comes from the room's roster, so
+   an offline account cannot appear in it at all. */
+#participants .roster li.offline .who {
+  color: var(--muted);
+}
+
+#participants .roster li.offline .dot {
+  background: none;
+  border: 1px solid var(--speaker, var(--line));
+}
+
 #participants .empty {
   padding: 0.45rem 0.9rem;
   color: var(--muted);
@@ -394,9 +409,9 @@ 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. */
+/* The name and colour of the selected account. The same pair the titlebar
+   carries for this screen's person — the person declares theirs at the moment
+   of joining, and an account carries its own whether or not it is running. */
 #launcher .who {
   display: flex;
   align-items: center;
@@ -437,6 +452,14 @@ body {
   cursor: pointer;
 }
 
+/* Add and remove an account. Square and unlabelled beside the picker they act
+   on, so the row keeps its width for the working directory. */
+#launcher #account-new,
+#launcher #account-delete {
+  padding: 0.25rem 0.5rem;
+  line-height: 1;
+}
+
 #launcher button:disabled {
   cursor: default;
   opacity: 0.6;