diff --git a/docs/0-requirements.md b/docs/0-requirements.md
index 7f0bb34..9f8ade6 100644
--- a/docs/0-requirements.md
+++ b/docs/0-requirements.md
@@ -6,6 +6,17 @@
 
 アプリが持つのは**部屋の壁だけ**である。機能・ツール・認証・MCP は各 CLI がそのまま持ち、アプリはそれらを内包しない。各セッションの文脈と人格は独立したまま保たれ、発言者を識別できる共通の場で対話する。
 
+### 投稿モデル
+
+この場は AI と話すための場所ではない。人間も AI も区別なくやり取りできる場所であり、チャットよりも掲示板に近い。
+
+- **参加者はひと種類である。** 人間もセッションも同じ参加者であり、違いは名前だけである。名簿は両者を同じ列に並べる。
+- **発言はひとつの行為である。** 誰が出しても同じフレームで、同じ経路を通り、全員へ配られる。発言者ごとに別の行為を用意しない。
+- **自分の発言は自分へ戻らない。** 抑止は接続の同一性で判定する。名前で判定すると、名前が衝突している間は他人の発言まで落ちる。
+- **宛先は誰でも名指せる。** 人間も宛先の選択肢に並ぶ。宛先は配送を絞らない（constraints の「単一ベンダー構成」参照）。
+
+この前提は後付けではない。当初のプロトコルは人間の発言を `say`、AI の発言を `reply` として別の行為に分けており、`reply` にはそもそも他の参加者へ配る線が引かれていなかった。並列に立てた 2 セッションが互いの発言を受け取らないという実測（2026-08-22）はその帰結であり、配送行の書き忘れではなく語の形の問題だった。統一フレーム `post` はこの是正である（#39）。
+
 狙いは `Liplus-Project/liplus-language` が自ら未達と記している基盤層である。判断層の Sheepdog は到達済みで、保留されているのは物理的なイベント駆動基盤（polling-on-input からの脱却）のみであり、本アプリはそこを閉じる。
 
 設計母体は `Liplus-Project/liplus-desktop` #90。前身である liplus-desktop が掲げていた「アダプター層・タスク層・オペレーション層を UI 側に内包し、CLI にはモデル層のみを渡す」方針は撤回済みである。Li+ の L6 Adapter Layer は基盤を所有しないための層であり、内包はその反転にあたる。
@@ -88,13 +99,15 @@ liplus-chat (Tauri app)  =  部屋の壁
 ### 会話ループ
 
 ```
-[人間の発言] → 部屋 → MCP サーバ
+[参加者の発言] → 部屋 →（発言者以外の全サイドカーへ fan-out）
                          ↓ notifications/claude/channel
                     [CLI 対話セッション（PTY 保持）]
                          ↓ MCP tool 呼び出し
-                    MCP サーバ → 部屋 → [メッセージ一覧へ追加]
+                    MCP サーバ → 部屋 → [メッセージ一覧へ追加＋他の参加者へ fan-out]
 ```
 
+人間が発言しても、セッションが発言しても、通る経路は同じ 1 本である。部屋の中に「人間の発言を処理する道」と「AI の発言を処理する道」は無い。
+
 push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/index.ts` に準拠）:
 
 - method = `notifications/claude/channel`
@@ -115,15 +128,21 @@ push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/in
 
 | 向き | type | フィールド |
 |---|---|---|
-| 部屋 → サイドカー | `say` | `message_id` / `user` / `content` / `to`（任意） / `ts` |
-| サイドカー → 部屋 | `hello` | `protocol` / `agent` |
-| サイドカー → 部屋 | `reply` | `message_id` / `agent` / `content` / `to`（任意） / `ts` |
+| サイドカー → 部屋 | `hello` | `protocol` / `name` |
+| サイドカー → 部屋 | `post` | `message_id` / `content` / `to`（任意） / `ts` |
+| 部屋 → サイドカー | `post` | `message_id` / `speaker` / `content` / `to`（任意） / `ts` |
+
+発言のフレームは `post` 一種類であり、向きによって名前が変わらない。誰が出した発言かはフレームの種別ではなく `speaker` の値で表す。
+
+`speaker` はサイドカーが送らない。部屋が、フレームの届いた接続に紐づく名前（`hello` の `name`）から刻む。送信側が名乗れる欄を持たないため、他の参加者を騙る余地が構造上無く、名簿と表示が食い違うこともない。宛先は名指せるが自分は名乗れない、という非対称がこの性質を作っている。
+
+未知の `type` は拒否せず無視する。部屋側がフレーム種別を増やしても、旧サイドカーが壊れないため。`protocol` はフレームの形が変わり、サイドカー側が気づく必要があるときに上げる。`say` / `reply` から `post` への統合で `protocol` を 2 へ上げた。サイドカーはアプリが `.mcp.json` へ書く同梱パスから起動するため、部屋とサイドカーの版が食い違う形が構造上無く、旧フレームとの互換は残していない。
 
-未知の `type` は拒否せず無視する。部屋側がフレーム種別を増やしても、旧サイドカーが壊れないため。`protocol` はフレームの形が変わり、サイドカー側が気づく必要があるときに上げる。
+`to` は両方向で同じ語彙であり、宛先となる参加者の表示名を入れる。任意であり、無いときは `null` ではなくキーごと省く。
 
-`to` は両方向で同じ語彙であり、宛先となる参加者の表示名を入れる。任意であり、無いときは `null` ではなくキーごと省く。`to` の追加で `protocol` は上げていない。サイドカーはアプリが `.mcp.json` へ書く同梱パスから起動するため、部屋とサイドカーの版が食い違う形が構造上無い。
+**自分の発言の抑止**は部屋側で行う。部屋は接続ごとに origin を採番し、fan-out のときにその発言を出した接続だけを飛ばす。origin はフレームの外側をタグとして流れ、wire には出ない。したがって送信側は自分の origin を設定することも他人の origin を騙ることもできない。名前で判定しないのは、名前が衝突している間に他の参加者の発言まで落ちるためである（#40）。サイドカー側に自己判定は置かない。
 
-人間の発言も、エージェントの返信も、フロントエンドへは同一の `room-message` イベントとして届く。並び順の権威を 1 箇所に保つためであり、送信時にフロント側でローカルに追記しない。
+どの参加者の発言も、フロントエンドへは同一の `room-message` イベントとして届く。並び順の権威を 1 箇所に保つためであり、送信時にフロント側でローカルに追記しない。イベントは `own`（自分の発言かどうか）を伴う。表示上の区別を残す場合の軸はこれであり、人間か AI かではない。
 
 ### サイドカーの起動形
 
@@ -141,9 +160,12 @@ push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/in
 判定材料（`meta.to`）と判定規律（`instructions`）は同時に変える。片方だけ動かすと、宛先を知らないまま宛先を判断させる状態になる。
 
 - サイドカーは自分の部屋での名前（`LIPLUS_AGENT_NAME`）を `instructions` へ埋め込む。埋めなければエージェントは `meta.to` を自分と照合できない。
+- `instructions` は「人間と AI を区別しない」ことを明示する。区別しない前提はフレームだけでなく作法にも要る。フレームから区別を消しても、作法が「人間に答えよ」と言っていれば、エージェントはもう無い区別を読むことになる。
 - `meta.to` が自分の名前なら自分宛、他の参加者の名前なら自分宛ではない、無ければ部屋全体宛。全体宛に誰が答えるかはエージェントの判断に委ねる。
 - 宛先による配送の絞り込みはアプリ側で行わない。部屋は全員へ配り、答えるかどうかをエージェントが決める。絞れば部屋が「誰に届いたか」を持つことになり、アプリが会話の中身へ関与し始める。
 - 宛先は任意である。必須にすると人間の入力費用が上がる。
+- 宛先の相手は人間でもセッションでもよく、指定の仕方は変わらない。画面の宛先の選択肢は「自分以外の参加者」であり、人間も同じ列に並ぶ。
+- 届いた発言はすべて他の参加者のものである。自分の発言は戻らないため、エージェントは自分を認識する必要がない。
 
 ### MCP サーバの実装方式
 
@@ -171,8 +193,9 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 - 部屋ソケット（Rust、`127.0.0.1` 任意ポート、Bearer トークン必須）
 - サーバの `.mcp.json` 登録（既存内容はマージして保持）と、成立条件を満たす CLI 起動フラグの適用
 - 部屋の作法（`instructions`）の初版
-- 発言の宛先（部屋 → `say.to` → channel の `meta.to`、返信は `say_to_room` の `to`）と、それを判定材料として名指しする `instructions`
-- チャットルーム UI（メッセージ一覧、発言者表示、入力欄、参加者表示）
+- 発言の宛先（部屋 → `post.to` → channel の `meta.to`、送信は `say_to_room` の `to`）と、それを判定材料として名指しする `instructions`
+- 参加者モデル（統一 `post` フレーム、発言者以外の全参加者への配送、接続同一性による自分の発言の抑止、人間を含む名簿）
+- チャットルーム UI（メッセージ一覧、発言者表示、入力欄、参加者表示、自分以外の参加者から選ぶ宛先）
 - 診断面（部屋ソケットの待受状態、セッションの生死と終了コード、CLI の端末表示と入力）
 - Windows CI（`npm ci` と Rust コンパイル確認）、Release 公開時の CD
 
@@ -185,7 +208,7 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 ### 未実装
 
-- 複数の AI セッションを同一の部屋へ参加させる運用（同時発話の抑制を含む）
+- 複数の AI セッションを同一の部屋へ参加させる運用（同時発話の抑制を含む）。参加者間で発言が届く経路は実装済みだが、実機での往復はまだ確認していない。2026-08-22 の実測（2 セッションが互いの発言を受け取らない）は #39 の修正前のものであり、修正後の再計測は済んでいない。
 - 会話ログの永続化と観測 UI
 - plugin としての allowlist 掲載（配布の第二段階）
 
@@ -252,7 +275,7 @@ CI が実行するもの:
 
 1. **部屋ソケットが待ち受けているか。** タイトルバーの「診断」を開き、部屋ソケットの行を見る。`127.0.0.1:<port> で待受中` でなければ以降はすべて不成立。
 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` がある場合、セッション起動はエラーで止まる（黙って外すと動いたように見えるため）。
diff --git a/index.html b/index.html
index a7c563c..257daf5 100644
--- a/index.html
+++ b/index.html
@@ -60,9 +60,10 @@
 
       <footer id="composer">
         <!-- The addressee is optional. Leaving it on 全体 is a room-wide
-             utterance; who answers one of those is the agents' judgment, not
-             the room's. The room delivers every utterance to everyone either
-             way. -->
+             utterance; who answers one of those is the participants'
+             judgment, not the room's. The room delivers every utterance to
+             everyone either way, and anyone in the roster can be named —
+             people and sessions alike. -->
         <label class="to">
           宛先
           <select id="to-select">
diff --git a/sidecar/src/index.ts b/sidecar/src/index.ts
index 7cd2537..d688cc8 100644
--- a/sidecar/src/index.ts
+++ b/sidecar/src/index.ts
@@ -15,8 +15,11 @@
  *                     port or the launch moment from its own side.
  *
  * Direction of travel:
- *   room says     -> WebSocket frame -> channel notification -> agent reacts
- *   agent replies -> `say_to_room` tool -> WebSocket frame -> the room
+ *   someone posts -> WebSocket frame -> channel notification -> agent reacts
+ *   this agent posts -> `say_to_room` tool -> WebSocket frame -> the room
+ *
+ * Both directions carry the same frame. A person and a session are both
+ * participants of the room, and what separates them is a name (#39).
  *
  * The CLI terminal output is never read as a message source. stdout belongs to
  * the MCP transport; every log line goes to stderr.
@@ -31,11 +34,11 @@ import WebSocket from "ws";
 import { randomUUID } from "node:crypto";
 
 const ROOM_URL = process.env.LIPLUS_ROOM_URL ?? "";
-const AGENT_NAME = process.env.LIPLUS_AGENT_NAME ?? "agent";
+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 = 1;
+const PROTOCOL_VERSION = 2;
 
 function log(line: string): void {
   process.stderr.write(`[liplus-chat sidecar] ${line}\n`);
@@ -43,24 +46,33 @@ function log(line: string): void {
 
 // ── Room frames ──────────────────────────────────────────────────────────────
 //
-// Room -> sidecar:
-//   { type: "say",   message_id, user, content, to?, ts }
 // Sidecar -> room:
-//   { type: "hello", protocol, agent }
-//   { type: "reply", message_id, agent, content, to?, ts }
+//   { type: "hello", protocol, name }
+//   { type: "post",  message_id, content, to?, ts }
+// Room -> sidecar:
+//   { type: "post",  message_id, speaker, content, to?, ts }
+//
+// One frame kind carries speech, whoever produced it. The room stamps
+// `speaker` from the connection the frame arrived on, so this side does not
+// send it: a participant names an addressee, never itself.
 //
 // `to` is optional in both directions and means the same thing on each: the
-// display name of the participant addressed. The room fans every frame out to
+// display name of the participant addressed. The room fans every post out to
 // everyone regardless — whether an utterance is yours to answer is decided
 // here, by the agent, not by the room narrowing its delivery.
 //
+// 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
+// post (#40).
+//
 // Frames whose `type` is unknown are ignored rather than rejected, so the room
 // can add frame kinds without breaking a sidecar built against this revision.
 
-interface SayFrame {
-  type: "say";
+interface PostFrame {
+  type: "post";
   message_id?: string;
-  user?: string;
+  speaker?: string;
   content?: string;
   to?: string;
   ts?: string;
@@ -72,8 +84,12 @@ const INSTRUCTIONS = [
   "あなたは liplus-chat の部屋に参加しています。",
   `この部屋でのあなたの名前は「${AGENT_NAME}」です。`,
   "",
+  "この部屋は、人間と AI を区別しません。参加者は全員が同じ参加者であり、",
+  "違いは名前だけです。発言もひとつの行為で、誰が出しても同じ形で届きます。",
+  "相手が人間か別のセッションかを気にする必要はありません。",
+  "",
   '部屋の発言は <channel source="liplus-chat" ...> として届きます。',
-  "返信するときは say_to_room ツールを呼んでください。ターミナルへの出力は",
+  "発言するときは say_to_room ツールを呼んでください。ターミナルへの出力は",
   "部屋には届きません。",
   "",
   "宛先:",
@@ -82,9 +98,11 @@ const INSTRUCTIONS = [
   "- meta.to が他の参加者の名前なら、あなた宛ではありません。黙ってください。",
   "  補足したくなっても割り込まないでください。",
   "- meta.to が無い発言は部屋全体宛です。自分が答えるべきときだけ答えてください。",
-  "- say_to_room の to 引数で、こちらからも宛先を指定できます。",
+  "- say_to_room の to 引数で、こちらからも宛先を指定できます。宛先には",
+  "  人間の参加者も指定できます。指定の仕方は相手によって変わりません。",
   "",
   "部屋の作法:",
+  "- 自分の発言は返ってきません。届いた発言はすべて他の参加者のものです。",
   "- 返信しない判断は正当です。全員が答えると部屋は読めなくなります。",
   "- 一度の発言は簡潔に。長い説明が必要なときは、まず要点だけ返してください。",
   "- 他の参加者の発言を、自分の文脈として取り込まないでください。それぞれが",
@@ -148,10 +166,11 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 
   const to = typeof args?.to === "string" ? args.to : undefined;
+  // No speaker field: the room stamps that from this connection. Sending one
+  // would be a claim about who is speaking, and the room would overwrite it.
   const sent = sendToRoom({
-    type: "reply",
+    type: "post",
     message_id: randomUUID(),
-    agent: AGENT_NAME,
     content,
     ...(to ? { to } : {}),
     ts: new Date().toISOString(),
@@ -202,11 +221,14 @@ function sendToRoom(frame: Record<string, unknown>): boolean {
   }
 }
 
-function pushToChannel(frame: SayFrame): void {
+function pushToChannel(frame: PostFrame): void {
   const content = frame.content ?? "";
   if (!content) return;
 
-  const user = frame.user ?? "someone";
+  // `speaker` on the room's wire, `user` in the channel meta: the latter is
+  // the host's key and the host renders it, so the name is translated at this
+  // boundary rather than the room's frame being bent to the host's vocabulary.
+  const speaker = frame.speaker ?? "someone";
   // The addressee rides in meta for the same reason the speaker does: the body
   // must stay equal to what was said. It is judgment material, not text — the
   // instructions tell the agent to read it and decide whether to answer.
@@ -221,7 +243,7 @@ function pushToChannel(frame: SayFrame): void {
       meta: {
         chat_id: CHAT_ID,
         message_id: frame.message_id ?? randomUUID(),
-        user,
+        user: speaker,
         ...(to ? { to } : {}),
         ts: frame.ts ?? new Date().toISOString(),
       },
@@ -247,7 +269,7 @@ function connectRoom(): void {
     retryCount = 0;
     lastError = "";
     log(`room socket: connected as "${AGENT_NAME}"`);
-    sendToRoom({ type: "hello", protocol: PROTOCOL_VERSION, agent: AGENT_NAME });
+    sendToRoom({ type: "hello", protocol: PROTOCOL_VERSION, name: AGENT_NAME });
     pingTimer = setInterval(() => {
       if (socket.readyState === WebSocket.OPEN) socket.ping();
     }, PING_INTERVAL);
@@ -262,7 +284,7 @@ function connectRoom(): void {
     }
     if (typeof data !== "object" || data === null) return;
     const frame = data as { type?: string };
-    if (frame.type === "say") pushToChannel(frame as SayFrame);
+    if (frame.type === "post") pushToChannel(frame as PostFrame);
     // Unknown frame kinds are ignored on purpose; see the frame comment above.
   });
 
diff --git a/sidecar/test/round-trip.test.mjs b/sidecar/test/round-trip.test.mjs
index db003d4..d4c891b 100644
--- a/sidecar/test/round-trip.test.mjs
+++ b/sidecar/test/round-trip.test.mjs
@@ -39,7 +39,7 @@ function withTimeout(promise, label) {
   ]);
 }
 
-test("room say reaches the channel, and say_to_room reaches the room", async (t) => {
+test("a room post reaches the channel, and say_to_room reaches the room", async (t) => {
   // ── fake room ──────────────────────────────────────────────────────────────
   const http = createServer();
   const wss = new WebSocketServer({ server: http });
@@ -48,7 +48,7 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
 
   const connected = deferred();
   const helloSeen = deferred();
-  const replySeen = deferred();
+  const postSeen = deferred();
   let roomSocket = null;
 
   wss.on("connection", (socket) => {
@@ -57,7 +57,7 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
     socket.on("message", (raw) => {
       const frame = JSON.parse(raw.toString());
       if (frame.type === "hello") helloSeen.resolve(frame);
-      if (frame.type === "reply") replySeen.resolve(frame);
+      if (frame.type === "post") postSeen.resolve(frame);
     });
   });
 
@@ -152,7 +152,7 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
   assert.match(
     init.result.instructions ?? "",
     /say_to_room/,
-    "instructions must name the reply tool",
+    "instructions must name the posting tool",
   );
   // The manners and the material they are judged on ship together. Manners
   // that say "answer what is addressed to you" without naming where the
@@ -168,6 +168,14 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
     /test-agent/,
     "instructions must tell the agent the name it answers to",
   );
+  // The model lives in the manners as much as in the frames. An agent told to
+  // answer "the human" would be reading a distinction the protocol no longer
+  // carries (#39).
+  assert.match(
+    init.result.instructions ?? "",
+    /人間と AI を区別しません/,
+    "instructions must state that participants are not split into human and AI",
+  );
 
   notify("notifications/initialized", {});
 
@@ -175,20 +183,20 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
   assert.deepEqual(
     tools.result.tools.map((tool) => tool.name),
     ["say_to_room"],
-    "exactly one reply tool is exposed",
+    "exactly one posting tool is exposed",
   );
 
   // ── room -> agent ──────────────────────────────────────────────────────────
   await withTimeout(connected.promise, "sidecar to connect to the room");
   const hello = await withTimeout(helloSeen.promise, "hello frame");
-  assert.equal(hello.agent, "test-agent");
-  assert.equal(hello.protocol, 1);
+  assert.equal(hello.name, "test-agent");
+  assert.equal(hello.protocol, 2);
 
   roomSocket.send(
     JSON.stringify({
-      type: "say",
+      type: "post",
       message_id: "m-1",
-      user: "Master",
+      speaker: "Master",
       content: "聞こえる？",
       ts: "2026-08-21T00:00:00.000Z",
     }),
@@ -212,9 +220,9 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
   // ── the addressee rides through to the agent ───────────────────────────────
   roomSocket.send(
     JSON.stringify({
-      type: "say",
+      type: "post",
       message_id: "m-2",
-      user: "Master",
+      speaker: "Master",
       content: "リンだけ答えて",
       to: "test-agent",
       ts: "2026-08-21T00:00:01.000Z",
@@ -231,9 +239,9 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
   // agent decides. Filtering here would put "who heard it" in the room.
   roomSocket.send(
     JSON.stringify({
-      type: "say",
+      type: "post",
       message_id: "m-3",
-      user: "Master",
+      speaker: "Master",
       content: "レイはどう思う",
       to: "other-agent",
       ts: "2026-08-21T00:00:02.000Z",
@@ -243,17 +251,44 @@ test("room say reaches the channel, and say_to_room reaches the room", async (t)
   const elsewhere = await nextNotification("notifications/claude/channel", 2);
   assert.equal(elsewhere.params.meta.to, "other-agent");
 
-  // ── agent -> room ──────────────────────────────────────────────────────────
+  // ── this participant -> room ───────────────────────────────────────────────
   const call = await request("tools/call", {
     name: "say_to_room",
     arguments: { content: "聞こえてるわ", to: "Master" },
   });
   assert.ok(!call.result.isError, `tool call failed: ${JSON.stringify(call.result)}`);
 
-  const reply = await withTimeout(replySeen.promise, "reply frame");
-  assert.equal(reply.agent, "test-agent");
-  assert.equal(reply.content, "聞こえてるわ");
-  assert.equal(reply.to, "Master");
+  const post = await withTimeout(postSeen.promise, "post frame");
+  assert.equal(post.type, "post");
+  assert.equal(post.content, "聞こえてるわ");
+  // A person is addressed exactly like a session. One vocabulary, one frame.
+  assert.equal(post.to, "Master");
+  // Attribution belongs to the room, stamped from the connection. A sender
+  // that could name itself could name somebody else.
+  assert.equal(
+    "speaker" in post,
+    false,
+    "a posting participant must not name itself; the room stamps the speaker",
+  );
+
+  // ── suppression is the room's, and is not decided by name ─────────────────
+  // The room drops a post on the connection that produced it, so this side
+  // never has to recognise itself. It must not second-guess that with a name
+  // test: while two participants share a name, a name test here would swallow
+  // the other one's posts too (#40).
+  roomSocket.send(
+    JSON.stringify({
+      type: "post",
+      message_id: "m-4",
+      speaker: "test-agent",
+      content: "同じ名前の別参加者",
+      ts: "2026-08-21T00:00:03.000Z",
+    }),
+  );
+
+  const sameName = await nextNotification("notifications/claude/channel", 3);
+  assert.equal(sameName.params.meta.message_id, "m-4");
+  assert.equal(sameName.params.meta.user, "test-agent");
 
   // ── a dropped frame must not read as delivered ─────────────────────────────
   roomSocket.close();
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 5d85030..9661425 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -38,8 +38,9 @@ pub fn run() {
             config::save_sessions,
             config::load_sessions,
             room::room_port,
-            room::room_agents,
-            room::room_say,
+            room::room_participants,
+            room::room_join,
+            room::room_post,
             session::parse_launch_options,
             session::preview_launch_args,
             session::start_session,
diff --git a/src-tauri/src/room.rs b/src-tauri/src/room.rs
index 48efa78..90fdf0a 100644
--- a/src-tauri/src/room.rs
+++ b/src-tauri/src/room.rs
@@ -6,14 +6,23 @@
 //!
 //! Frames on the wire are the room protocol:
 //!
-//!   room    -> sidecar : { type: "say",   message_id, user, content, to?, ts }
-//!   sidecar -> room    : { type: "hello", protocol, agent }
-//!                        { type: "reply", message_id, agent, content, to?, ts }
+//!   sidecar -> room : { type: "hello", protocol, name }
+//!   both ways       : { type: "post", message_id, speaker, content, to?, ts }
 //!
-//! `to` is optional in both directions and carries the same vocabulary: the
-//! display name of the participant addressed. The room still fans every frame
-//! out to every sidecar — narrowing delivery here would make the room hold who
-//! heard what, and answering is the agent's judgment, not the room's.
+//! One frame kind carries speech, whoever produced it. A person and a session
+//! are both participants; what separates them is a name, not a frame. The
+//! earlier protocol had `say` for a person and `reply` for a session, and only
+//! `say` was ever fanned out — the asymmetry was not a missing line but the
+//! shape of the words, so the words went (#39).
+//!
+//! `to` is optional and carries the display name of the participant addressed.
+//! The room still fans every post out to every participant — narrowing
+//! delivery here would make the room hold who heard what, and answering is the
+//! participant's judgment, not the room's.
+//!
+//! `speaker` is stamped by the room from the connection the frame arrived on,
+//! never read off the frame. A sender cannot claim to be someone else, and the
+//! roster and the attribution cannot disagree.
 //!
 //! 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.
@@ -32,27 +41,54 @@ use tokio_tungstenite::tungstenite::Message;
 use uuid::Uuid;
 
 /// Bumped when a frame's shape changes in a way a sidecar must notice.
-pub const PROTOCOL_VERSION: u32 = 1;
+///
+/// 2: `say` and `reply` collapsed into one `post` frame; `agent` became `name`.
+pub const PROTOCOL_VERSION: u32 = 2;
 
-/// One line of the room, as the frontend sees it.
+/// One post of the room, as the frontend sees it.
+///
+/// Carries no participant class. What separates two lines is the name on them.
+/// `own` is a self/other axis for display, which is a property of the viewer,
+/// not of the speaker.
 #[derive(Debug, Clone, Serialize)]
 pub struct RoomMessage {
     pub message_id: String,
-    /// "human" for a person, "agent" for a session.
-    pub kind: String,
     /// Display name of the speaker.
     pub speaker: String,
     pub content: String,
     pub to: Option<String>,
     pub ts: String,
+    /// True when this screen's own participant produced it.
+    pub own: bool,
+}
+
+/// A post as it happened, before any viewer-relative framing.
+struct Post {
+    message_id: String,
+    speaker: String,
+    content: String,
+    to: Option<String>,
+    ts: String,
+}
+
+/// A post on its way out, tagged with the connection that produced it.
+///
+/// The tag rides beside the frame, never inside it: it is never serialised, so
+/// no sender can supply one and no sender can forge one. Suppression is a
+/// property of the connection, which is the one identity a name collision
+/// cannot blur (#40).
+#[derive(Clone)]
+struct Fanout {
+    origin: String,
+    frame: String,
 }
 
 #[derive(Debug, Deserialize)]
-struct AgentFrame {
+struct IncomingFrame {
     #[serde(rename = "type")]
     kind: String,
     message_id: Option<String>,
-    agent: Option<String>,
+    name: Option<String>,
     content: Option<String>,
     to: Option<String>,
     ts: Option<String>,
@@ -61,30 +97,39 @@ struct AgentFrame {
 
 struct RoomInner {
     port: Option<u16>,
-    agents: BTreeSet<String>,
+    /// 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>,
 }
 
 /// Shared handle to the room socket. Cloneable; all clones share one room.
 #[derive(Clone)]
 pub struct RoomState {
     inner: Arc<Mutex<RoomInner>>,
-    /// Frames fanned out to every connected sidecar.
-    to_agents: broadcast::Sender<String>,
+    /// Posts fanned out to every connected participant but their author.
+    to_participants: broadcast::Sender<Fanout>,
     /// Bearer token the sidecar must present. Generated per app run, handed to
     /// the sidecar through `.mcp.json` env, never written anywhere else.
     token: String,
+    /// The screen's own connection. It has no socket, so it needs an identity
+    /// minted here to sit on the same suppression axis as every other one.
+    local_origin: String,
 }
 
 impl RoomState {
     pub fn new() -> Self {
-        let (to_agents, _) = broadcast::channel(256);
+        let (to_participants, _) = broadcast::channel(256);
         RoomState {
             inner: Arc::new(Mutex::new(RoomInner {
                 port: None,
-                agents: BTreeSet::new(),
+                participants: BTreeSet::new(),
+                local_name: None,
             })),
-            to_agents,
+            to_participants,
             token: Uuid::new_v4().to_string(),
+            local_origin: Uuid::new_v4().to_string(),
         }
     }
 
@@ -96,23 +141,48 @@ impl RoomState {
         self.inner.lock().port
     }
 
-    pub fn agents(&self) -> Vec<String> {
-        self.inner.lock().agents.iter().cloned().collect()
+    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);
     }
 
-    fn add_agent(&self, name: &str) {
-        self.inner.lock().agents.insert(name.to_string());
+    fn add_participant(&self, name: &str) {
+        self.inner.lock().participants.insert(name.to_string());
     }
 
-    fn remove_agent(&self, name: &str) {
-        self.inner.lock().agents.remove(name);
+    fn remove_participant(&self, name: &str) {
+        self.inner.lock().participants.remove(name);
+    }
+
+    /// Seat this screen's person in the room under `name`, replacing an
+    /// earlier seat.
+    ///
+    /// 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 {
+        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);
+        }
+        inner.participants.insert(name.to_string());
+        inner.local_name = Some(name.to_string());
+        true
     }
 }
 
+/// Absent is the key omitted, never an empty one: a participant matching `to`
+/// against their own name must not have to rule the empty string out first.
+fn normalize_to(to: Option<String>) -> Option<String> {
+    to.map(|name| name.trim().to_string())
+        .filter(|name| !name.is_empty())
+}
+
 fn now_iso() -> String {
     // Tauri already pulls chrono-free time handling in; a plain RFC3339-ish
     // stamp from SystemTime keeps the dependency list unchanged.
@@ -146,6 +216,46 @@ fn now_iso() -> String {
     )
 }
 
+/// Put one post into the room.
+///
+/// The single path every utterance takes, whoever spoke. `origin` is the
+/// connection it arrived on: the fan-out skips that connection, and the screen
+/// reads it to know whether the line is its own. Two callers reach here — the
+/// socket loop and the screen's own command — and neither has a path of its
+/// own past this point.
+fn deliver(app: &AppHandle, room: &RoomState, origin: &str, post: Post) {
+    let mut frame = serde_json::json!({
+        "type": "post",
+        "message_id": post.message_id,
+        "speaker": post.speaker,
+        "content": post.content,
+        "ts": post.ts,
+    });
+    // Omitted rather than null when absent.
+    if let Some(name) = &post.to {
+        frame["to"] = serde_json::Value::String(name.clone());
+    }
+
+    // No subscribers means no session has joined yet. That is not an error —
+    // the room accepts what is said in it; a later joiner simply missed it.
+    let _ = room.to_participants.send(Fanout {
+        origin: origin.to_string(),
+        frame: frame.to_string(),
+    });
+
+    let _ = app.emit(
+        "room-message",
+        RoomMessage {
+            message_id: post.message_id,
+            speaker: post.speaker,
+            content: post.content,
+            to: post.to,
+            ts: post.ts,
+            own: origin == room.local_origin,
+        },
+    );
+}
+
 /// Bind the room socket and start accepting sidecars.
 ///
 /// Port 0: the OS picks. The port is handed to sidecars through `.mcp.json`,
@@ -173,8 +283,8 @@ pub async fn start(app: AppHandle, room: RoomState) -> Result<u16, String> {
             let app = app.clone();
             let room = room.clone();
             tokio::spawn(async move {
-                if let Err(err) = serve_agent(app, room, stream).await {
-                    eprintln!("[room] agent connection ended: {err}");
+                if let Err(err) = serve_participant(app, room, stream).await {
+                    eprintln!("[room] participant connection ended: {err}");
                 }
             });
         }
@@ -183,7 +293,7 @@ pub async fn start(app: AppHandle, room: RoomState) -> Result<u16, String> {
     Ok(port)
 }
 
-async fn serve_agent(
+async fn serve_participant(
     app: AppHandle,
     room: RoomState,
     stream: tokio::net::TcpStream,
@@ -212,27 +322,40 @@ async fn serve_agent(
         .map_err(|e| format!("handshake failed: {e}"))?;
     let (mut sink, mut source) = ws.split();
 
-    let mut from_room = room.to_agents.subscribe();
+    // This connection's identity, minted here. Nothing the far side sends can
+    // set it or read it, so nothing the far side sends can wear another
+    // participant's suppression or shed its own.
+    let origin = Uuid::new_v4().to_string();
+
+    let mut from_room = room.to_participants.subscribe();
+    let own_origin = origin.clone();
     let pump = tokio::spawn(async move {
-        while let Ok(frame) = from_room.recv().await {
-            if sink.send(Message::Text(frame.into())).await.is_err() {
+        while let Ok(fanout) = from_room.recv().await {
+            // A participant does not receive their own post. Decided on the
+            // connection, never on the name: while two participants share a
+            // name, a name test drops the other one's posts too (#40).
+            if fanout.origin == own_origin {
+                continue;
+            }
+            if sink.send(Message::Text(fanout.frame.into())).await.is_err() {
                 break;
             }
         }
     });
 
-    // Known once the sidecar says hello; used to drop it from the roster.
-    let mut agent_name: Option<String> = None;
+    // Known once the participant says hello; used to attribute posts and to
+    // drop them from the roster.
+    let mut joined_as: Option<String> = None;
 
     while let Some(Ok(msg)) = source.next().await {
         let Message::Text(text) = msg else { continue };
-        let Ok(frame) = serde_json::from_str::<AgentFrame>(&text) else {
+        let Ok(frame) = serde_json::from_str::<IncomingFrame>(&text) else {
             continue;
         };
 
         match frame.kind.as_str() {
             "hello" => {
-                let name = frame.agent.unwrap_or_else(|| "agent".to_string());
+                let name = frame.name.unwrap_or_else(|| "session".to_string());
                 if frame.protocol != Some(PROTOCOL_VERSION) {
                     // Legible mismatch beats a silent half-working room.
                     eprintln!(
@@ -240,33 +363,37 @@ async fn serve_agent(
                         frame.protocol
                     );
                 }
-                room.add_agent(&name);
-                agent_name = Some(name);
-                let _ = app.emit("room-agents", room.agents());
+                room.add_participant(&name);
+                joined_as = Some(name);
+                let _ = app.emit("room-participants", room.participants());
             }
-            "reply" => {
-                let speaker = frame
-                    .agent
-                    .or_else(|| agent_name.clone())
-                    .unwrap_or_else(|| "agent".to_string());
-                let message = RoomMessage {
-                    message_id: frame.message_id.unwrap_or_else(|| Uuid::new_v4().to_string()),
-                    kind: "agent".to_string(),
-                    speaker,
-                    content: frame.content.unwrap_or_default(),
-                    to: frame.to,
-                    ts: frame.ts.unwrap_or_else(now_iso),
-                };
-                let _ = app.emit("room-message", message);
+            "post" => {
+                // Attribution comes from the connection, not from the frame. A
+                // sender may name an addressee; it may not name itself.
+                let speaker = joined_as.clone().unwrap_or_else(|| "session".to_string());
+                deliver(
+                    &app,
+                    &room,
+                    &origin,
+                    Post {
+                        message_id: frame
+                            .message_id
+                            .unwrap_or_else(|| Uuid::new_v4().to_string()),
+                        speaker,
+                        content: frame.content.unwrap_or_default(),
+                        to: normalize_to(frame.to),
+                        ts: frame.ts.unwrap_or_else(now_iso),
+                    },
+                );
             }
             _ => {}
         }
     }
 
     pump.abort();
-    if let Some(name) = agent_name {
-        room.remove_agent(&name);
-        let _ = app.emit("room-agents", room.agents());
+    if let Some(name) = joined_as {
+        room.remove_participant(&name);
+        let _ = app.emit("room-participants", room.participants());
     }
     Ok(())
 }
@@ -279,20 +406,41 @@ pub fn room_port(state: tauri::State<RoomState>) -> Option<u16> {
 }
 
 #[tauri::command]
-pub fn room_agents(state: tauri::State<RoomState>) -> Vec<String> {
-    state.agents()
+pub fn room_participants(state: tauri::State<RoomState>) -> Vec<String> {
+    state.participants()
 }
 
-/// Post a human utterance into the room.
+/// Seat this screen's person in the room under `name`.
 ///
-/// The message is echoed back to the frontend through the same `room-message`
-/// event the agents' replies use, so the room has one ordering authority
-/// rather than two.
+/// 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.
 #[tauri::command]
-pub fn room_say(
+pub fn room_join(
     app: AppHandle,
     state: tauri::State<RoomState>,
-    user: String,
+    name: String,
+) -> 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 _ = app.emit("room-participants", state.participants());
+    }
+    Ok(())
+}
+
+/// Post this screen's person's utterance into the room.
+///
+/// Goes through `deliver` like every other post: same frame, same fan-out,
+/// same event. The screen does not append locally on send, so the room keeps
+/// one ordering authority rather than two.
+#[tauri::command]
+pub fn room_post(
+    app: AppHandle,
+    state: tauri::State<RoomState>,
+    speaker: String,
     content: String,
     to: Option<String>,
 ) -> Result<String, String> {
@@ -301,41 +449,28 @@ pub fn room_say(
         return Err("content is empty".to_string());
     }
 
-    // Absent is the key omitted, never an empty one: an agent matching `to`
-    // against its own name must not have to rule "" out first. Normalising
-    // here keeps that shape a property of the room rather than of its callers.
-    let to = to
-        .map(|name| name.trim().to_string())
-        .filter(|name| !name.is_empty());
-
-    let message_id = Uuid::new_v4().to_string();
-    let ts = now_iso();
-
-    let mut frame = serde_json::json!({
-        "type": "say",
-        "message_id": message_id,
-        "user": user,
-        "content": content,
-        "ts": ts,
-    });
-    // Omitted rather than null when absent, matching the `reply` direction.
-    if let Some(name) = &to {
-        frame["to"] = serde_json::Value::String(name.clone());
+    let speaker = speaker.trim().to_string();
+    if speaker.is_empty() {
+        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) {
+        let _ = app.emit("room-participants", state.participants());
     }
 
-    // No subscribers means no session has joined yet. That is not an error —
-    // the room accepts what is said in it; a later joiner simply missed it.
-    let _ = state.to_agents.send(frame.to_string());
-
-    let _ = app.emit(
-        "room-message",
-        RoomMessage {
+    let message_id = Uuid::new_v4().to_string();
+    let local_origin = state.local_origin.clone();
+    deliver(
+        &app,
+        &state,
+        &local_origin,
+        Post {
             message_id: message_id.clone(),
-            kind: "human".to_string(),
-            speaker: user,
+            speaker,
             content,
-            to,
-            ts,
+            to: normalize_to(to),
+            ts: now_iso(),
         },
     );
 
diff --git a/src/main.ts b/src/main.ts
index 8d3738d..2955083 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -1,9 +1,9 @@
 // The room surface.
 //
-// Messages arrive on one event (`room-message`) whether a human or an agent
-// spoke, so the room has a single ordering authority. A human utterance is not
-// appended locally on send — it comes back through the same event the agents'
-// replies do. See src-tauri/src/room.rs.
+// Everyone in the room is a participant, and a post is one act whoever made it
+// (#39). Messages arrive on one event (`room-message`) either way, so the room
+// has a single ordering authority; what is typed here is not appended locally
+// on send but comes back through that same event. See src-tauri/src/room.rs.
 //
 // The diagnostics pane carries a real terminal for the launched CLI. That is a
 // display, not a message source: the room's lines come from the channel and
@@ -19,12 +19,13 @@ import "@xterm/xterm/css/xterm.css";
 
 interface RoomMessage {
   message_id: string;
-  /** "human" or "agent". */
-  kind: string;
   speaker: string;
   content: string;
   to: string | null;
   ts: string;
+  /** True when this screen's own participant posted it. Self/other, not
+   *  human/AI: the room no longer carries that axis. */
+  own: boolean;
 }
 
 interface TabConfig {
@@ -66,8 +67,8 @@ const optionsEl = document.getElementById("launch-options") as HTMLInputElement;
 const previewEl = document.getElementById("launch-preview") as HTMLElement;
 
 let tabs: TabConfig[] = [];
-/** Who is in the room, as the addressee list is drawn from. */
-let agents: string[] = [];
+/** Everyone in the room, this screen's person included. */
+let participants: string[] = [];
 /** The session the terminal is attached to, once one is running. */
 let activePtyId: string | null = null;
 
@@ -154,7 +155,7 @@ function appendMessage(message: RoomMessage): void {
 
   const line = document.createElement("article");
   line.className = "message";
-  line.dataset.kind = message.kind;
+  line.dataset.own = message.own ? "true" : "false";
 
   const head = document.createElement("div");
   head.className = "meta";
@@ -188,22 +189,48 @@ function appendMessage(message: RoomMessage): void {
 }
 
 function renderRoster(joined: string[]): void {
-  agents = joined;
+  participants = joined;
   rosterEl.textContent = joined.length ? joined.join(" / ") : "参加者なし";
   renderAddressees();
 }
 
+/** The name this screen posts under, and is listed in the roster under. */
+function localName(): string {
+  return nameEl.value.trim() || "human";
+}
+
+/**
+ * Take a seat in the room under the current name.
+ *
+ * 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.
+ */
+async function join(): Promise<void> {
+  try {
+    await invoke("room_join", { name: localName() });
+  } catch {
+    // Failing to seat is not worth interrupting anything: the first post
+    // seats the name anyway.
+  }
+}
+
 /**
  * Redraw the addressee list from the roster.
  *
- * The names have to be the ones the agents answer to, so they come from the
+ * The names have to be the ones participants answer to, so they come from the
  * roster rather than being typed: a mistyped addressee is an utterance
  * addressed to nobody, and nothing on screen would say so. A chosen addressee
  * survives a roster change while that participant is still present, and falls
  * back to the whole room when they leave.
+ *
+ * Everyone but oneself is addressable — sessions and people alike, since the
+ * roster no longer separates them.
  */
 function renderAddressees(): void {
   const chosen = toEl.value;
+  const mine = localName();
+  const addressable = participants.filter((name) => name !== mine);
   toEl.replaceChildren();
 
   const everyone = document.createElement("option");
@@ -211,27 +238,27 @@ function renderAddressees(): void {
   everyone.textContent = "全体";
   toEl.appendChild(everyone);
 
-  for (const agent of agents) {
+  for (const participant of addressable) {
     const option = document.createElement("option");
-    option.value = agent;
-    option.textContent = agent;
+    option.value = participant;
+    option.textContent = participant;
     toEl.appendChild(option);
   }
 
-  toEl.value = agents.includes(chosen) ? chosen : "";
+  toEl.value = addressable.includes(chosen) ? chosen : "";
 }
 
 async function send(): Promise<void> {
   const content = inputEl.value.trim();
   if (!content) return;
 
-  const user = nameEl.value.trim() || "human";
+  const speaker = localName();
   // Empty means the room as a whole. The app still delivers to everyone; the
-  // addressee is judgment material for the agents, not a delivery filter.
+  // addressee is judgment material for the participants, not a delivery filter.
   const to = toEl.value || null;
   inputEl.value = "";
   try {
-    await invoke<string>("room_say", { user, content, to });
+    await invoke<string>("room_post", { speaker, content, to });
     status("");
   } catch (err) {
     // Put the text back rather than losing what was typed.
@@ -377,7 +404,10 @@ async function main(): Promise<void> {
 
   nameEl.value = localStorage.getItem(NAME_KEY) ?? "human";
   nameEl.addEventListener("change", () => {
-    localStorage.setItem(NAME_KEY, nameEl.value.trim() || "human");
+    localStorage.setItem(NAME_KEY, localName());
+    // 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());
   });
 
   toggleEl.addEventListener("click", () => {
@@ -390,7 +420,7 @@ async function main(): Promise<void> {
   });
 
   await listen<RoomMessage>("room-message", (event) => appendMessage(event.payload));
-  await listen<string[]>("room-agents", (event) => renderRoster(event.payload));
+  await listen<string[]>("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));
@@ -435,7 +465,8 @@ async function main(): Promise<void> {
   }
 
   try {
-    renderRoster(await invoke<string[]>("room_agents"));
+    await join();
+    renderRoster(await invoke<string[]>("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 beb30e2..8ff8ff1 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -116,9 +116,11 @@ body {
   padding-left: 0.7rem;
 }
 
-/* Speaker attribution is the load-bearing distinction in this room, so the
-   two kinds are separated by colour as well as by name. */
-.message[data-kind="human"] {
+/* 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 self vs other: the room carries no human/AI distinction, and a
+   colour drawn on one would be reading a line that is no longer there (#39). */
+.message[data-own="true"] {
   border-left-color: var(--accent);
 }