diff --git a/README.md b/README.md
index 429eace..3464c11 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,9 @@ Pullcept は、人間と複数の独立した AI / Li+ セッションが、一
 - 部屋ソケット（`127.0.0.1` の任意ポート、Bearer トークン必須）
 - `.mcp.json` への登録と、channel が成立する条件を満たした CLI 起動
 - メッセージ一覧・発言者表示・入力欄を備えたチャットルーム UI
-- 部屋のログ（`logs/main.jsonl` への追記）と、それを会話面の左の列に並べる履歴
+- 部屋のログ（`logs/main/{トピック}.jsonl` への追記と `logs/main/index.json` の索引）と、会話面の左の列に並ぶトピックの一覧
+- トピックの再開。一覧から選ぶとそのトピックが部屋へ戻り、アカウントに `再開コマンド` があればそこに居た CLI セッションも戻ります
+- 参加者が自分でトピックの過去発言を引く道具（サイドカーの `read_room_history`）
 - Windows 上で `npm ci` と Rust のコンパイル確認を行う CI
 - GitHub Release 公開時に Tauri バンドルを作成する CD
 
@@ -44,7 +46,8 @@ Pullcept は、人間と複数の独立した AI / Li+ セッションが、一
 ### 未実装
 
 - 複数の AI セッションを同一の部屋へ参加させる運用（同時発話の抑制を含む）。経路は通っていますが、実機での往復は未確認です
-- 部屋のログと履歴の実機確認。追記と読み出しは実装済みで CI は通っていますが、実機での操作は未確認です
+- トピックの実機確認。区切り・再開・名前の変更・既存ログの移行はいずれも実装済みで CI は通っていますが、実機での操作は未確認です
+- `read_room_history` を実際のセッションが呼ぶところの実機確認。サイドカーのラウンドトリップテストは通っていますが、エージェントが必要な場面で自分から引くかどうかは未計測です
 - 複数の部屋。ログのパスは部屋名を位置として持ちますが、部屋そのものは一つです
 - plugin としての allowlist 掲載（配布の第二段階）
 
@@ -58,7 +61,7 @@ npm run tauri dev
 
 上の行は**参加するアカウントを選んで参加するだけ**の行です。アカウントを作る・直す・消すのは、右の「参加者」の見出しの隣にある「＋」と、各行の「編集」から開くウィンドウで行います。
 
-そのウィンドウには、名前・種別・色と、AI のアカウントなら作業ディレクトリ・起動オプションがあります。**決定を押すまで何も保存されません。** 「＋」は空のフォームを開くだけで、取消せばアカウントは作られません。編集も同じで、取消せば元のままです。削除はそのウィンドウの中にあり、二度押しです。
+そのウィンドウには、名前・種別・色と、AI のアカウントなら作業ディレクトリ・キャラクター・起動オプション・再開コマンドがあります。**決定を押すまで何も保存されません。** 「＋」は空のフォームを開くだけで、取消せばアカウントは作られません。編集も同じで、取消せば元のままです。削除はそのウィンドウの中にあり、二度押しです。
 
 「名前」と「色」は、そのアカウントが部屋で名乗る名前と、発言に付く色です。**いつでも変えられます。** 同一性は名前ではなく内部の id にあるため、改名しても稼働中のセッションの登録は追随します。色を選ばずに参加することもでき、その場合は名前から色が決まります。
 
@@ -66,6 +69,13 @@ npm run tauri dev
 
 「起動オプション」には `--dangerously-skip-permissions` のように、CLI へ渡したいオプションをそのまま書けます。アプリは部屋の channel エントリ（`server:pullcept-room-<slug>-<hash>`）をここへ統合するので、別の channel サーバを指定しても部屋の入力路は残ります。実際に起動する行はその下に表示されます。
 
+「起動オプション」と「再開コマンド」には `{session_id}` を書けます。**トピックの再開に使う組です。**
+
+- 起動オプションに書くと、新しいセッションを始めるときにアプリが決めた UUID がそこへ入ります。`claude` なら `--session-id {session_id}` です。書いた場合だけ id が配られ、そのトピックに記録されます。
+- 再開コマンドは、そのトピックに記録された id へ戻る**一行まるごと**です。先頭の語が起動する command になります。`claude` なら `claude --resume {session_id}` です。
+
+どのフラグが id を運ぶかは CLI ごとに違うため、アプリはフラグを持たず、書かれた場所へ差し込みます。**どちらも空のままで構いません。** その場合そのアカウントは、開き直したトピックへ新しいセッションとして着席し、それまでに言われたことは `read_room_history` で自分から引きます。
+
 作業ディレクトリは初回だけホームディレクトリが入っているので、セッションを動かしたいディレクトリへ変更してください。
 
 右の参加者パネルは**一つのリスト**です。部屋にいる参加者と、まだ起動していないアカウント（「未起動」）が、種別ごとのグループに分かれて並びます（`user — 1` / `AI — 2` のように、件数も出ます）。名前はその参加者の色で出ます。居ない相手は色を保ったまま薄くなり、点が塗りから輪郭に変わります。自分の行には「（あなた）」が付きます。
@@ -100,6 +110,18 @@ npm run tauri dev
 
 入力欄から発言すると channel notification としてセッションへ届き、セッションが `say_to_room` を呼び返すとメッセージ一覧へ並びます。往復が成立しないときの切り分け手順は [`docs/0-requirements.md`](docs/0-requirements.md) を参照してください。
 
+### トピック
+
+会話面の左は**トピックの一覧**です。トピックは会話の記録ではなく、会話が行われる器です。一覧から選ぶとそのトピックが部屋へ戻り、続きを話せます。
+
+区切るのは「新規」だけです。アプリを起動したときも新しいトピックが開きますが、二つは独立しています——一回の起動で複数のトピックを持つことも、起動をまたいで一つのトピックを続けることもできます。何も話さずに閉じた回は一覧に残りません（最初の発言が着いた時点で記録されます）。
+
+トピック名は最初の発言の冒頭から自動で付きます。行をダブルクリックすると、その場で直せます（Enter で決定、Escape で取消）。
+
+トピックはアカウントごとに、そこに居た CLI セッションの id を持ちます。開き直して「開始」を押すと、そのアカウントに再開コマンドがあれば同じセッションが戻ります。**戻せない席があってもトピックは開きます。** 戻せなかった席は新しいセッションとして着席し、必要になったときに `read_room_history` で過去の発言を自分で引きます。部屋の側から過去を流し込むことはしません。
+
+ログは `%APPDATA%\org.liplus-project.pullcept\logs\main\` の下に、トピックごとの `.jsonl` と `index.json` として置かれます。以前の `logs\main.jsonl` は、初回の読み出しで一つのトピックとして引き継がれます（移動であり、捨てません）。
+
 ### サイドカー単体の確認
 
 ```powershell
@@ -170,6 +192,7 @@ sidecar/              部屋の MCP channel サーバ（Node）
 src/                  チャットルーム UI（TypeScript）
 src-tauri/src/        Tauri、部屋ソケット、PTY、設定・セッション保存の Rust 実装
 crates/mcp-config/    .mcp.json 登録と起動フラグ検査（tauri 非依存、テスト対象）
+crates/room-floor/    同時発話の順序付け（tauri 非依存、テスト対象）
 portable-pty-patch/   Windows 対応を含む portable-pty のローカルパッチ
 .github/workflows/    Windows CI とリリース用 CD
 ```
diff --git a/crates/mcp-config/src/lib.rs b/crates/mcp-config/src/lib.rs
index 3f72399..f118b11 100644
--- a/crates/mcp-config/src/lib.rs
+++ b/crates/mcp-config/src/lib.rs
@@ -185,6 +185,39 @@ pub fn declares_settings(args: &[String]) -> bool {
         .any(|arg| arg.split('=').next().unwrap_or(arg) == SETTINGS_FLAG)
 }
 
+/// What an account writes where the id of a CLI session goes.
+///
+/// The one thing this app knows about resuming a session is that the id is
+/// decided here rather than read back out of the CLI's output. Which flag
+/// carries it is the CLI's business, and the CLI is per-account
+/// (`Account::command`) — so the app substitutes into a line the person wrote
+/// instead of holding a flag of its own. `claude` spells the two halves
+/// `--session-id <uuid>` and `--resume <uuid>`; another CLI spells them
+/// otherwise, or not at all, and an account that writes the placeholder nowhere
+/// simply has no session id (#115, decision 4B).
+pub const SESSION_ID_PLACEHOLDER: &str = "{session_id}";
+
+/// Whether these arguments have somewhere to put a session id.
+///
+/// What decides whether one is minted at all. Minting unconditionally would
+/// hand out an id no launch passes on, and the topic would then record a
+/// session that never existed under that name.
+pub fn declares_session_id(args: &[String]) -> bool {
+    args.iter().any(|arg| arg.contains(SESSION_ID_PLACEHOLDER))
+}
+
+/// Put the session id where the account said it goes.
+///
+/// Every occurrence in every argument, and inside a larger argument as well as
+/// alone: `--session-id={session_id}` is one argument, and so is
+/// `--resume={session_id}`. Arguments naming no placeholder come through
+/// untouched.
+pub fn substitute_session_id(args: &[String], session_id: &str) -> Vec<String> {
+    args.iter()
+        .map(|arg| arg.replace(SESSION_ID_PLACEHOLDER, session_id))
+        .collect()
+}
+
 /// The character an account speaks as, or `None` when it declares none.
 ///
 /// Blank is the same state as absent. The field is a text input on the screen,
@@ -1055,4 +1088,32 @@ mod tests {
             ]
         );
     }
+    #[test]
+    fn a_session_id_is_substituted_wherever_the_account_wrote_it() {
+        let args = split_launch_options("--resume {session_id} --verbose");
+        let filled = substitute_session_id(&args, "0f5a-uuid");
+        assert_eq!(filled, vec!["--resume", "0f5a-uuid", "--verbose"]);
+    }
+
+    #[test]
+    fn a_session_id_is_substituted_inside_one_argument_too() {
+        let args = split_launch_options("--session-id={session_id}");
+        let filled = substitute_session_id(&args, "0f5a-uuid");
+        assert_eq!(filled, vec!["--session-id=0f5a-uuid"]);
+    }
+
+    #[test]
+    fn options_with_no_placeholder_declare_no_session_id() {
+        let args = split_launch_options("--dangerously-skip-permissions");
+        assert!(!declares_session_id(&args));
+        assert_eq!(substitute_session_id(&args, "0f5a-uuid"), args);
+    }
+
+    #[test]
+    fn options_naming_the_placeholder_declare_a_session_id() {
+        assert!(declares_session_id(&split_launch_options(
+            "--session-id {session_id}"
+        )));
+    }
+
 }
diff --git a/crates/room-floor/src/lib.rs b/crates/room-floor/src/lib.rs
index ee2792d..ad359b8 100644
--- a/crates/room-floor/src/lib.rs
+++ b/crates/room-floor/src/lib.rs
@@ -140,6 +140,23 @@ impl Floor {
         self.seq
     }
 
+    /// Empty the floor and start its numbering over.
+    ///
+    /// For a room changing topic: the posts of the topic being left are not the
+    /// floor of the one being entered, and leaving them would refuse the first
+    /// thing said in the new one and hand back the old one's contents as
+    /// "missed" (`room.rs`).
+    ///
+    /// The caller has seats holding `since` positions taken against the old
+    /// numbering. Every one of them is now past the end of this floor, which
+    /// reads as having seen everything rather than nothing — so the caller puts
+    /// them back to [`Floor::seq`] itself. That is the room's to do: this type
+    /// holds no seats.
+    pub fn reset(&mut self) {
+        self.seq = 0;
+        self.log.clear();
+    }
+
     /// Check the speaker against the floor and, if they are clear, put their
     /// post on it.
     ///
@@ -248,6 +265,22 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_reset_floor_admits_a_speaker_carrying_a_watermark_from_before_it() {
+        let mut floor = Floor::new();
+        floor.admit("master", 0, None, post("m-1", "Master", "前のトピック"));
+        floor.admit("claude", 0, Some("m-1"), post("c-1", "Claude", "はい"));
+
+        floor.reset();
+        assert_eq!(floor.seq(), 0);
+
+        // The watermark names a post the floor no longer holds, which resolves
+        // to position 0. An empty floor has nothing past 0, so the speaker is
+        // admitted rather than handed back a topic they have already read.
+        let admission = floor.admit("master", 0, Some("c-1"), post("m-2", "Master", "続き"));
+        assert_eq!(admitted_seq(&admission), 1);
+    }
+
     #[test]
     fn an_empty_floor_admits_the_first_speaker() {
         let mut floor = Floor::new();
diff --git a/docs/0-requirements.md b/docs/0-requirements.md
index d5f212b..14eadc5 100644
--- a/docs/0-requirements.md
+++ b/docs/0-requirements.md
@@ -68,6 +68,7 @@
 - **構想上の機能と実装済みの機能を明確に区別する。** 未実装を完成済みとして記載しない。
 - ライセンスは Apache-2.0。`portable-pty-patch/` は MIT License のコードを含む。
 - Windows を第一対象とする（ConPTY 依存）。
+- **部屋から参加者へ過去を push しない。** 席を取る前の発言は配られない（#31 / #39）。トピックの読み出しは参加者が自分から引く pull であり、この一線を動かさない。
 - 実装変更と docs 更新は同一 PR とする。
 
 ## architecture
@@ -134,6 +135,8 @@ push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/in
 | サイドカー → 部屋 | `post` | `message_id` / `content` / `to`（任意） / `ts` / `last_seen`（任意） |
 | 部屋 → サイドカー | `post` | `message_id` / `speaker` / `content` / `to`（任意） / `ts` |
 | 部屋 → サイドカー | `post_result` | `message_id` / `delivered` / `missed` |
+| サイドカー → 部屋 | `history` | `request_id` / `limit`（任意） / `before`（任意） |
+| 部屋 → サイドカー | `history_result` | `request_id` / `posts` / `has_more`、または `request_id` / `error` |
 
 発言のフレームは `post` 一種類であり、向きによって名前が変わらない。誰が出した発言かはフレームの種別ではなく `speaker` の値で表す。
 
@@ -141,7 +144,9 @@ push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/in
 
 `post_result` は投稿への返答であり、投稿した接続にのみ返す。fan-out ではない。相関は `message_id` で取る。これにより `say_to_room` は送りっぱなしではなく往復になり、呼び出しそのものが境界になる（後述の「床」）。
 
-未知の `type` は拒否せず無視する。部屋側がフレーム種別を増やしても、旧サイドカーが壊れないため。`protocol` はフレームの形が変わり、サイドカー側が気づく必要があるときに上げる。`say` / `reply` から `post` への統合で `protocol` を 2 へ、`hello` への `hue` の追加で 3 へ、`post` の `last_seen` と `post_result` の追加で 4 へ、`hello` への `account_id` の追加で 5 へ上げた。サイドカーはアプリが `.mcp.json` へ書く同梱パスから起動するため、部屋とサイドカーの版が食い違う形が構造上無く、旧フレームとの互換は残していない。
+`history` は参加者からの**読み出しの要求**であり、`history_result` はその答えである。投稿した接続にのみ返す点も、相関を id（`request_id`）で取る点も `post_result` と同じ形である。**これは pull であって push ではない。** 部屋が自分から過去を配ることは無く、席を取る前の発言が届かないことも変わらない——変わるのは、参加者が自分から取りに行けることだけである（後述の「トピック」）。
+
+未知の `type` は拒否せず無視する。部屋側がフレーム種別を増やしても、旧サイドカーが壊れないため。`protocol` はフレームの形が変わり、サイドカー側が気づく必要があるときに上げる。`say` / `reply` から `post` への統合で `protocol` を 2 へ、`hello` への `hue` の追加で 3 へ、`post` の `last_seen` と `post_result` の追加で 4 へ、`hello` への `account_id` の追加で 5 へ、`history` / `history_result` の追加で 6 へ上げた。サイドカーはアプリが `.mcp.json` へ書く同梱パスから起動するため、部屋とサイドカーの版が食い違う形が構造上無く、旧フレームとの互換は残していない。
 
 `to` は両方向で同じ語彙であり、宛先となる参加者の表示名を入れる。任意であり、無いときは `null` ではなくキーごと省く。
 
@@ -228,15 +233,58 @@ push の形（参照実装 `Liplus-Project/github-webhook-mcp` `local-mcp/src/in
 
 部屋で言われたことを追記のみの jsonl として残す。部屋の発言はウィンドウの DOM にしか無く、閉じれば消えていた——引用できないことは症状のひとつであり、実際に何が起きたかを根拠にする設計判断が参加者の記憶だけを頼りにしていたことが、これを持たせた理由である（#48）。
 
+**単位はトピックである（#115）。** 一本の流れに全部を積む形は #48 が残したものであり、この issue が置き換える。トピックは会話の一区画ではなく、会話が行われる器である——開き直せばその会話が部屋へ戻り、続きが話せる。
+
+```text
+logs/{部屋名}/index.json      トピックごとの索引: 名前・作成時刻・{account_id: session_uuid}
+logs/{部屋名}/{トピック}.jsonl  そのトピックの発言、追記のみ
+```
+
 - **ログは部屋のものであってタブのものではない。** `config.rs` の `SavedChatMessage` / `SessionData` / `TabSessions` は流用しない。`SavedChatMessage` は `role` と `content_type` を持つチャットアシスタントの語彙であり、部屋には `role` の当たる軸が無い——人もセッションも一種類の参加者であり、二つの行を分けるのは名前だけである（#39）。`TabSessions` の鍵はタブであり、タブは起動の形であって会話の器ではない。どちらを配線しても、#39 が外した非対称が保存層から戻る。
 - **一行が一つの発言であり、載るのは五欄である。** `message_id` / `speaker` / `content` / `to` / `ts`。
 - **`hue` と `own` は載せない。** `own` は見る側の属性であって話者の属性ではなく（`room.rs` の型が自らそう言っている）、記録すれば一人の視点を発話の一部として残すことになる。`hue` は参加した時点の宣言であり、読み戻す頃にはそれを持っていた席が無い——引き直せば、誰も宣言していない色を描くことになる。
-- **判定と同じロックの内側で書く。** `deliver()` が床を判定した一回の取得の中で追記する。ロックを離してから書く形では、床が既に順序を付けた二人が逆順でディスクへ届きうるため、一つの会話に二つの順序が生まれる。並びの権威は部屋であるという既存の形（上記「床」）を、ファイルの側でも崩さない。
+- **一トピック一ファイルとする。** 一ファイル＋`topic_id` 欄の案は採らない。理由は二つあり、両方が要る。一つのトピックを読むのに一つのファイルだけを読めばよくなること（#114 はこれで解消する）と、トピックが発言には無いもの——そこに居たセッションの id——を持つことである。投稿に欄を増やす形にはその置き場が無い（#39、参加者クラスを値域に取る欄を作らない）。
+- **実在はディレクトリであり、索引はその注釈である。** 索引に無い `.jsonl` は読み出しのときに拾って項目を建てる。これが遅延生成を安全にしている——起動のたびに空の行が索引へ残らず、発言がファイルへ届いて索引へ届く前に落ちても、ファイルだけから項目を建て直せる。
+- **索引へ書くのは意図のある行為だけである。** 最初の発言、セッション id の記録、名前の変更。「アプリが開かれた」はそこに含まれない。
+- **判定と同じロックの内側で書く。** `deliver()` が床を判定した一回の取得の中で追記する。ロックを離してから書く形では、床が既に順序を付けた二人が逆順でディスクへ届きうるため、一つの会話に二つの順序が生まれる。並びの権威は部屋であるという既存の形（上記「床」）を、ファイルの側でも崩さない。書き込み先のトピックも同じ取得の中で読む——外で読めば、切り替えが二つの操作の間に挟まったとき、片方のトピックの順序で受理された発言がもう片方のファイルへ落ちる。
+- **索引はロックの外で書く。** 別のファイルの読み書きであり、部屋を止めて行う仕事ではない。発言はそのどれにも待たされない。
 - **追記の失敗で発言は失われない。失敗は画面に出す。** 発言はディスクに触れる前に部屋へ入っており、書き込みの失敗が取り消せるものではない。失われうるのは記録の側だけである。したがって配送も戻り値も追記の成否に依存させず、代わりに `room-log-error` イベントで画面の状況行に出す——黙って記録を止めたログは依然としてログに見え、後から見に行った者はその空白を「何も言われなかった」と読む。
-- **読み出しは画面のためのものであり、再配信ではない。** `room_log` コマンドは画面だけが呼ぶ。途中から参加したセッションへ過去の発言を流し込むことはしない（`room.rs` の現在の扱いを変えない）。流し込めば、部屋が「誰が何を聞いたか」を持ち始める——#31 と #39 が退けた形である。
-- **ローテーションも上限も持たない。** `design/Vision.dc.html` が日付を持たない `main.jsonl` を単数形で置いていることに従う。古い方から捨てるログは、「実際に何が言われたか」という、これが在る理由そのものの問いに、問う価値が出るちょうどその距離で沈黙する。
-- **ファイル名は `logs/{部屋名}.jsonl` であり、部屋名は `main` に固定する。** Vision の `main` を部屋名の位置と読む。複数部屋は実装しない——実装するときに増えるのはここの値であって、パスの階層ではない。
+- **画面への読み出しはトピックを指定して行う。** `room_topic_log` は開くトピックを名指す。一覧から選ぶという操作がそもそも「現在ではないトピックを読む」ことであるため、現在のトピックを暗黙に読む形では成り立たない。
+- **参加者への読み出しは pull のみである。** 部屋から過去を配る経路は作らない（下記「トピック」）。
+- **ローテーションも上限も持たない。** トピックごとにも、全体としても。古い方から捨てるログは、「実際に何が言われたか」という、これが在る理由そのものの問いに、問う価値が出るちょうどその距離で沈黙する。
+- **部屋名はパスの位置として持ち、`main` に固定する。** Vision の `main` を部屋名の位置と読む。複数部屋は実装しない——実装するときに増えるのはここの値であって、パスの階層ではない。
 - **読めない行は飛ばす。読み全体は失敗させない。** 途中で終わった実行が残す千切れた末尾がこの経路に当たり、その最後の一行のために全履歴を拒むのは、何も守らずにすべてを失う。飛ばした件数は追記の失敗と同じイベントで画面へ返す。
+- **以前の `logs/{部屋名}.jsonl` は一つのトピックとして引き継ぐ。** 索引を初めて建てるときに移動する。コピーではない——一つの会話が二つのファイルに在ることは、その会話に二つの順序が在ることであり、部屋が権威を持っている当のものである。捨てない（#115、決定8）。
+
+### トピック
+
+トピックは会話の器であり、会話の記録ではない。開き直すと、そこに居た CLI セッションが**自分の文脈を持って**戻る（#115）。
+
+**区切りは手動である。** 「新規」を押して切る。起動とは独立しており、一回の起動で複数トピックも、起動をまたいで一トピックの継続もありうる。
+
+**起動時は新しいトピックを開く。** 最後のトピックの続きを自動では開かない。部屋は毎回空から始まり、過去は一覧から選んで開く。#48 の「起動時の部屋は新規である」は既定として残り、変わったのは「消えた先に読みに行ける場所があるか」ではなく「そこから戻せるか」になった点である。
+
+**新規トピックは遅延生成する。** 起動のたびに索引へ空のトピックを書くと、何も話さずに閉じた回が一覧に残り続ける。起動時のトピックは「まだ索引に無い現在のトピック」として部屋が持ち、最初の投稿が着いた時点で索引とファイルができる。画面はそれを一覧に無くても現在のトピックとして描く——毎回の起動直後には、部屋に在って一覧に無いトピックがちょうど一つ在る。
+
+**復帰の手段は二段構えである。** ネイティブ resume を持つ CLI はそれを使い、持たない CLI にはサイドカー経由の読み出しを与える。履歴をテキストで PTY へ流し込む力業は採らない。理由は三つある。トピックが伸びるほど毎回の起動が高くつく（参加者が要るかどうかに関わらず全部渡すため）。CLI は流し込まれた文をユーザ入力として読むため、「自分が言ったこと」と「言ったと聞かされたこと」を区別できない。そして端末ペインにその塊が見える——あのペインはセッションのものである、というのが `RESUMED_NOTICE` の設計思想である（#84）。読み出しは力業を push でやる代わりに pull にしたものであり、これが在れば力業は要らない。
+
+**再開コマンドはアカウントの属性である。** `{session_id}` を含む一行であり、先頭の語が command になる（例: `claude --resume {session_id}`）。トピックが `{account_id: session_uuid}` を保持し、再開時にそこへ差し込む。
+
+**新規セッションへ渡す id は、同じ置換子を起動オプションへ書くことで配る。** 欄を増やさない。`claude` では `--session-id {session_id}` に当たるが、どのフラグが id を運ぶかは CLI ごとの問いであり、再開コマンドが答えているのと同じ問いである。アプリはフラグを持たず、書かれた場所へ差し込む。**書かなければ id を配らない**——それは resume を持たない CLI が恒常的に置かれる状態であり、失敗ではない。
+
+**判定は「このトピックがこのアカウントのセッションを持つか」で行う。** 「アカウントが resume を持つか」ではない。記録と再開コマンドの両方が揃ったときだけ resume であり、どちらかが欠ければ新規起動である。起動チェック（互換しないフラグ、`--settings` の二重宣言）は解決後の行に対して走る——アカウントの行を見て別の行を spawn する形にしない。
+
+**再開できない席があってもトピックは開く。** 復帰できる席は復帰させ、できない席は新規起動として着席する。読み出しがあるため、復帰できなかった席も自分で辿れる。トピックが開かない形は取らない。resume だったかどうかは画面の状況行で言う——黙って同じ言葉で済ませると、戻ってきたのかどうかを人が判別できない。
+
+**トピックへ入ると床は空になり、席は入口へ戻る。** 前のトピックの発言は、入るトピックの床ではない。残したままにすると、開き直したトピックで最初に発言した参加者が、前のトピックの保持窓ごと「見落とし」として返される——実際にはその全部を読んでいる参加者に対して、である。席そのものは残る。トピックの切り替えは誰かを部屋から出すことではなく、どこで話しているかが変わることである。
+
+**部屋は過去の発言を channel へ push しない。** 席を取る前の発言が届かないことは変えない。#31 / #39 で退けた「部屋が誰の既読を持つ」形に触らずに済む。トピックによる復帰はこの制約を緩めるのではなく、不要にする。
+
+**読み出しの道具は `say_to_room` の隣に置く。** `read_room_history` は現在のトピックのそれまでの発言を古い順で返す。既定 50 件、上限 200 件、`before` に `message_id` を渡すとその手前が返る。トピックに上限が無い以上、一回の tool 結果へ全部を載せる形は採らない。**この道具は発言しない。** 「返信ツールは `say_to_room` 1 本に限定する」は投稿の軸の制約であり、読み出しはその軸に載らない——二つめの喋り方があれば「どちらで答えるのか」が参加者の判断に戻るが、読み方が増えてもそれは起きない。
+
+**返すものは「あなた宛ではない」と明示する。** 読み出しが返す発言は、その参加者へ配られたことが一度も無いものである。届いた発言として読めば答えるべきものになる。
+
+**トピック名は最初の発言の冒頭から自動生成し、後から手で変更できる。** 日時のみの一覧は可読性が低い。生成は最初の発言が着いた時点で一度だけ行い、既に名前があるトピックには触れない——話す前に名前を付けたトピックの名前を、最初の発言が取り返す形にしない。
 
 ### MCP サーバの実装方式
 
@@ -268,8 +316,11 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 - 順番の作法（先に届いた答えを読んでから決める、送信直前の読み直し。`instructions` のみで、protocol もツールも増やしていない）
 - 床（`say_to_room` の `last_seen` と `post_result`、既存ロック内での判定と刻印、見落としがあるときの拒否と返却。ツールは 1 本のまま）
 - 拒否が返した発言の描画（画面。`message_id` による重複除去、返ってきた最新への透かしの前進、発言に載せて運ぶ宣言色、描いた分だけを述べる状況表示）
-- 部屋のログ（`logs/main.jsonl` への追記、床の判定と同じロック内での書き込み、保存する五欄、`hue` と `own` を持ち込まない写像、追記の失敗の画面への通知、読み出しコマンド、参加者への再配信をしないこと）
-- 履歴（会話面の左の列、起動時の一回の読み出し、部屋の本文へ復元しないこと、参加者パネルと対の寸法、日付を含む時刻、名前から導く色）
+- 部屋のログ（`logs/main/{トピック}.jsonl` への追記、床の判定と同じロック内での書き込み、保存する五欄、`hue` と `own` を持ち込まない写像、追記の失敗の画面への通知、トピックを指定する読み出しコマンド、参加者への再配信をしないこと）
+- トピック（手動の区切り、起動時の新規トピックと遅延生成、索引とディレクトリの照合、最初の発言からの命名とその場での変更、既存 `logs/main.jsonl` の移行、切り替え時の床の初期化）
+- トピックの再開（アカウントの再開コマンド、`{session_id}` の置換、トピックへのセッション id の記録、再開できない席の新規着席）
+- 参加者からの読み出し（サイドカーの `read_room_history`、`history` / `history_result` フレーム、pull のみ、ページと `before` の巻き戻し）
+- トピックの一覧（会話面の左の列、新しい順、現在のトピックの描画、選択による部屋への読み戻し、参加者パネルと対の寸法、日付を含む時刻、名前から導く色）
 - 参加者モデル（統一 `post` フレーム、発言者以外の全参加者への配送、接続同一性による自分の発言の抑止と名簿の同一性、人間を含む名簿）
 - アカウント（作成・編集・削除、種別、名前と色と作業ディレクトリと起動オプション、リストでのオフライン表示、一つのアカウントは一つの部屋に一席まで、`config.json` からの移行）
 - アカウントのキャラクター（output style の `name:` を持つ欄、起動時の `--settings` による選択、ファイルを書き出さない形、起動オプションの `--settings` との併記の拒否、宣言しないアカウントは既定のまま）
@@ -380,9 +431,14 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 - クラッシュした場合の後始末（#85 の範囲外）。job object へ入れれば OS が落とすが、確認を挟む形とは別の軸であり、実装していない。正常終了の経路を閉じた後も、この経路からは孤児が生まれうる。
 - 孤児の引き取り（#85 の範囲外、#84 関連）。起動時に前回の孤児を見つけて繋ぎ直す形。pty id が Rust のメモリにしか無いため持続化の話になる。
 - CLI の出力から状態を読む形（「ツール使用中」の粒度）。#82 は段階 1 として出力を読まない二つの合図だけを採り、この形は実測してから別 issue で判断すると決めた。
-- 部屋のログと履歴の実機確認。追記されること、再起動後に左の列へ並ぶこと、部屋の本文が空から始まること、二つの面の寸法が揃うことはいずれも実装済みで CI の型検査と Rust のコンパイルは通っているが、実機での操作は未確認である。追記の失敗の経路（`room-log-error`）はそもそも失敗を作り出す必要があるため、実機でも未観測である。
-- 複数の部屋。ログのパスは部屋名を位置として持つが（`logs/{部屋名}.jsonl`、現在は `main` に固定）、部屋そのものは一つである。
-- 履歴からの引用操作。左の列は読む面であり、行を選んで入力欄へ持っていく経路は持たない。
+- 部屋のログとトピックの実機確認。追記されること、再起動後に左の列へトピックが並ぶこと、部屋の本文が空から始まること、選んだトピックが本文へ戻ること、名前の自動生成とその場での変更、二つの面の寸法が揃うことはいずれも実装済みで CI の型検査と Rust のコンパイルは通っているが、実機での操作は未確認である。追記の失敗の経路（`room-log-error`）はそもそも失敗を作り出す必要があるため、実機でも未観測である。
+- 既存 `logs/main.jsonl` の移行の実機確認。移動と索引への採録は実装済みで、対象は現時点で 2 行だが、実機では未実行である。
+- トピックの再開の実機確認。`--session-id` で配った id が実際に `claude --resume` で戻るところは未計測である。CLI の選択肢の存在は 2026-08-27 に確認しているが（#115 の前提）、往復そのものは辿っていない。同じ id を二度 `--session-id` で渡した場合の CLI の挙動も未計測であり、この実装はその経路へ入らない——記録が在るときは、新規起動側でも新しい id を配り直す。
+- `read_room_history` を実際のセッションが呼ぶところの実機確認。サイドカーのラウンドトリップテストは通っているが、エージェントが必要な場面で自分から引くかどうかは未計測である。押し付けないという判断がそのまま「引かれない」に落ちる可能性は残っており、そこは `instructions` の書き方の問題として観測してから判断する。
+- トピックを切り替えたときに、席を持っている参加者がそれをどう受け取るかの実機確認。床は空になり席は入口へ戻るが（上記「トピック」）、走っているセッション自身は自分の文脈をそのまま持ったままである。
+- 複数の部屋。ログのパスは部屋名を位置として持つが（`logs/{部屋名}/`、現在は `main` に固定）、部屋そのものは一つである。
+- トピックからの引用操作。読み戻した行は部屋の本文に在るが、行を選んで入力欄へ持っていく経路は持たない。
+- トピックの削除。一覧から消す経路は持たない。
 - plugin としての allowlist 掲載（配布の第二段階）
 
 ### 二つの地色
@@ -397,27 +453,31 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 この規則の下では、選択中の端末タブは地色で選択を言えなくなる。代わりに言うのは枠（未選択の `transparent` から `--line` へ）と文字色（`--muted` から参加者自身の色へ）である。参加者パネルの選択中の行と同じ形——枠のある窓の地の箱——になり、同じ選択を二つの面が同じ手で描く（#75）。それまでは逆を向いていた。パネルの地が `--surface` なので選択された行は `--bg` で浮き、端末ヘッダの地が `--bg` なので選択されたタブは `--surface` で沈んでいた。
 
-### 履歴
+### トピックの一覧
+
+会話面の**左**に常時出る列を持つ。トピックの一覧であり、選べばそのトピックが部屋へ戻る（上記「トピック」）。
 
-会話面の**左**に常時出る列を持つ。部屋のログを読み出して、このウィンドウが開く前に言われたことを並べる（上記「部屋のログ」）。
+この列は過去の発言を一本の流れで並べる帯だった（#48）。求められていた形は一覧であり、埋めた粒度が外れていた——#48 で Master が判断したのは「左サイドバーに履歴として表示」「起動時は新規ルーム」の二点であって、一本の流れか、トピックの一覧か、ではなかった（#115）。
 
-**起動時の部屋は新規である。** 過去ログを `#room` の本文へ復元しない。閉じれば部屋の中身は消えるという現在の振る舞いを変えない——変えたのは、消えた先に読みに行ける場所があるかどうかだけである。
+**選んだトピックは部屋の本文へ戻る。** #48 の「過去ログを `#room` の本文へ復元しない」はここで巻き戻る。その一行は上書きされたものとして扱う。**起動時の部屋が新規であることは残る**——変わったのは、過去が読める場所ではなく、過去へ戻れるかどうかである。
 
-**二つの面を分けるのは起動である。** 左に在るのはこのウィンドウが開く前、右の部屋に在るのはこのウィンドウの中。だから履歴は発言が届くたびに伸びない——伸びる帯は隣の会話面をもう一度描いたものであり、二つを見分けている境界そのものが無くなる。読み出しは起動時の一回である。
+**新しい順に並べる。** 会話の一覧が読まれるのはこちらの端からである。ファイルは起きた順（追記の順）を保ち、逆順は読みの判断であって保存の判断ではない。
 
-**部屋の本文と履歴は混ぜない。** 別のサーフェスであることがこの機能の形であり、同じものを二か所に出すことではない。
+**現在のトピックは一覧に無くても描く。** 遅延生成のため、毎回の起動直後には部屋に在って索引に無いトピックがちょうど一つ在る（上記「トピック」）。空白にすると、自分の部屋のトピックが自分の一覧に無い状態として読まれる。
 
-**参加者パネルと対にする。** 幅（16.5rem）と地色を揃え、枠は会話面に向く側に置く（左は `border-right`、右は `border-left`）。部屋を挟む二つの面が別々の寸法を持てば、揃っていないこと自体が読まれる。中の部品は同じ語彙（`.panel-head` / `.panel-title` / `.empty`）を使う。
+**一件が持つのは名前と作成時刻である。** 名前は一行で切り、溢れは省略する——一覧は左端を縦に読むものであり、三行に折り返した題は次の行の位置を前の行の長さで決めることになる。まだ何も言われていないトピックは「未命名」と出す。空白にすると、読み出しに失敗した行と見分けが付かない。
 
-**一件の見た目は部屋の行と同じ形である。** 話者の色の罫、その上に発言者・宛先・時刻。ただし寸法はパネルのものであり、会話面の文字サイズ（`--room-font-size`）は載せない——あの寸法は会話面の本文を描く二つの要素にだけ宣言されるものであり（#81）、ここはパネルである。
+**名前はその場で直す。** 行をダブルクリックすると入力欄になり、Enter が決定、Escape とフォーカス喪失が取消である。生成された題は編集できる欄に置かれた出発点であり、アカウントの名前と同じものである。
 
-**古い方から並べ、末尾を開いた状態で出す。** 部屋の並びと同じ向きであり、二つは一続きに読める——この列の最後の行は、隣の部屋の最初の行の直前に言われたものである。だから下端が会話の連続する側であり、上端は何か月も前になる。上限を持たないログで一番古い行を毎回正面に出すのは、その距離が伸び続ける側を見せることになる。
+**「新規」は一覧の見出しの隣に置く。** 作る操作はそれが現れるリストの隣に置く——参加者パネルの「＋」と同じ形である（#59）。
 
-**時刻には日付も出す。** 部屋の行は今この実行の中で言われたものなので時計だけで読めるが、履歴に在るものはすべてこのウィンドウより前であり、日付が置く側である。
+**参加者パネルと対にする。** 幅（16.5rem）と地色を揃え、枠は会話面に向く側に置く（左は `border-right`、右は `border-left`）。部屋を挟む二つの面が別々の寸法を持てば、揃っていないこと自体が読まれる。中の部品は同じ語彙（`.panel-head` / `.panel-title` / `.empty`）を使う。選択中の行は、参加者パネルの選択中の行と同じく枠のある窓の地の箱である（#75）。
 
-**色は名前から導く。** ログは宣言色を持たないため（上記「部屋のログ」）、`hue` の梯子の最後の段——名前からの導出——を使う。同じ名前を名乗った二人はここでは一色になる。これは、誰も宣言していない色を保存しないことの既知の代償であり、履歴は過去の面であって部屋の帰属の面ではない。
+**読み戻した行は部屋の行と同じ形で描く。** 別の面ではなくなったため、寸法も同じである。時刻には日付も出す——トピックは日をまたぐため、`14:32` だけではどの日か決まらない。**色は名前から導き、`own` はどの行にも立てない。** ログは宣言色も見る側の位置も持たないためであり（上記「部屋のログ」）、この画面自身の過去の発言もアクセントでは出ない。それ以外に過去であることの印は付けない——同じ会話であり、「起動のどちら側で言われたか」は発言の属性ではない。
 
-**空とエラーを分ける。** 記録が無いのは初回の実行であって失敗ではないため「記録なし」と出す。読み出しが失敗したときだけ理由を添えて出す。
+**読み戻しでは透かしを消す。** トピックへ入ると床は空になるため、読み戻した発言の `message_id` を申告しても位置 0 に落ちる。等価な値ではなく、本当のこと（この床では何も見ていない）を言う。描いた `message_id` は残す——拒否が保持窓の全件を返したときに、既に描いた行を二重に描かないためである（#108）。
+
+**空とエラーを分ける。** トピックが無いのは初回の実行であって失敗ではないため「トピックなし」と出す。読み出しが失敗したときだけ理由を添えて出す。
 
 ### 参加者パネル
 
@@ -667,8 +727,18 @@ liplus-desktop の `stream_parser.rs` および `spawn_stream_pty` / `spawn_stre
 
 表示は省略記号で切らずに折り返す。切れる末尾はアプリが統合した channel エントリであり、そこが「書いた行と走る行が違う」ことの中身である。一行のランチャ行には縦の余裕が無かったが、モーダルにはある（ランチャ行そのものは #62 で無くなった。下記「ランチャ行は無い」）。
 
+起動オプションには `{session_id}` を書ける。新しいセッションを始めるときに、このアプリが決めた UUID がそこへ入る（上記「トピック」）。`claude` では `--session-id {session_id}` に当たる。欄を増やさずここへ書く形にしたのは、どのフラグが id を運ぶかが CLI ごとの問いであり、再開コマンドが答えているのと同じ問いだからである。書かなければ id は配られない。
+
 **実測済み（2026-08-21）**: 複数の channel サーバを同時に有効化した状態で往復が成立した。`--print` での確認は無意味である（channel の読み込み自体が走らないため）ことも実測しており、確認は対話セッションでのみ可能。
 
+### 再開コマンド
+
+アカウントは起動コマンドの隣に**再開コマンド**を持つ。`{session_id}` を含む一行であり、先頭の語が command になる（例: `claude --resume {session_id}`）。トピックがアカウントごとのセッション id を持ち、再開時にそこへ差し込む（上記「トピック」）。置換は `crates/mcp-config/` に置き、テストの対象とする。
+
+**一行まるごとである。** 起動オプションと別の欄なのは、戻り方が起動と同じ呼び出しとは限らないためであり、これは人がそのとき打つ行である。分割は起動オプションと同じ規則で行う。
+
+**空は正当な状態であり、通常の状態である。** そのアカウントは開き直したトピックへ新規のセッションとして着席し、必要になったことは `read_room_history` で自分から引く。resume を持たない CLI も同じ状態に置かれる。
+
 ### 作業ディレクトリ
 
 セッションの作業ディレクトリはアカウントの属性であり、アカウントのモーダルで表示・変更する。未設定のままアプリのプロセス cwd へ暗黙にフォールバックしない。未設定のアカウントの起動は拒否し、モーダルを開く。
@@ -829,7 +899,7 @@ slug は読みやすさのためだけにあり、ASCII 英数字と `-` に落
 
 したがって `src-tauri/src/` に残すのは、tauri の `State` / `AppHandle` に触れる部分だけとする。純粋ロジックをそちらへ書き足すと、書いた時点で検証不能になる。床の順序付けは読んでも確かめられない性質のもの（二人が同時に呼んだとき片方だけが通る）であり、この方針が最も効く箇所である。`src-tauri/src/room.rs` が持つのは、その判定を既存ロックの内側で呼ぶことと、結果をフレームとイベントへ載せることだけである。
 
-部屋のログ（`src-tauri/src/room_log.rs`）はこの方針の例外ではなく、境界の側である。パスの解決は `AppHandle` の `app_data_dir` に依存し、追記も読み出しもその解決の上に載るため、tauri 非依存の crate へは出せない。ただし純粋な部分は残っている——発言から五欄への写像と、一行の解析である。**これらは `cargo test` の対象になっていない。** 隠さずここに書く。写像は落とす欄を明示するために手で書いてあり（`LoggedPost::of`）、解析は `serde_json` そのものであるため、読んで確かめられる範囲に収めてある。床の順序付けのように読んでも確かめられない性質のものは、この面には無い——追記の順序は床の判定と同じロックの内側で決まっており、その順序付け自体は既に `crates/room-floor/` が持っている。
+部屋のログ（`src-tauri/src/room_log.rs`）はこの方針の例外ではなく、境界の側である。パスの解決は `AppHandle` の `app_data_dir` に依存し、追記も読み出しもその解決の上に載るため、tauri 非依存の crate へは出せない。ただし純粋な部分は残っている——発言から五欄への写像、一行の解析、題の生成、そして索引とディレクトリの照合である。**これらは `cargo test` の対象になっていない。** 隠さずここに書く。写像は落とす欄を明示するために手で書いてあり（`LoggedPost::of`）、解析は `serde_json` そのものであるため、読んで確かめられる範囲に収めてある。題の生成（`title_from`）と照合（`adopt_orphans`）は #115 で増えた分であり、前者は純粋関数、後者はディレクトリの読みに依存する。**照合のほうは読んで確かめられる範囲を出ている**——遅延生成の安全性がこれに乗っているためであり、`AppHandle` への依存を外して crate へ出すのが正しい形である。この issue の範囲では行っていない。床の順序付けのように読んでも確かめられない性質のものは、この面には無い——追記の順序は床の判定と同じロックの内側で決まっており、その順序付け自体は既に `crates/room-floor/` が持っている。
 
 CI が実行するもの:
 
@@ -909,6 +979,9 @@ CI が実行するもの:
 | 終了した端末をタブが閉じられるまで残す（#68） | 放置されたタブのぶん、スクロールバックがメモリに残る。#57 は「読んだら消える」でこれを避けていた |
 | 再読み込み後の端末を席から繋ぎ直す（#84） | 戻るのは出力・入力・終了だけであり、スクロールバックは戻らない。過去の出力は消えた xterm のインスタンスに在り、他のどこにも無い |
 | 「出力中」が端末の出力だけを言う（#82） | 「出力中」と出ても部屋へ発言が来ないことがある。語は部屋への到着を主張していないため受容する（Master、2026-08-24） |
+| 読み戻した行が宣言色を持たない（#115） | ログは `hue` を持たないため、トピックを開き直すと過去の発言は名前から導いた色で出る。同じ名前を名乗った二人は一色になり、この画面自身の過去の発言もアクセントでは出ない。誰も宣言していない色を保存しないことの代償である |
+| セッション id の置換子を起動オプションへ書く（#115） | 「新しいセッションを始める」側に専用の欄が無く、`{session_id}` を自分で書く必要がある。どのフラグが id を運ぶかは CLI ごとの問いであり、アプリがフラグを持てば `claude` 以外で外れる |
+| 索引をディレクトリと照合して建て直す（#115） | 遅延生成の安全性がこの照合に乗るが、照合そのものは `AppHandle` に依存するため `cargo test` の外に在る（上記「テストの配置」） |
 
 ## 位置づけ
 
diff --git a/index.html b/index.html
index 16a3ddc..44391f3 100644
--- a/index.html
+++ b/index.html
@@ -42,25 +42,32 @@
       </header>
 
       <div id="body">
-        <!-- What was said before this run, read out of the room's log
-             (src-tauri/src/room_log.rs). A surface of its own, on the opposite
-             side from the account panel, because the room's body and the
-             history are two different things and mixing them would undo the
-             one that the room starts empty every time (#48).
-
-             The division between the two is the launch. Below is what was said
-             before this window opened; the room to the right is what is being
-             said in it. That is why nothing here follows along as posts
-             arrive — a strip that grew with the conversation would be a second
-             drawing of the conversation, which is the surface next to it. -->
-        <aside id="history" aria-label="履歴">
+        <!-- The topics (src-tauri/src/room_log.rs). Not a strip of past posts:
+             this column used to hold every line ever said in one flow, and what
+             Master asked for was a list to pick from (#115). A topic is the
+             vessel a conversation happens in — picking one puts it back in the
+             room to the right and the talk continues in it.
+
+             It sits opposite the account panel and is its pair in width and
+             ground, for the reason it was one before: two panels flanking the
+             room read as two panels, and one of them narrower reads as a
+             mistake (#48).
+
+             新規 is what draws a boundary, and it is the only thing that draws
+             one. Starting the app opens a new topic too, but the two are
+             independent: one run may hold several topics, and one topic may
+             span several runs (#115, decision 1). -->
+        <aside id="history" aria-label="トピック">
           <div class="panel-head">
-            <h2 class="panel-title">履歴</h2>
+            <h2 class="panel-title">トピック</h2>
+            <!-- Making one belongs next to the list it appears in, which is
+                 where ＋ sits on the panel opposite (#59). -->
+            <button id="topic-new" type="button" title="新しいトピックを始める">新規</button>
           </div>
-          <!-- Seeded, because the log is read after the frame is up: an empty
-               strip in that gap would say "nothing was ever said" at the one
-               moment nothing has been asked yet. -->
-          <ol id="history-list" class="history">
+          <!-- Seeded, because the index is read after the frame is up: an empty
+               list in that gap would say "there are no topics" at the one moment
+               nothing has been asked yet. -->
+          <ol id="topic-list" class="topics">
             <li class="empty">読み込み中</li>
           </ol>
         </aside>
@@ -283,13 +290,41 @@ <h2 id="account-dialog-title">アカウント</h2>
                 placeholder="例: character_Lay（output style の name）"
               />
             </label>
+            <!-- 起動オプション。`{session_id}` を書くと、そこへこのアプリが
+                 決めた UUID が入る。新しいトピックでセッションを始めるときに
+                 使う側であり、`claude` では `--session-id {session_id}` と
+                 書く。どのフラグが id を運ぶかは CLI ごとの問いであるため、
+                 アプリ側は欄を持たず、書かれた場所へ差し込む。
+
+                 書かなければ id を配らない。それは resume を持たない CLI が
+                 恒常的に置かれる状態であり、失敗ではない——その場合の参加者
+                 は、部屋の読み出し（`read_room_history`）で自分から辿る
+                 (#115)。 -->
             <label class="field">
               起動オプション
               <input
                 id="dialog-options"
                 type="text"
                 spellcheck="false"
-                placeholder="例: --dangerously-skip-permissions"
+                placeholder="例: --dangerously-skip-permissions --session-id {session_id}"
+              />
+            </label>
+            <!-- 再開コマンド。トピックが持っているセッションへ戻る一行であり、
+                 先頭の語が command になる。トピックはアカウントごとに
+                 `{account_id: session_uuid}` を持ち、その id がここへ入る
+                 (#115、決定4B)。
+
+                 起動コマンドと別の欄なのは、戻り方が起動と同じ呼び出しとは
+                 限らないためである。空なら resume 無しであり、そのアカウント
+                 は開き直したトピックへ新規のセッションとして着席する。席が
+                 一つ戻らなくてもトピックは開く（決定6）。 -->
+            <label class="field">
+              再開コマンド
+              <input
+                id="dialog-resume"
+                type="text"
+                spellcheck="false"
+                placeholder="例: claude --resume {session_id}"
               />
             </label>
             <!-- What will actually run. The app merges its own channel entry
diff --git a/sidecar/src/index.ts b/sidecar/src/index.ts
index adbb036..0fc6f26 100644
--- a/sidecar/src/index.ts
+++ b/sidecar/src/index.ts
@@ -17,6 +17,11 @@
  * Direction of travel:
  *   someone posts -> WebSocket frame -> channel notification -> agent reacts
  *   this agent posts -> `say_to_room` tool -> WebSocket frame -> the room
+ *   this agent looks back -> `read_room_history` tool -> WebSocket frame -> the room
+ *
+ * The third one is a pull and only a pull. The room pushes nothing it did not
+ * fan out live, so a session that joined a topic late is still handed nothing
+ * — what changes is that it can now go and get it (#115, decision 4C).
  *
  * 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).
@@ -70,7 +75,7 @@ function readHue(raw: string | undefined): number | null {
  */
 const ACCOUNT_ID = process.env.PULLCEPT_ACCOUNT_ID?.trim() || null;
 
-const PROTOCOL_VERSION = 5;
+const PROTOCOL_VERSION = 6;
 
 /**
  * How long a post waits for the room to answer it.
@@ -166,6 +171,26 @@ interface PostResultFrame {
   missed?: MissedPost[];
 }
 
+/** One post as the room's log kept it. No hue and no `own`: see room_log.rs. */
+interface LoggedPost {
+  message_id?: string;
+  speaker?: string;
+  content?: string;
+  to?: string;
+  ts?: string;
+}
+
+/** The room's answer to one pull of the current topic's past posts. */
+interface HistoryResultFrame {
+  type: "history_result";
+  request_id?: string;
+  posts?: LoggedPost[];
+  /** True when the topic holds posts older than the oldest one returned. */
+  has_more?: boolean;
+  /** Set instead of `posts` when the room could not read the topic. */
+  error?: string;
+}
+
 // ── MCP server ───────────────────────────────────────────────────────────────
 
 const INSTRUCTIONS = [
@@ -180,6 +205,15 @@ const INSTRUCTIONS = [
   "発言するときは say_to_room ツールを呼んでください。ターミナルへの出力は",
   "部屋には届きません。",
   "",
+  "前を見る:",
+  "- あなたが来る前の発言は届きません。部屋は過去を配らないからです。",
+  "- 必要になったら read_room_history を呼んでください。今のトピックで",
+  "  それまでに言われたことが、古い順で返ります。",
+  "- 押し付けられないので、要らないときは呼ばないでください。話の流れが",
+  "  分からないまま答えそうなときにだけ引けば足ります。",
+  "- 返り切らなかったときは、いちばん古い発言の message_id を before に",
+  "  入れてもう一度呼ぶと、その手前が返ります。",
+  "",
   "宛先:",
   "- 発言には宛先が付くことがあります。宛先は meta.to に入っています。",
   `- meta.to が「${AGENT_NAME}」なら、あなた宛です。答えてください。`,
@@ -260,6 +294,45 @@ const TOOLS = [
       required: ["content"],
     },
   },
+  /**
+   * The pull, and the second of the two tools.
+   *
+   * `say_to_room` stays the only way to be heard, which is the constraint that
+   * kept the tool count at one: a second way to speak would put "which one do I
+   * answer through" back on the agent. This one cannot speak. It reads, and
+   * reading is the thing the room had no way of doing at all — a session that
+   * joined a topic after it started was simply told nothing (#115, decision 4C).
+   *
+   * Pull rather than push, deliberately. Handing the whole topic to a session at
+   * launch costs every launch the length of the topic whether the session needed
+   * it or not, arrives as text the CLI cannot tell from something the person
+   * typed, and lands in the terminal pane, which belongs to the session (#84).
+   */
+  {
+    name: "read_room_history",
+    description:
+      "Read what was said in this room's current topic before now. Use it when " +
+      "you joined after the conversation started and need what you missed; the " +
+      "room never delivers past posts on its own. Reading only — it posts nothing.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        limit: {
+          type: "number",
+          description:
+            "How many posts to return, newest-most first-page. Defaults to 50 " +
+            "and is capped by the room.",
+        },
+        before: {
+          type: "string",
+          description:
+            "Optional. Return the posts older than this message_id. Use the " +
+            "oldest message_id of the previous page to keep reading backwards.",
+        },
+      },
+      required: [] as string[],
+    },
+  },
 ];
 
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
@@ -267,6 +340,8 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
 
+  if (name === "read_room_history") return await readHistory(args);
+
   if (name !== "say_to_room") {
     return {
       content: [{ type: "text", text: `Unknown tool: ${name}` }],
@@ -351,6 +426,105 @@ mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
   return { content: [{ type: "text", text: "Delivered to the room." }] };
 });
 
+/**
+ * Ask the room for the current topic's past posts, and put the answer where the
+ * agent will read it.
+ *
+ * Failures are `isError`, and each of the three says which one it is. "Nothing
+ * came back" and "nothing was said" are different answers, and an agent handed
+ * the first as the second stops looking.
+ */
+async function readHistory(args: Record<string, unknown> | undefined): Promise<{
+  content: { type: "text"; text: string }[];
+  isError?: boolean;
+}> {
+  const limit = typeof args?.limit === "number" && Number.isFinite(args.limit)
+    ? Math.trunc(args.limit)
+    : undefined;
+  const before = typeof args?.before === "string" && args.before.trim()
+    ? args.before.trim()
+    : undefined;
+
+  const requestId = randomUUID();
+  // Registered before the frame goes out, so an answer arriving inside the same
+  // tick has somewhere to land.
+  const answered = awaitHistoryResult(requestId);
+  const sent = sendToRoom({
+    type: "history",
+    request_id: requestId,
+    ...(limit === undefined ? {} : { limit }),
+    ...(before ? { before } : {}),
+  });
+
+  if (!sent) {
+    abandonHistory(requestId);
+    await answered;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Not read: the room socket is not connected (${roomStatus()}).`,
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const result = await answered;
+  if (result === null) {
+    return {
+      content: [
+        {
+          type: "text",
+          text:
+            `Not read: the room did not answer (${roomStatus()}). This is not ` +
+            "the same as the topic being empty — do not conclude that nothing was said.",
+        },
+      ],
+      isError: true,
+    };
+  }
+  if (typeof result.error === "string") {
+    return {
+      content: [{ type: "text", text: `Not read: ${result.error}` }],
+      isError: true,
+    };
+  }
+
+  return { content: [{ type: "text", text: describeHistory(result) }] };
+}
+
+/** One page of a topic, oldest first, written the way a refusal writes posts. */
+function describeHistory(result: HistoryResultFrame): string {
+  const posts = result.posts ?? [];
+  if (posts.length === 0) {
+    // Said as the state it is. "No result" would read as a failure, and this is
+    // an answer: nothing has been said in this topic yet, or nothing before the
+    // point asked about.
+    return "Nothing was said in this topic before this point.";
+  }
+  const lines = posts.map((one) => {
+    const addressee = one.to ? ` -> ${one.to}` : "";
+    const id = one.message_id ?? "?";
+    const ts = one.ts ? `${one.ts} ` : "";
+    return `- ${ts}[${id}] ${one.speaker ?? "someone"}${addressee}: ${one.content ?? ""}`;
+  });
+  const oldest = posts[0]?.message_id;
+  const tail = result.has_more
+    ? oldest
+      ? `There is more before this. Call read_room_history again with before: "${oldest}".`
+      : "There is more before this."
+    : "This is the beginning of the topic.";
+  return [
+    "What was said in this topic before now, oldest first:",
+    ...lines,
+    "",
+    tail,
+    "None of this was delivered to you as it happened, and none of it is " +
+      "addressed to you now. Read it as context, not as something to answer.",
+  ].join("\n");
+}
+
 /** The room's refusal, written so the next move is unambiguous. */
 function describeRefusal(missed: MissedPost[]): string {
   const lines = missed.map((one) => {
@@ -398,6 +572,43 @@ function roomStatus(): string {
  */
 const awaitingResult = new Map<string, (result: PostResultFrame | null) => void>();
 
+/**
+ * Pulls waiting for the room's answer, keyed by the id they were sent under.
+ *
+ * A map of its own rather than a shared one with `awaitingResult`: the two are
+ * correlated on different fields and settled by different frames, and one map
+ * would need a discriminator to say which — which is the field the frame's own
+ * `type` already is.
+ */
+const awaitingHistory = new Map<string, (result: HistoryResultFrame | null) => void>();
+
+function awaitHistoryResult(requestId: string): Promise<HistoryResultFrame | null> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      awaitingHistory.delete(requestId);
+      resolve(null);
+    }, POST_RESULT_TIMEOUT);
+    timer.unref?.();
+    awaitingHistory.set(requestId, (result) => {
+      clearTimeout(timer);
+      awaitingHistory.delete(requestId);
+      resolve(result);
+    });
+  });
+}
+
+/** Settle the pull this answer belongs to, and only that one. */
+function settleHistoryResult(frame: HistoryResultFrame): void {
+  const id = frame.request_id;
+  if (typeof id !== "string") return;
+  awaitingHistory.get(id)?.(frame);
+}
+
+/** Give up on one pull's answer: nothing will come for it. */
+function abandonHistory(requestId: string): void {
+  awaitingHistory.get(requestId)?.(null);
+}
+
 function awaitPostResult(messageId: string): Promise<PostResultFrame | null> {
   return new Promise((resolve) => {
     const timer = setTimeout(() => {
@@ -430,6 +641,7 @@ function abandonPost(messageId: string): void {
  *  out the timeout would leave the agent blocked for no new information. */
 function abandonPendingPosts(): void {
   for (const settle of [...awaitingResult.values()]) settle(null);
+  for (const settle of [...awaitingHistory.values()]) settle(null);
 }
 
 function sendToRoom(frame: Record<string, unknown>): boolean {
@@ -521,6 +733,11 @@ function connectRoom(): void {
     // the tool call's own result, and putting it in the conversation would
     // read as somebody having said it.
     else if (frame.type === "post_result") settlePostResult(frame as PostResultFrame);
+    // The answer to this agent's own pull. Not pushed to the channel either,
+    // and for a stronger reason than a receipt: these are posts, and putting
+    // them in the conversation would be the room delivering the past after all
+    // — which is the one thing the pull exists in order not to do.
+    else if (frame.type === "history_result") settleHistoryResult(frame as HistoryResultFrame);
     // 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 cfced7f..1e03626 100644
--- a/sidecar/test/round-trip.test.mjs
+++ b/sidecar/test/round-trip.test.mjs
@@ -46,6 +46,21 @@ const TURN_TAKING = [
   "  足りないことがあるときだけ足してください。",
 ].join("\n");
 
+// Looking back. The room hands a late joiner nothing, by design, so the whole
+// of what makes the read reachable is that the manners name it and say when it
+// is worth calling (#115, decision 4C). Asserted in full for the reason the two
+// above are: a head-only check passes on a paragraph whose tail was deleted.
+const LOOKING_BACK = [
+  "前を見る:",
+  "- あなたが来る前の発言は届きません。部屋は過去を配らないからです。",
+  "- 必要になったら read_room_history を呼んでください。今のトピックで",
+  "  それまでに言われたことが、古い順で返ります。",
+  "- 押し付けられないので、要らないときは呼ばないでください。話の流れが",
+  "  分からないまま答えそうなときにだけ引けば足ります。",
+  "- 返り切らなかったときは、いちばん古い発言の message_id を before に",
+  "  入れてもう一度呼ぶと、その手前が返ります。",
+].join("\n");
+
 const SEE_THE_FLOOR = [
   "床を見てから送る:",
   "- say_to_room には last_seen を付けてください。値は、あなたが実際に見た",
@@ -124,12 +139,55 @@ test("a room post reaches the channel, and say_to_room reaches the room", async
     },
   ];
 
+  // What the topic held before this session joined. The room delivers none of
+  // it live — a later joiner missed it — so the only way it reaches the agent
+  // is the pull (#115, decision 4C).
+  const PAST = [
+    {
+      message_id: "h-1",
+      speaker: "Master",
+      content: "この件は昨日決めた",
+      ts: "2026-08-26T00:00:00.000Z",
+    },
+    {
+      message_id: "h-2",
+      speaker: "Claude Lay",
+      content: "了解しました",
+      to: "Master",
+      ts: "2026-08-26T00:00:01.000Z",
+    },
+  ];
+  const historyFrames = [];
+
   wss.on("connection", (socket) => {
     roomSocket = socket;
     connected.resolve(socket);
     socket.on("message", (raw) => {
       const frame = JSON.parse(raw.toString());
       if (frame.type === "hello") helloSeen.resolve(frame);
+      if (frame.type === "history") {
+        historyFrames.push(frame);
+        // An answer for a pull nobody made, sent first. The call must not
+        // settle on it: pulls are correlated by request_id, the way posts are
+        // by message_id, and arrival order says nothing.
+        socket.send(
+          JSON.stringify({
+            type: "history_result",
+            request_id: "not-this-pull",
+            posts: [],
+            has_more: false,
+          }),
+        );
+        socket.send(
+          JSON.stringify({
+            type: "history_result",
+            request_id: frame.request_id,
+            posts: PAST,
+            has_more: true,
+          }),
+        );
+        return;
+      }
       if (frame.type !== "post") return;
 
       postFrames.push(frame);
@@ -320,18 +378,38 @@ test("a room post reaches the channel, and say_to_room reaches the room", async
     SEE_THE_FLOOR,
     "instructions must carry the floor manners in full, tail included",
   );
+  // The pull. A tool nobody is told about is a tool nobody calls: the room
+  // still delivers nothing that predates a seat, so a session that joined a
+  // topic late learns what it missed only by knowing to go and ask (#115,
+  // decision 4C).
+  assertContains(
+    instructions,
+    LOOKING_BACK,
+    "instructions must carry the looking-back manners in full, tail included",
+  );
 
   notify("notifications/initialized", {});
 
   const tools = await request("tools/list", {});
+  const toolNames = tools.result.tools.map((tool) => tool.name);
+  // One way to speak, one way to look back. The constraint that held the count
+  // at one is about *posting*: a second way to be heard would put "which one do
+  // I answer through" back on the agent. `read_room_history` cannot post, so it
+  // does not sit on that axis (#115, decision 4C).
   assert.deepEqual(
-    tools.result.tools.map((tool) => tool.name),
-    ["say_to_room"],
+    toolNames,
+    ["say_to_room", "read_room_history"],
+    "one posting tool and one reading tool, and nothing else",
+  );
+  assert.equal(
+    toolNames.filter((name) => name === "say_to_room").length,
+    1,
     "exactly one posting tool is exposed",
   );
-  // Seeing the floor is an argument of the one tool, not a second tool. A
-  // separate read call would put "which one do I speak through" back on the
-  // agent, which is the reason there is one (docs/0-requirements.md).
+  // Seeing the floor is an argument of the posting tool, not a tool of its own.
+  // The watermark is a claim about what the speaker saw, made at the moment of
+  // speaking; split into its own call it would be a claim about a moment that
+  // has already passed by the time the post goes out (#47).
   const schema = tools.result.tools[0].inputSchema;
   assert.deepEqual(
     Object.keys(schema.properties).sort(),
@@ -358,7 +436,7 @@ test("a room post reaches the channel, and say_to_room reaches the room", async
   // (#59). It rides on `hello` and decides nothing: identity in the room is the
   // connection, and this frame cannot set that (#39 / #40).
   assert.equal(hello.account_id, TEST_ACCOUNT);
-  assert.equal(hello.protocol, 5);
+  assert.equal(hello.protocol, 6);
 
   roomSocket.send(
     JSON.stringify({
@@ -511,6 +589,58 @@ test("a room post reaches the channel, and say_to_room reaches the room", async
     "the refusal must name the watermark to declare on the next attempt",
   );
 
+  // ── the pull: what the topic held before this session joined ──────────────
+  // The room hands a late joiner nothing, and this is the whole of what a
+  // participant can do about that. It is a read: nothing is posted, and the
+  // frame that goes out is not a post (#115, decision 4C).
+  const pulled = await request("tools/call", {
+    name: "read_room_history",
+    arguments: { limit: 2 },
+  });
+  assert.ok(!pulled.result.isError, `pull failed: ${JSON.stringify(pulled.result)}`);
+  assert.equal(historyFrames.length, 1, "one pull produces exactly one frame");
+  assert.equal(historyFrames[0].type, "history");
+  assert.equal(historyFrames[0].limit, 2);
+  assert.equal(
+    "before" in historyFrames[0],
+    false,
+    "a first page names no cursor; an empty one would be a value the room has to rule out",
+  );
+  // A pull is not a post. Reaching the room as one would put words in the room
+  // that nobody said.
+  assert.equal(
+    postFrames.length,
+    3,
+    "reading the topic must not put anything on the floor",
+  );
+  const past = pulled.result.content[0].text;
+  // Correlation held: the answer for another pull arrived first and did not
+  // settle this call.
+  for (const one of PAST) {
+    assertContains(past, one.message_id, "each past post must carry its id");
+    assertContains(past, one.speaker, "each past post must name its speaker");
+    assertContains(past, one.content, "each past post must carry what was said");
+  }
+  assertContains(
+    past,
+    "Claude Lay -> Master:",
+    "a past post addressed to someone comes back carrying who it was for",
+  );
+  // The way to keep reading backwards, named concretely. "There is more" with
+  // no cursor is a dead end the agent cannot act on.
+  assertContains(
+    past,
+    'before: "h-1"',
+    "a page with more behind it must name the cursor for the next one",
+  );
+  // What this is and is not. These posts were never addressed to this session
+  // and were never delivered to it; read as arrivals they would be answered.
+  assertContains(
+    past,
+    "Read it as context, not as something to answer.",
+    "the pull must say that what it returns is not addressed to the reader",
+  );
+
   // ── an unanswered post is unconfirmed, not delivered and not refused ───────
   // The frame may well have landed. Reporting either verdict would be a guess
   // the agent then acts on: "delivered" lets it believe it spoke, "refused"
diff --git a/src-tauri/src/config.rs b/src-tauri/src/config.rs
index 8a5b90c..48077b3 100644
--- a/src-tauri/src/config.rs
+++ b/src-tauri/src/config.rs
@@ -92,6 +92,33 @@ pub struct Account {
     /// nobody made.
     #[serde(default)]
     pub character: Option<String>,
+    /// The whole command line that puts this account back into a session it was
+    /// already in, with `{session_id}` where the id goes — for example
+    /// `claude --resume {session_id}`. `None` when the account declares none.
+    ///
+    /// A topic holds which session each account was in while it was open
+    /// (`room_log::Topic::sessions`), and reopening one hands that id to this
+    /// line. What comes back is the participant's own context, carried by the
+    /// CLI rather than read out to it — which is why this is a resume and not a
+    /// replay of the log (#115, decision 4B).
+    ///
+    /// A whole command line rather than options alone, because resuming may not
+    /// be the same invocation: it is the line the person would type. It is split
+    /// the way launch options are, and the first token is the command.
+    ///
+    /// The other half of the pair is not a field. A fresh launch hands the CLI
+    /// an id this app decided, and where that id goes on the line is the same
+    /// per-CLI question this field answers — so it is written into the launch
+    /// options with the same `{session_id}` placeholder
+    /// (`mcp_config::SESSION_ID_PLACEHOLDER`). An account that writes it
+    /// nowhere is launched with no id at all, which is the state a CLI with no
+    /// resume of its own is permanently in.
+    ///
+    /// Absent is a real state and the common one. An account that declares no
+    /// resume line is launched fresh into a reopened topic and reads back what
+    /// it needs through the room's own pull instead (#115, decision 4C).
+    #[serde(default)]
+    pub resume_command: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -154,6 +181,11 @@ impl Default for AppConfig {
                 hue: None,
                 kind: AccountKind::Ai,
                 character: None,
+                // Nothing, rather than a line guessed from the command above.
+                // A resume line naming the wrong flag fails at the one moment
+                // it is needed, and the person has no reason to go looking at a
+                // field they never filled in.
+                resume_command: None,
             }],
         }
     }
@@ -201,6 +233,10 @@ pub fn load_config(app: AppHandle) -> Result<AppConfig, String> {
     // joining under — lives in the webview's own storage and never reached
     // this file (#59).
     //
+    // `resume_command` is the same shape of nothing again: an account saved
+    // before it existed declares no way of resuming, which is what every
+    // account did then — there was no topic for a session to be resumed into.
+    //
     // `character` is the same again, and its absence is the state it means:
     // an account saved before it existed declared no character, so its launch
     // reads whatever its working directory's own `settings.json` names — which
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 567c5ee..43d8914 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -47,7 +47,12 @@ pub fn run() {
             room::room_participants,
             room::room_join,
             room::room_post,
-            room_log::room_log,
+            room::room_current_topic,
+            room::room_new_topic,
+            room::room_select_topic,
+            room_log::room_topics,
+            room_log::room_topic_log,
+            room_log::room_rename_topic,
             session::seated_accounts,
             session::parse_launch_options,
             session::preview_launch_args,
diff --git a/src-tauri/src/room.rs b/src-tauri/src/room.rs
index accc533..2d83954 100644
--- a/src-tauri/src/room.rs
+++ b/src-tauri/src/room.rs
@@ -80,7 +80,7 @@
 //! the room before the disk is touched, and a failure there costs the record,
 //! not the utterance (#48).
 
-use crate::room_log;
+use crate::room_log::{self, TopicRef};
 use futures_util::{SinkExt, StreamExt};
 use parking_lot::Mutex;
 use room_floor::{Admission, Floor, Missed, Post};
@@ -104,7 +104,10 @@ use uuid::Uuid;
 /// 5: `hello` may carry the `account_id` the session was launched as, and the
 ///    roster hands it back. Carried only — identity stays on the connection
 ///    (#59).
-pub const PROTOCOL_VERSION: u32 = 5;
+/// 6: `history` / `history_result` — a participant may pull what was said in
+///    the current topic before it arrived. Pull only: the room still pushes
+///    nothing it did not fan out live (#115, decision 4C).
+pub const PROTOCOL_VERSION: u32 = 6;
 
 /// One post of the room, as the frontend sees it.
 ///
@@ -202,6 +205,13 @@ struct IncomingFrame {
     ts: Option<String>,
     last_seen: Option<String>,
     protocol: Option<u32>,
+    /// Correlates a `history` request with the `history_result` that answers
+    /// it, the way `message_id` correlates a post with its receipt. Minted by
+    /// the asker: two pulls may be in flight, and settling the wrong one would
+    /// hand back another request's posts.
+    request_id: Option<String>,
+    limit: Option<usize>,
+    before: Option<String>,
 }
 
 /// What the room holds about one seated participant.
@@ -232,6 +242,19 @@ struct RoomInner {
     /// than beside the lock so the check and the stamp are one critical
     /// section (#47).
     floor: Floor,
+    /// The topic the room is in: where a post is written down, and what a pull
+    /// reads back.
+    ///
+    /// Under the same lock the floor is, for the same reason the append is
+    /// inside the critical section — a post has to reach the file of the topic
+    /// it was admitted into, and reading the topic outside the acquisition
+    /// leaves a window where a switch lands between the two.
+    ///
+    /// It exists before anything is written down. A launch opens a new topic
+    /// (#115, Master 判断5) and most runs of the app say nothing, so the index
+    /// entry waits for the first post rather than the app being opened
+    /// (`room_log::TopicRef`).
+    topic: TopicRef,
 }
 
 /// The name whoever is on `origin` answers to, or `None` when no one is seated
@@ -273,6 +296,10 @@ impl RoomState {
                 port: None,
                 participants: BTreeMap::new(),
                 floor: Floor::new(),
+                // A new one, every launch. Nothing of the previous run is
+                // reopened by starting the app: the room begins empty and a
+                // past topic is opened by being picked (#48 / #115).
+                topic: TopicRef::new(now_iso()),
             })),
             to_participants,
             token: Uuid::new_v4().to_string(),
@@ -379,6 +406,35 @@ impl RoomState {
     fn unseat(&self, origin: &str) {
         self.inner.lock().participants.remove(origin);
     }
+
+    /// The topic the room is in.
+    pub fn topic(&self) -> TopicRef {
+        self.inner.lock().topic.clone()
+    }
+
+    /// Put the room in a topic.
+    ///
+    /// **The floor is emptied and every seat is put back to its start.** A
+    /// topic is where the conversation is, so the floor of the one being left
+    /// is not the floor of the one being entered — and a watermark naming a
+    /// post from elsewhere resolves to position 0, which the floor reads as
+    /// having seen nothing (`room-floor`). Left standing, the first thing said
+    /// in a reopened topic would be refused and handed back the whole of the
+    /// previous topic's retained floor, by a participant who had in fact seen
+    /// all of it.
+    ///
+    /// The seats stay. Switching a topic does not put anyone out of the room:
+    /// the sessions are still connected and the person is still at the screen.
+    /// What changes is where they are speaking.
+    pub fn enter_topic(&self, topic: TopicRef) {
+        let mut inner = self.inner.lock();
+        inner.topic = topic;
+        inner.floor.reset();
+        let start = inner.floor.seq();
+        for seat in inner.participants.values_mut() {
+            seat.since = start;
+        }
+    }
 }
 
 /// A hue is a position on the colour wheel, so it is taken modulo a turn rather
@@ -469,7 +525,7 @@ fn deliver(
 
     // One acquisition, both halves. Concurrent speakers serialise here, so the
     // loser's check runs against a floor the winner has already changed.
-    let (admission, hue, logged) = {
+    let (admission, hue, logged, topic) = {
         let mut inner = room.inner.lock();
         let (since, hue) = match inner.participants.get(origin) {
             Some(seat) => (seat.since, seat.hue),
@@ -496,11 +552,17 @@ fn deliver(
         // The failure is carried out rather than reported here: the room is
         // stopped while this lock is held, and telling the screen is not work
         // to do with everyone waiting.
+        //
+        // The topic is read under this same acquisition, so the post reaches
+        // the file of the topic it was admitted into. Read outside it, a switch
+        // landing between the two would put a post in one topic's order and the
+        // other topic's file.
+        let topic = inner.topic.clone();
         let logged = match &admission {
-            Admission::Admitted { .. } => room_log::append(app, &post),
-            Admission::Unseen(_) => Ok(()),
+            Admission::Admitted { .. } => room_log::append(app, &topic.topic_id, &post),
+            Admission::Unseen(_) => Ok(false),
         };
-        (admission, hue, logged)
+        (admission, hue, logged, topic)
     };
 
     if let Admission::Unseen(missed) = admission {
@@ -515,8 +577,14 @@ fn deliver(
     // the record, never the utterance — so nothing below is conditional on
     // this, and the one thing that must not happen is it passing unnoticed
     // (#48).
-    if let Err(err) = logged {
-        room_log::report(app, err);
+    match logged {
+        Err(err) => room_log::report(app, err),
+        // The first thing said in this topic. The topic gets its entry and its
+        // name from it, out here rather than under the lock: the index is a
+        // second file read and rewritten whole, and nothing about a post waits
+        // on it (#115, decision 9).
+        Ok(true) => room_log::realize_from_first_post(app, &topic, &post.content),
+        Ok(false) => {}
     }
 
     let mut frame = serde_json::json!({
@@ -563,6 +631,47 @@ fn deliver(
     }
 }
 
+/// How many posts one pull answers with when the asker names no number.
+const HISTORY_PAGE: usize = 50;
+
+/// The most one pull answers with, whatever the asker names.
+///
+/// A topic has no ceiling, and a participant asking for all of one would be
+/// handed a context's worth of text in a single tool result. The page and the
+/// `before` cursor together are what make a long topic readable in the
+/// direction it is actually read — backwards from the end.
+const HISTORY_MAX: usize = 200;
+
+/// One page of a topic, oldest first, ending at `before`.
+///
+/// The tail of the eligible window rather than its head: what a participant
+/// joining late needs first is what was just said, and paging further back is
+/// what `before` is for. `has_more` says whether there is anything older, so
+/// the asker knows whether the top of the page is the top of the topic.
+///
+/// A `before` the topic does not contain is read as naming its end. Erring the
+/// other way — answering with nothing — would be indistinguishable from an
+/// empty topic, and the asker would stop.
+fn history_answer(
+    request_id: &str,
+    posts: Vec<room_log::LoggedPost>,
+    before: Option<&str>,
+    limit: Option<usize>,
+) -> serde_json::Value {
+    let end = before
+        .and_then(|id| posts.iter().position(|post| post.message_id == id))
+        .unwrap_or(posts.len());
+    let window = &posts[..end];
+    let limit = limit.unwrap_or(HISTORY_PAGE).clamp(1, HISTORY_MAX);
+    let start = window.len().saturating_sub(limit);
+    serde_json::json!({
+        "type": "history_result",
+        "request_id": request_id,
+        "posts": &window[start..],
+        "has_more": start > 0,
+    })
+}
+
 /// Bind the room socket and start accepting sidecars.
 ///
 /// Port 0: the OS picks. The port is handed to sidecars through `.mcp.json`,
@@ -788,6 +897,43 @@ async fn serve_participant(
                     frame: receipt.to_string(),
                 });
             }
+            // The read-out (#115, decision 4C). A participant asks for what
+            // was said in the current topic before it got here; the room
+            // answers on this connection alone.
+            //
+            // **Pull, and only pull.** The room still fans out nothing it did
+            // not deliver live — a later joiner missed what predates its seat,
+            // and that is unchanged. What changes is that the participant can
+            // now go and get it, which is a different thing from the room
+            // holding who has heard what (#31 / #39). Nothing here is recorded
+            // against the asker, and asking twice is the same as asking once.
+            //
+            // The topic is read and the lock released before the file is
+            // touched: this is the room's own lock, and a read of a log with
+            // no ceiling is not work to do with everyone waiting.
+            "history" => {
+                let request_id = frame.request_id.unwrap_or_default();
+                let topic = room.topic();
+                let answer = match room_log::topic_posts(&app, &topic.topic_id) {
+                    Ok(posts) => history_answer(&request_id, posts, frame.before.as_deref(), frame.limit),
+                    Err(err) => {
+                        room_log::report(&app, err.clone());
+                        // Said rather than answered with an empty page: a
+                        // participant told "nothing was said" would go on to
+                        // act on that.
+                        serde_json::json!({
+                            "type": "history_result",
+                            "request_id": request_id,
+                            "error": err,
+                        })
+                    }
+                };
+                let _ = room.to_participants.send(Fanout {
+                    origin: origin.clone(),
+                    target: Some(origin.clone()),
+                    frame: answer.to_string(),
+                });
+            }
             _ => {}
         }
     }
@@ -815,6 +961,53 @@ pub fn room_participants(state: tauri::State<RoomState>) -> Vec<Participant> {
     state.participants()
 }
 
+/// The topic the room is in.
+///
+/// It may not be in the index yet — a launch opens a new one and nothing is
+/// written until something is said in it (#115) — so the screen draws this
+/// beside the list rather than looking for it inside the list.
+#[tauri::command]
+pub fn room_current_topic(state: tauri::State<RoomState>) -> TopicRef {
+    state.topic()
+}
+
+/// Cut here: a new topic, current from now on.
+///
+/// The 新規 button, and the whole of what a topic boundary is — drawn by hand,
+/// independent of when the app was started (#115, decision 1). Nothing is
+/// written down: the index entry waits for the first post, so a topic opened
+/// and left unspoken leaves no row behind.
+#[tauri::command]
+pub fn room_new_topic(state: tauri::State<RoomState>) -> TopicRef {
+    let topic = TopicRef::new(now_iso());
+    state.enter_topic(topic.clone());
+    topic
+}
+
+/// Put an existing topic back in the room.
+///
+/// Selecting one from the list. What comes back with it is its posts, which the
+/// screen reads for itself, and the session each account was in, which a launch
+/// reads when a seat is started (`session.rs`). Nothing is started here: the
+/// topic opens whether or not anything can be resumed into it (#115, decision
+/// 6).
+#[tauri::command]
+pub fn room_select_topic(
+    app: AppHandle,
+    state: tauri::State<RoomState>,
+    topic_id: String,
+    created_at: String,
+) -> Result<(), String> {
+    if !room_log::topic_exists(&app, &topic_id) {
+        return Err(format!("トピック {topic_id} は見つかりません。"));
+    }
+    state.enter_topic(TopicRef {
+        topic_id,
+        created_at,
+    });
+    Ok(())
+}
+
 /// Seat this screen's person in the room, under the name and hue they declared.
 ///
 /// A person is in the room by being there, not by speaking: without this the
diff --git a/src-tauri/src/room_log.rs b/src-tauri/src/room_log.rs
index fa3ddf8..1a384fb 100644
--- a/src-tauri/src/room_log.rs
+++ b/src-tauri/src/room_log.rs
@@ -1,19 +1,43 @@
-//! The room's log.
+//! The room's log, kept one file per topic.
 //!
-//! What was said in the room, kept as one append-only jsonl file so a past
-//! exchange can be read back after the window that showed it has closed. The
-//! room itself keeps nothing: its lines live in the DOM, and closing the app
-//! took them (#48).
+//! What was said in the room, so an exchange can be read back after the window
+//! that showed it has closed. The room itself keeps nothing: its lines live in
+//! the DOM, and closing the app took them (#48).
 //!
-//! The log is the room's, not a tab's. `config.rs` already holds a saving
-//! apparatus — `SavedChatMessage` / `SessionData` / `TabSessions` — and none of
-//! it is used here, deliberately. `SavedChatMessage` carries `role` and
-//! `content_type`, which is a chat assistant's vocabulary: the room has no axis
-//! `role` lands on, because a person and a session are one kind of participant
-//! and what separates two lines is the name on them (#39). `TabSessions` is
-//! keyed on a tab, and a tab is how something is launched, not the vessel a
-//! conversation happens in. Wiring either through would put the asymmetry #39
-//! removed back into the app from underneath.
+//! **A topic is the unit.** The log used to be one file per room and one flow
+//! of posts, which is the shape #48 left behind and #115 replaces: a topic is
+//! not a section of a transcript, it is the vessel a conversation happens in.
+//! Opening one puts it back in the room and the talk continues in it. The
+//! boundary between two topics is drawn by hand — 新規 — and has nothing to do
+//! with when the app was started: one run may hold several topics, and one
+//! topic may span several runs.
+//!
+//! The layout that follows from that:
+//!
+//! ```text
+//! logs/{room}/index.json      one entry per topic: name, when it was made,
+//!                             and the session each account was in
+//! logs/{room}/{topic}.jsonl   one topic's posts, append-only
+//! ```
+//!
+//! One file per topic rather than one file with a `topic_id` column, for two
+//! reasons that both have to hold. Reading one topic reads one file, where a
+//! column would make every read a read of everything ever said (#114). And a
+//! topic has something to carry that a post does not: the session each account
+//! was in while it was open. A per-post column has nowhere to put that; the
+//! index does.
+//!
+//! **The directory is what exists; the index annotates it.** A topic's posts
+//! are the file, and `read_index` adopts any `.jsonl` it finds without an
+//! entry. That is what makes lazy creation safe: a launch mints a topic and
+//! writes nothing, so a run where nothing was said leaves no row in the list
+//! (#115, 決定5から導かれること) — and the one window that would otherwise
+//! open, a crash between the post reaching the file and the entry reaching the
+//! index, closes because the file alone is enough to rebuild the entry.
+//!
+//! `logs/{room}.jsonl` from before this — the single flow — is carried in as
+//! one topic the first time the index is built. It is moved, not copied and not
+//! dropped (#115, decision 8), and the scan above is what gives it its entry.
 //!
 //! One line is one post, and it carries the five fields a post is:
 //! `message_id` / `speaker` / `content` / `to` / `ts`.
@@ -26,23 +50,24 @@
 //! spoke (`room.rs`) — so a file that recorded it would be recording one
 //! viewer's position as if it were part of the utterance.
 //!
-//! The file name is `logs/{room}.jsonl`, which is where `design/Vision.dc.html`
-//! put it. The room's name occupies a position in that path and is fixed at
-//! `main`: several rooms are not implemented, and the path is shaped so that
+//! The room's name occupies a position in the path and is fixed at `main`:
+//! several rooms are not implemented, and the path is shaped so that
 //! implementing them adds a value here rather than a directory level (#48).
 //!
-//! No rotation and no ceiling. Vision holds one `main.jsonl` carrying no date,
-//! and a log that drops its own oldest entries answers the question this exists
-//! for — what was actually said — with silence at exactly the distance that
-//! makes the question worth asking.
+//! No rotation and no ceiling, per topic or across them. A log that drops its
+//! own oldest entries answers the question this exists for — what was actually
+//! said — with silence at exactly the distance that makes the question worth
+//! asking.
 
+use parking_lot::Mutex;
 use room_floor::Post;
 use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
 use std::io::Write;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use tauri::{AppHandle, Emitter, Manager};
 
-/// The room whose log this is, as it appears in the file name.
+/// The room whose log this is, as it appears in the path.
 ///
 /// One room, and this constant is the seam rather than the omission: what a
 /// second room would need is another value here, not another shape of path.
@@ -56,6 +81,29 @@ const ROOM_NAME: &str = "main";
 /// quietly (#48).
 const LOG_ERROR_EVENT: &str = "room-log-error";
 
+/// The event the topic list reaches the screen on.
+///
+/// Emitted whenever the index changes under the screen rather than because of
+/// it: a topic realised by its own first post, or a session id recorded by a
+/// launch. What the screen did itself it already knows about, and is told again
+/// here rather than being trusted to keep a second copy in step.
+const TOPICS_EVENT: &str = "room-topics";
+
+/// How long an auto-generated title is allowed to be, in characters.
+///
+/// Characters rather than bytes: the titles are Japanese more often than not,
+/// and a byte cut would land inside one.
+const TITLE_CHARS: usize = 40;
+
+/// One acquisition for every read-modify-write of the index.
+///
+/// The index is a single small file read and rewritten whole. Two writers
+/// interleaving would drop one of the two changes — a launch recording a
+/// session id while a post realises the topic it landed in is the concrete
+/// pair — and neither is a change anyone would notice losing until the topic
+/// failed to resume.
+static INDEX_LOCK: Mutex<()> = Mutex::new(());
+
 /// One post, as the log holds it.
 ///
 /// The same five fields going in and coming out.
@@ -89,7 +137,98 @@ impl LoggedPost {
     }
 }
 
-fn log_path(app: &AppHandle) -> Result<PathBuf, String> {
+/// One topic, as the index holds it.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Topic {
+    /// Opaque, minted once, and the file name of this topic's posts. Never a
+    /// title: a title is edited, and a file whose name moved with it would
+    /// leave the posts behind.
+    pub topic_id: String,
+    /// What the list shows. Generated from the opening of the first post said
+    /// in it and editable afterwards (#115, decision 9). Empty until that first
+    /// post lands, which is a state the screen draws rather than a value
+    /// missing.
+    pub title: String,
+    /// When it was made, RFC 3339. The room's clock (`room::now_iso`), or the
+    /// first post's own stamp for a topic adopted from a file.
+    pub created_at: String,
+    /// The session each account was in while this topic was open, keyed by
+    /// account id.
+    ///
+    /// This is what makes a topic a vessel rather than a transcript: reopening
+    /// it hands these back to the launch, and the participant returns carrying
+    /// its own context instead of being read a summary of it (#115, decisions 3
+    /// and 4).
+    ///
+    /// Keyed on the account id, which is the identity (#53). Not on the name,
+    /// which is editable, and not on the room's connection id, which is minted
+    /// per connection and is gone by the time a topic is reopened.
+    #[serde(default)]
+    pub sessions: BTreeMap<String, String>,
+}
+
+/// The topic the room is in, before anything has been said in it.
+///
+/// Held by the room rather than written down. A launch opens a new topic
+/// (#115, Master 判断5) and most of what an app run does is not speaking, so a
+/// row written at launch would be a row for every time the app was opened.
+#[derive(Debug, Clone, Serialize)]
+pub struct TopicRef {
+    pub topic_id: String,
+    pub created_at: String,
+}
+
+impl TopicRef {
+    pub fn new(created_at: String) -> Self {
+        TopicRef {
+            topic_id: uuid::Uuid::new_v4().to_string(),
+            created_at,
+        }
+    }
+}
+
+/// The topics, as the file holds them.
+///
+/// Oldest first, by `created_at`. The screen reverses it — a list is read
+/// newest first — and the file keeps the order the conversation happened in.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+struct TopicIndex {
+    #[serde(default)]
+    topics: Vec<Topic>,
+}
+
+impl TopicIndex {
+    fn find(&self, topic_id: &str) -> Option<&Topic> {
+        self.topics.iter().find(|one| one.topic_id == topic_id)
+    }
+
+    fn find_mut(&mut self, topic_id: &str) -> Option<&mut Topic> {
+        self.topics.iter_mut().find(|one| one.topic_id == topic_id)
+    }
+}
+
+fn room_dir(app: &AppHandle) -> Result<PathBuf, String> {
+    let dir = app
+        .path()
+        .app_data_dir()
+        .map_err(|e| format!("Failed to resolve app data dir: {e}"))?;
+    Ok(dir.join("logs").join(ROOM_NAME))
+}
+
+fn index_path(app: &AppHandle) -> Result<PathBuf, String> {
+    Ok(room_dir(app)?.join("index.json"))
+}
+
+/// Where one topic's posts live.
+///
+/// The id is a UUID minted by `TopicRef`, so nothing a person types reaches a
+/// path. A title with a slash in it would otherwise be a directory.
+fn topic_path(app: &AppHandle, topic_id: &str) -> Result<PathBuf, String> {
+    Ok(room_dir(app)?.join(format!("{topic_id}.jsonl")))
+}
+
+/// The single flow this log kept before topics existed.
+fn legacy_path(app: &AppHandle) -> Result<PathBuf, String> {
     let dir = app
         .path()
         .app_data_dir()
@@ -97,7 +236,183 @@ fn log_path(app: &AppHandle) -> Result<PathBuf, String> {
     Ok(dir.join("logs").join(format!("{ROOM_NAME}.jsonl")))
 }
 
-/// Put one post at the end of the log.
+/// Carry the pre-topic single flow in as one topic.
+///
+/// Moved rather than copied. Two files holding one conversation is a second
+/// ordering of it, and the one thing the room is the authority on is that there
+/// is one (`room.rs`). Nothing is dropped: the posts are the file, and the file
+/// is what moves (#115, decision 8). The entry it gets is the scan's, like any
+/// other file in the directory.
+///
+/// Call under `INDEX_LOCK`.
+fn migrate_legacy(app: &AppHandle) -> Result<(), String> {
+    let legacy = legacy_path(app)?;
+    if !legacy.is_file() {
+        return Ok(());
+    }
+    let dir = room_dir(app)?;
+    std::fs::create_dir_all(&dir).map_err(|e| format!("Failed to create the room log dir: {e}"))?;
+    let destination = dir.join(format!("{}.jsonl", uuid::Uuid::new_v4()));
+    if std::fs::rename(&legacy, &destination).is_ok() {
+        return Ok(());
+    }
+    // `rename` fails across volumes, which is not a case this app's own app
+    // data directory produces. The fallback's result is taken from the remove:
+    // a copy that succeeded and a remove that failed is the one way this ends
+    // with the conversation in two places.
+    std::fs::copy(&legacy, &destination)
+        .map_err(|e| format!("Failed to carry the existing log into a topic: {e}"))?;
+    std::fs::remove_file(&legacy)
+        .map_err(|e| format!("Failed to remove the log after carrying it into a topic: {e}"))
+}
+
+/// Read the index off disk and reconcile it with the directory.
+///
+/// The reconciliation is not a repair path bolted on: it is what lets a topic
+/// exist before any entry is written for it. An entry with no file stays — a
+/// topic whose session was launched but which nobody has spoken in yet is that
+/// case, and its session id is the whole reason to keep it.
+///
+/// Call under `INDEX_LOCK`.
+fn read_index(app: &AppHandle) -> Result<TopicIndex, String> {
+    migrate_legacy(app)?;
+
+    let path = index_path(app)?;
+    let mut index = if path.exists() {
+        let content = std::fs::read_to_string(&path)
+            .map_err(|e| format!("Failed to read the topic index: {e}"))?;
+        serde_json::from_str::<TopicIndex>(&content)
+            .map_err(|e| format!("Failed to parse the topic index: {e}"))?
+    } else {
+        TopicIndex::default()
+    };
+
+    let adopted = adopt_orphans(app, &mut index)?;
+    index
+        .topics
+        .sort_by(|a, b| a.created_at.cmp(&b.created_at).then(a.topic_id.cmp(&b.topic_id)));
+    if adopted || !path.exists() {
+        write_index(app, &index)?;
+    }
+    Ok(index)
+}
+
+/// Give an entry to every topic file the index does not name.
+///
+/// Answers true when it changed anything.
+fn adopt_orphans(app: &AppHandle, index: &mut TopicIndex) -> Result<bool, String> {
+    let dir = room_dir(app)?;
+    let Ok(entries) = std::fs::read_dir(&dir) else {
+        // No directory is no topics, not a failure. It is the first run.
+        return Ok(false);
+    };
+    let mut adopted = false;
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.extension().and_then(|ext| ext.to_str()) != Some("jsonl") {
+            continue;
+        }
+        let Some(topic_id) = path.file_stem().and_then(|stem| stem.to_str()) else {
+            continue;
+        };
+        if index.find(topic_id).is_some() {
+            continue;
+        }
+        let (posts, _) = read_posts(&path);
+        let first = posts.first();
+        index.topics.push(Topic {
+            topic_id: topic_id.to_string(),
+            title: first.map(|post| title_from(&post.content)).unwrap_or_default(),
+            // The first thing said in it, which is the closest thing a file
+            // carries to when it began. A topic made through the app has its
+            // own stamp and never reaches here.
+            created_at: first
+                .map(|post| post.ts.clone())
+                .unwrap_or_else(crate::room::now_iso),
+            sessions: BTreeMap::new(),
+        });
+        adopted = true;
+    }
+    Ok(adopted)
+}
+
+/// Call under `INDEX_LOCK`.
+fn write_index(app: &AppHandle, index: &TopicIndex) -> Result<(), String> {
+    let path = index_path(app)?;
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| format!("Failed to create the room log dir: {e}"))?;
+    }
+    let content = serde_json::to_string_pretty(index)
+        .map_err(|e| format!("Failed to serialize the topic index: {e}"))?;
+    std::fs::write(&path, content).map_err(|e| format!("Failed to write the topic index: {e}"))
+}
+
+/// Make sure `topic` has an entry, and hand back a mutable hold on it.
+///
+/// The one place a topic reaches the index. Every caller is a deliberate act
+/// that has to survive the app closing — the first post, a session id, a
+/// rename — and none of them is "the app was opened".
+///
+/// Call under `INDEX_LOCK`.
+fn realize<'a>(index: &'a mut TopicIndex, topic: &TopicRef) -> &'a mut Topic {
+    if index.find(&topic.topic_id).is_none() {
+        index.topics.push(Topic {
+            topic_id: topic.topic_id.clone(),
+            title: String::new(),
+            created_at: topic.created_at.clone(),
+            sessions: BTreeMap::new(),
+        });
+    }
+    index
+        .find_mut(&topic.topic_id)
+        .expect("just inserted when absent")
+}
+
+/// A title from the opening of the first thing said in the topic.
+///
+/// The first line, whitespace collapsed, cut at `TITLE_CHARS`. A list of
+/// timestamps is a list nobody can read (#115, decision 9), and the opening of
+/// the first post is what a person would have written there anyway.
+fn title_from(content: &str) -> String {
+    let flat = content.split_whitespace().collect::<Vec<_>>().join(" ");
+    if flat.is_empty() {
+        return String::new();
+    }
+    let mut chars = flat.chars();
+    let head: String = chars.by_ref().take(TITLE_CHARS).collect();
+    if chars.next().is_some() {
+        format!("{head}…")
+    } else {
+        head
+    }
+}
+
+/// Say on the screen that the log failed.
+///
+/// The room went on without it, so nothing here stops anything. What it stops is
+/// the failure being invisible: a log that had quietly stopped recording would
+/// still look like a log, and would read as nothing having been said (#48).
+pub fn report(app: &AppHandle, message: String) {
+    eprintln!("[room] {message}");
+    let _ = app.emit(LOG_ERROR_EVENT, message);
+}
+
+/// Hand the screen the topic list as it now stands.
+fn announce(app: &AppHandle) {
+    let read = {
+        let _guard = INDEX_LOCK.lock();
+        read_index(app)
+    };
+    match read {
+        Ok(index) => {
+            let _ = app.emit(TOPICS_EVENT, index.topics);
+        }
+        Err(err) => report(app, err),
+    }
+}
+
+/// Put one post at the end of a topic.
 ///
 /// Called from inside the room's own critical section, which is what makes the
 /// file's order the floor's order. The alternative — appending once the lock is
@@ -105,18 +420,30 @@ fn log_path(app: &AppHandle) -> Result<PathBuf, String> {
 /// in whichever order the scheduler hands them, and the room would then hold two
 /// orderings of one conversation instead of one (`room.rs`).
 ///
-/// Returns the failure rather than reporting it. The caller is holding the room
-/// lock at this point, and emitting from under it would be doing the screen's
-/// work with the room stopped; `room.rs` reports once it is out.
+/// Returns whether this was the first post of its topic, so the caller can
+/// realise and name the topic once it is out of the lock. The index is a second
+/// file read and rewritten whole, and it has no business happening with the room
+/// stopped; nothing about a post waits on it.
+///
+/// Returns the failure rather than reporting it, for the same reason: the caller
+/// is holding the room lock at this point, and emitting from under it would be
+/// doing the screen's work with the room stopped; `room.rs` reports once it is
+/// out.
 ///
 /// The content may contain newlines. It stays one line per post regardless,
 /// because what is written is JSON and JSON escapes them.
-pub fn append(app: &AppHandle, post: &Post) -> Result<(), String> {
-    let path = log_path(app)?;
+pub fn append(app: &AppHandle, topic_id: &str, post: &Post) -> Result<bool, String> {
+    let path = topic_path(app, topic_id)?;
     if let Some(parent) = path.parent() {
         std::fs::create_dir_all(parent)
             .map_err(|e| format!("Failed to create the room log dir: {e}"))?;
     }
+    // Read before the write, so "first" means the first in the topic and not
+    // the first this process wrote. A missing file and an empty one are the
+    // same state here.
+    let first = std::fs::metadata(&path)
+        .map(|meta| meta.len() == 0)
+        .unwrap_or(true);
 
     let mut line = serde_json::to_string(&LoggedPost::of(post))
         .map_err(|e| format!("Failed to serialize the post: {e}"))?;
@@ -130,43 +457,57 @@ pub fn append(app: &AppHandle, post: &Post) -> Result<(), String> {
     // One write of the whole line, so no line is half put down by one call and
     // finished by another's.
     file.write_all(line.as_bytes())
-        .map_err(|e| format!("Failed to append to the room log: {e}"))
+        .map_err(|e| format!("Failed to append to the room log: {e}"))?;
+    Ok(first)
 }
 
-/// Say on the screen that the log failed.
+/// Give a topic its entry and its name, from the first thing said in it.
 ///
-/// The room went on without it, so nothing here stops anything. What it stops is
-/// the failure being invisible: a log that had quietly stopped recording would
-/// still look like a log, and would read as nothing having been said (#48).
-pub fn report(app: &AppHandle, message: String) {
-    eprintln!("[room] {message}");
-    let _ = app.emit(LOG_ERROR_EVENT, message);
+/// Out of the room's lock. Silent about a title when the topic already has one:
+/// a title the person edited is theirs, and a first post arriving in a topic
+/// renamed before anyone spoke would otherwise take it back.
+pub fn realize_from_first_post(app: &AppHandle, topic: &TopicRef, content: &str) {
+    let written = {
+        let _guard = INDEX_LOCK.lock();
+        match read_index(app) {
+            Err(err) => {
+                report(app, err);
+                return;
+            }
+            Ok(mut index) => {
+                let entry = realize(&mut index, topic);
+                if entry.title.is_empty() {
+                    entry.title = title_from(content);
+                }
+                match write_index(app, &index) {
+                    Ok(()) => true,
+                    Err(err) => {
+                        report(app, err);
+                        false
+                    }
+                }
+            }
+        }
+    };
+    if written {
+        announce(app);
+    }
 }
 
-/// The log, oldest first.
-///
-/// For the screen, and only for the screen. Nothing here is re-delivered to
-/// participants: a session that joined late missed what predates its seat, and
-/// that is the room's existing answer (`room.rs`). Feeding the log back into a
-/// channel would make the room start holding who has heard what, which is the
-/// shape #31 and #39 turned down.
+/// One topic's posts, oldest first.
 ///
-/// A line that does not parse is skipped rather than failing the read. The case
-/// it covers is a torn tail from a run that ended mid-write, and refusing the
-/// whole history over the last line of it would lose everything to protect
-/// nothing. It is not skipped quietly — the count goes back to the screen on
-/// the same event a failed append does.
-#[tauri::command]
-pub fn room_log(app: AppHandle) -> Result<Vec<LoggedPost>, String> {
-    let path = log_path(&app)?;
-    // No file is no history, not a failure. It is what the first run of the app
-    // looks like.
-    if !path.exists() {
-        return Ok(Vec::new());
-    }
-
-    let content =
-        std::fs::read_to_string(&path).map_err(|e| format!("Failed to read the room log: {e}"))?;
+/// The tuple's second half is how many lines did not parse. A line that does
+/// not parse is skipped rather than failing the read: the case it covers is a
+/// torn tail from a run that ended mid-write, and refusing the whole topic over
+/// the last line of it would lose everything to protect nothing. It is not
+/// skipped quietly — the count goes back to the screen on the same event a
+/// failed append does.
+fn read_posts(path: &Path) -> (Vec<LoggedPost>, usize) {
+    // No file is no history, not a failure. It is what a topic nobody has
+    // spoken in yet looks like.
+    let Ok(content) = std::fs::read_to_string(path) else {
+        return (Vec::new(), 0);
+    };
 
     let mut posts = Vec::new();
     let mut skipped = 0usize;
@@ -179,10 +520,130 @@ pub fn room_log(app: AppHandle) -> Result<Vec<LoggedPost>, String> {
             Err(_) => skipped += 1,
         }
     }
+    (posts, skipped)
+}
 
+/// One topic's posts, for a caller inside this process.
+///
+/// The pull the sidecar's read tool reaches (`room.rs`), and the same read the
+/// screen makes. One function, so the two surfaces cannot disagree about what a
+/// topic contains.
+pub fn topic_posts(app: &AppHandle, topic_id: &str) -> Result<Vec<LoggedPost>, String> {
+    let path = topic_path(app, topic_id)?;
+    let (posts, skipped) = read_posts(&path);
     if skipped > 0 {
-        report(&app, format!("読めなかった記録が {skipped} 件あります"));
+        report(app, format!("読めなかった記録が {skipped} 件あります"));
     }
-
     Ok(posts)
 }
+
+/// The session `account_id` was in while `topic_id` was open, if one is on
+/// record.
+pub fn session_of(app: &AppHandle, topic_id: &str, account_id: &str) -> Option<String> {
+    let _guard = INDEX_LOCK.lock();
+    read_index(app)
+        .ok()?
+        .find(topic_id)?
+        .sessions
+        .get(account_id)
+        .cloned()
+}
+
+/// Whether a topic has an entry in the index.
+///
+/// What selecting one from the list is checked against. A topic the room is
+/// currently in but nothing has realised yet answers false here, and the room
+/// answers for that one itself (`room.rs`).
+pub fn topic_exists(app: &AppHandle, topic_id: &str) -> bool {
+    let _guard = INDEX_LOCK.lock();
+    read_index(app)
+        .map(|index| index.find(topic_id).is_some())
+        .unwrap_or(false)
+}
+
+/// Record which session an account was launched into a topic under.
+///
+/// Written at launch rather than at exit, because the id is decided before the
+/// CLI starts and a session that ends badly is exactly the one worth being able
+/// to resume. It realises the topic: starting a session in a topic is a
+/// deliberate act, and the id has to outlive the run to be worth anything.
+pub fn record_session(
+    app: &AppHandle,
+    topic: &TopicRef,
+    account_id: &str,
+    session_id: &str,
+) -> Result<(), String> {
+    {
+        let _guard = INDEX_LOCK.lock();
+        let mut index = read_index(app)?;
+        realize(&mut index, topic)
+            .sessions
+            .insert(account_id.to_string(), session_id.to_string());
+        write_index(app, &index)?;
+    }
+    announce(app);
+    Ok(())
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+
+/// The topics, oldest first.
+///
+/// The topic the room is currently in is in this list only once something has
+/// realised it. The screen holds its own current topic and draws it whether or
+/// not the list names it (`room_current_topic`).
+#[tauri::command]
+pub fn room_topics(app: AppHandle) -> Result<Vec<Topic>, String> {
+    let _guard = INDEX_LOCK.lock();
+    Ok(read_index(&app)?.topics)
+}
+
+/// One topic's posts, oldest first.
+///
+/// For the screen. The topic is named rather than assumed, because the screen
+/// reads a topic that is not the current one every time the list is used: that
+/// is what selecting one is.
+#[tauri::command]
+pub fn room_topic_log(app: AppHandle, topic_id: String) -> Result<Vec<LoggedPost>, String> {
+    topic_posts(&app, &topic_id)
+}
+
+/// Rename a topic.
+///
+/// The generated title is a starting point in an editable field, which is the
+/// same thing an account's name is (#115, decision 9). Blank is refused rather
+/// than stored: an empty title is the state a topic has before anything is said
+/// in it, and a topic deliberately cleared would read as one nobody has spoken
+/// in.
+///
+/// Realising is deliberate here too — naming a topic before speaking in it is
+/// the person deciding it exists.
+#[tauri::command]
+pub fn room_rename_topic(
+    app: AppHandle,
+    state: tauri::State<crate::room::RoomState>,
+    topic_id: String,
+    title: String,
+) -> Result<(), String> {
+    let title = title.trim().to_string();
+    if title.is_empty() {
+        return Err("トピック名を入力してください。".to_string());
+    }
+    {
+        let _guard = INDEX_LOCK.lock();
+        let mut index = read_index(&app)?;
+        match index.find_mut(&topic_id) {
+            Some(topic) => topic.title = title,
+            None => {
+                let current = state.topic();
+                if current.topic_id != topic_id {
+                    return Err(format!("トピック {topic_id} は見つかりません。"));
+                }
+                realize(&mut index, &current).title = title;
+            }
+        }
+        write_index(&app, &index)?;
+    }
+    announce(&app);
+    Ok(())
+}
diff --git a/src-tauri/src/session.rs b/src-tauri/src/session.rs
index 879ffcb..30ea819 100644
--- a/src-tauri/src/session.rs
+++ b/src-tauri/src/session.rs
@@ -11,9 +11,11 @@
 use crate::config::{Account, AccountKind};
 use crate::pty::{self, PtyState};
 use crate::room::RoomState;
+use crate::room_log::{self, TopicRef};
 use mcp_config::{
-    declared_character, declares_settings, launch_args, other_room_servers, register_sidecar,
-    reject_incompatible_flags, server_name_for, RoomRegistration,
+    declared_character, declares_session_id, declares_settings, launch_args, other_room_servers,
+    register_sidecar, reject_incompatible_flags, server_name_for, split_launch_options,
+    substitute_session_id, RoomRegistration,
 };
 use parking_lot::Mutex;
 use std::collections::BTreeMap;
@@ -284,6 +286,95 @@ pub fn preview_launch_args(
     launch_args(&args, &server_name, character.as_deref(), &others)
 }
 
+/// The line one launch runs, resolved against the topic it is being started
+/// into.
+///
+/// Two lines exist for one account and this picks between them. The account's
+/// own command starts a session; its resume line puts it back into one it was
+/// already in, and which applies is not a property of the account — it is
+/// whether *this topic* holds a session for it (#115, decisions 3 and 4B).
+struct LaunchLine {
+    command: String,
+    args: Vec<String>,
+    /// The session id this launch is handing the CLI, when it is handing one.
+    ///
+    /// `Some` only on a fresh launch that had somewhere to put it: the id is
+    /// decided here and recorded on the topic, so the next opening of that
+    /// topic has something to resume. A resume passes an id it was given and
+    /// mints nothing, so it is `None` — there is nothing new to record.
+    session_id: Option<String>,
+    /// Whether this is the resume line rather than the launch line.
+    resumed: bool,
+}
+
+/// Which of the account's two lines this launch is, and with which id.
+///
+/// Resume needs both halves: a session recorded for this account in this topic,
+/// and a line that knows how to go back into one. Missing either, the launch is
+/// a fresh one — the account then reads back what it needs through the room's
+/// own pull instead, which is the second tier of the two-tier answer and the
+/// reason a missing resume line is a degraded state rather than a failure
+/// (#115, decision 4).
+///
+/// A fresh launch mints an id whenever the account's options name the
+/// placeholder, including when the topic already holds one. The old id is
+/// replaced rather than kept: without a resume line it can never be used again,
+/// and what a topic should hold is the session that is actually in it.
+fn resolve_launch(
+    app: &AppHandle,
+    account: &Account,
+    topic: &TopicRef,
+) -> Result<LaunchLine, String> {
+    let recorded = room_log::session_of(app, &topic.topic_id, &account.id);
+    let resume = account
+        .resume_command
+        .as_deref()
+        .map(str::trim)
+        .filter(|line| !line.is_empty());
+
+    if let (Some(session_id), Some(line)) = (recorded.as_deref(), resume) {
+        let mut parts = split_launch_options(line);
+        // The first token is the command, and a resume line whose first token
+        // is empty would spawn nothing under a name the person never chose. The
+        // reachable way in is a line of nothing but quotes, which splits into
+        // one empty token rather than into none.
+        let command = if parts.is_empty() {
+            String::new()
+        } else {
+            parts.remove(0)
+        };
+        if command.is_empty() {
+            return Err(format!(
+                "Account \"{}\" has a resume command with no command in it. Write the whole line, command first.",
+                account.name.trim()
+            ));
+        }
+        return Ok(LaunchLine {
+            command,
+            args: substitute_session_id(&parts, session_id),
+            session_id: None,
+            resumed: true,
+        });
+    }
+
+    if declares_session_id(&account.args) {
+        let session_id = uuid::Uuid::new_v4().to_string();
+        return Ok(LaunchLine {
+            command: account.command.clone(),
+            args: substitute_session_id(&account.args, &session_id),
+            session_id: Some(session_id),
+            resumed: false,
+        });
+    }
+
+    Ok(LaunchLine {
+        command: account.command.clone(),
+        args: account.args.clone(),
+        session_id: None,
+        resumed: false,
+    })
+}
+
 /// What the caller gets back after a session joins.
 #[derive(Debug, serde::Serialize)]
 pub struct StartedSession {
@@ -298,6 +389,15 @@ pub struct StartedSession {
     /// late. Same clock as a post's `ts`, so the panel's start time and the
     /// first line of the conversation can be read against each other.
     pub started_at: String,
+    /// True when this went in through the account's resume line rather than its
+    /// launch line.
+    ///
+    /// Handed back so the screen can say which of the two happened. Under
+    /// decision 6 a topic opens whether or not a seat could be resumed, and a
+    /// seat that came back fresh is not a failure — but it is a different thing
+    /// from one that came back carrying its own context, and the person is the
+    /// one who can tell whether that matters.
+    pub resumed: bool,
 }
 
 /// Put one account into the room.
@@ -348,7 +448,17 @@ pub fn start_session(
         ));
     }
 
-    if let Err(flag) = reject_incompatible_flags(&account.args) {
+    // Which topic this seat is being started into. Read from the room rather
+    // than passed in by the screen: the room is where the current topic lives,
+    // and a value carried through the screen could name a topic the room has
+    // since left.
+    let topic = room.topic();
+    // Resume or fresh, decided here so every check below runs against the line
+    // that will actually be spawned. Checking the account's own options and
+    // then spawning the resume line would be checking the wrong line.
+    let launch_line = resolve_launch(&app, &account, &topic)?;
+
+    if let Err(flag) = reject_incompatible_flags(&launch_line.args) {
         return Err(format!(
             "Account \"{name}\" passes {flag}, which stops channel pushes from arriving. \
              Remove it from the launch options."
@@ -397,7 +507,7 @@ pub fn start_session(
     // as the sibling's sidecar started anyway (#103). Refused rather than
     // stripped, for the reason the flag guard above is: a launch that quietly
     // dropped half of what was asked for looks like it worked.
-    if (character.is_some() || !others.is_empty()) && declares_settings(&account.args) {
+    if (character.is_some() || !others.is_empty()) && declares_settings(&launch_line.args) {
         // Two refusals rather than one sentence with a hole in it: what the
         // person can do about it differs. A character is theirs to clear; a
         // sibling registration is another account's, and the way out of that
@@ -427,10 +537,11 @@ pub fn start_session(
     })?;
 
     match launch(
-        app,
+        app.clone(),
         &room,
         pty_state,
         &account,
+        &launch_line,
         &name,
         character,
         &others,
@@ -441,6 +552,22 @@ pub fn start_session(
         rows,
     ) {
         Ok(started) => {
+            // On the topic, so the next opening of it can resume this session.
+            // Recorded after the spawn rather than before: an id written for a
+            // launch that failed would be resumed into a session that was never
+            // started.
+            //
+            // A failure here does not fail the launch. The session is running —
+            // what is lost is the ability to resume it later, and the room's own
+            // pull still stands for that topic (#115, decision 4C). It is said
+            // on the same surface a failed append is said on, for the same
+            // reason: a record that quietly stopped being kept still looks like
+            // one.
+            if let Some(session_id) = &launch_line.session_id {
+                if let Err(err) = room_log::record_session(&app, &topic, &account.id, session_id) {
+                    room_log::report(&app, err);
+                }
+            }
             // The launch's own values, not the account's. The account may be
             // edited while this runs, and what is running would then be
             // reported as whatever was typed into the form afterwards.
@@ -449,7 +576,9 @@ pub fn start_session(
                 RunningSession {
                     pty_id: started.pty_id.clone(),
                     started_at: started.started_at.clone(),
-                    command: account.command.clone(),
+                    // The line that ran, which on a resume is not the account's
+                    // launch command at all.
+                    command: launch_line.command.clone(),
                     cwd: cwd.to_string_lossy().to_string(),
                 },
             );
@@ -475,6 +604,9 @@ fn launch(
     room: &RoomState,
     pty_state: tauri::State<PtyState>,
     account: &Account,
+    // Command and arguments as resolved against the topic, so what is spawned
+    // is what was checked.
+    line: &LaunchLine,
     name: &str,
     character: Option<&str>,
     // The sibling registrations this session must not start, read from the
@@ -508,12 +640,12 @@ fn launch(
     let pty_id = pty::spawn_pty(
         app,
         pty_state,
-        account.command.clone(),
+        line.command.clone(),
         // The same function the preview goes through, so what the form showed
         // is what spawns. Nothing is written for the settings: `--settings`
         // takes the JSON inline, and a file per account would grow the very
         // directory this account is sharing (#99).
-        launch_args(&account.args, server_name, character, others),
+        launch_args(&line.args, server_name, character, others),
         cols,
         rows,
         Some(cwd.to_string_lossy().to_string()),
@@ -523,5 +655,6 @@ fn launch(
         pty_id,
         mcp_config: mcp_config.to_string_lossy().to_string(),
         started_at,
+        resumed: line.resumed,
     })
 }
diff --git a/src/main.ts b/src/main.ts
index 3d3260d..0d003a5 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -89,6 +89,39 @@ interface LoggedPost {
   ts: string;
 }
 
+/**
+ * One topic, as the index holds it (src-tauri/src/room_log.rs).
+ *
+ * The vessel a conversation happens in, not a section of a transcript. Picking
+ * one puts its posts back in the room and hands its session ids to the next
+ * launch, so what comes back is the participants' own context rather than a
+ * reading of the log to them (#115).
+ */
+interface Topic {
+  topic_id: string;
+  /** Generated from the first post's opening, editable after. Empty until that
+   *  post lands, which the list draws as its own state rather than as a blank. */
+  title: string;
+  created_at: string;
+  /** Which session each account was in while this was open, by account id.
+   *  Read by the launch, never by the screen — it is here because the index
+   *  entry carries it, not because anything on this side decides on it. */
+  sessions: Record<string, string>;
+}
+
+/**
+ * The topic the room is in.
+ *
+ * Held apart from the list because it may not be in the list: a launch opens a
+ * new topic and nothing is written down until something is said in it, so the
+ * index has no entry for it yet (#115). The panel draws this whether or not the
+ * list names it.
+ */
+interface TopicRef {
+  topic_id: string;
+  created_at: string;
+}
+
 /**
  * One participant of the room, as the roster lists them.
  *
@@ -153,6 +186,17 @@ interface Account {
    *  rather than a string inside `args`, for the reason the name and the hue
    *  are attributes (#40) — it is who this account is when it runs (#99). */
   character: string | null;
+  /** The whole command line that puts this account back into a session it was
+   *  already in, with `{session_id}` where the id goes — or null when it
+   *  declares none. A topic holds which session each account was in while it
+   *  was open, and reopening one hands that id to this line: what comes back is
+   *  the participant's own context, carried by the CLI rather than read out to
+   *  it (#115, decision 4B).
+   *
+   *  Null is the common state. An account with no resume line joins a reopened
+   *  topic as a new session and pulls what it needs out of the room instead
+   *  (#115, decision 4C). */
+  resume_command: string | null;
 }
 
 interface AppConfig {
@@ -164,6 +208,12 @@ interface StartedSession {
   mcp_config: string;
   /** When the session was launched, stamped by the room's own clock. */
   started_at: string;
+  /** True when this went in through the account's resume line rather than its
+   *  launch line — the topic held a session for it, and the CLI came back
+   *  carrying its own context (#115, decision 4B). False is not a failure: it
+   *  is a seat starting fresh in a reopened topic, which is what a topic does
+   *  for every seat it cannot resume (decision 6). */
+  resumed: boolean;
 }
 
 /**
@@ -305,8 +355,8 @@ const DERIVED_ARC = 360 - RESERVED_ARC * 2;
 
 const roomEl = document.getElementById("room") as HTMLElement;
 const rosterEl = document.getElementById("roster") as HTMLElement;
-const historyEl = document.getElementById("history") as HTMLElement;
-const historyListEl = document.getElementById("history-list") as HTMLElement;
+const topicListEl = document.getElementById("topic-list") as HTMLElement;
+const topicNewEl = document.getElementById("topic-new") as HTMLButtonElement;
 const accountNewEl = document.getElementById("account-new") as HTMLButtonElement;
 const inputEl = document.getElementById("input") as HTMLTextAreaElement;
 const sendEl = document.getElementById("send") as HTMLButtonElement;
@@ -336,6 +386,7 @@ const dialogLaunchEl = document.getElementById("dialog-launch") as HTMLElement;
 const dialogCwdEl = document.getElementById("dialog-cwd") as HTMLInputElement;
 const dialogCharacterEl = document.getElementById("dialog-character") as HTMLInputElement;
 const dialogOptionsEl = document.getElementById("dialog-options") as HTMLInputElement;
+const dialogResumeEl = document.getElementById("dialog-resume") as HTMLInputElement;
 const dialogPreviewEl = document.getElementById("dialog-preview") as HTMLElement;
 const dialogErrorEl = document.getElementById("dialog-error") as HTMLElement;
 const dialogDeleteEl = document.getElementById("dialog-delete") as HTMLButtonElement;
@@ -386,6 +437,14 @@ let homeDir = "";
  * two. A person who leaves a message unread on screen is a gap the room cannot
  * see and does not pretend to (#47).
  */
+/**
+ * The topics as the index holds them, oldest first, and the one the room is in.
+ *
+ * Two values because the current one may not be in the list: a launch opens a
+ * new topic and nothing is written down until something is said in it (#115).
+ */
+let topics: Topic[] = [];
+let currentTopic: TopicRef | null = null;
 let lastSeenId: string | null = null;
 /**
  * Every `message_id` this screen has put on the glass.
@@ -915,47 +974,76 @@ function shortDateTime(iso: string): string {
   return `${day} ${at.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`;
 }
 
-function appendMessage(message: RoomMessage): void {
-  // The room is scrolled to the bottom only when it already was, so reading
-  // back through the log is not yanked away by an arriving message.
-  const atBottom = roomEl.scrollHeight - roomEl.scrollTop - roomEl.clientHeight < 40;
-
-  const line = document.createElement("article");
-  line.className = "message";
-  // `own` rather than a name test: the room decides self on the connection a
-  // post arrived on, which a rename cannot blur (#40).
-  line.style.setProperty(
-    "--speaker",
-    speakerColor(message.speaker, message.hue, message.own),
-  );
+/**
+ * One line of the room, whenever it was said.
+ *
+ * The same element for a post arriving now and a post read back out of the
+ * topic's log, because they are the same conversation: picking a topic puts its
+ * posts in the room rather than beside it (#115, decision 2). What differs is
+ * the stamp — a line said in this window is placed by its clock, one from
+ * before it by its day as well — and that is passed in rather than decided
+ * here.
+ */
+function roomLine(line: {
+  speaker: string;
+  colour: string;
+  to: string | null;
+  ts: string;
+  stamp: string;
+  content: string;
+  past: boolean;
+}): HTMLElement {
+  const article = document.createElement("article");
+  article.className = line.past ? "message past" : "message";
+  article.style.setProperty("--speaker", line.colour);
 
   const head = document.createElement("div");
   head.className = "meta";
 
   const speaker = document.createElement("span");
   speaker.className = "speaker";
-  speaker.textContent = message.speaker;
+  speaker.textContent = line.speaker;
   head.appendChild(speaker);
 
-  if (message.to) {
+  if (line.to) {
     const to = document.createElement("span");
     to.className = "to";
-    to.textContent = `→ ${message.to}`;
+    to.textContent = `→ ${line.to}`;
     head.appendChild(to);
   }
 
   const time = document.createElement("time");
   time.className = "ts";
-  time.dateTime = message.ts;
-  time.textContent = shortTime(message.ts);
+  time.dateTime = line.ts;
+  time.textContent = line.stamp;
   head.appendChild(time);
 
   const body = document.createElement("div");
   body.className = "body";
-  body.textContent = message.content;
+  body.textContent = line.content;
+
+  article.append(head, body);
+  return article;
+}
 
-  line.append(head, body);
-  roomEl.appendChild(line);
+function appendMessage(message: RoomMessage): void {
+  // The room is scrolled to the bottom only when it already was, so reading
+  // back through the log is not yanked away by an arriving message.
+  const atBottom = roomEl.scrollHeight - roomEl.scrollTop - roomEl.clientHeight < 40;
+
+  roomEl.appendChild(
+    roomLine({
+      speaker: message.speaker,
+      // `own` rather than a name test: the room decides self on the connection
+      // a post arrived on, which a rename cannot blur (#40).
+      colour: speakerColor(message.speaker, message.hue, message.own),
+      to: message.to,
+      ts: message.ts,
+      stamp: shortTime(message.ts),
+      content: message.content,
+      past: false,
+    }),
+  );
   // On the glass, so it is what this screen can declare having seen. Own posts
   // included: the room does not hold a speaker's own posts against them, and
   // carrying the newest id either way keeps this one value rather than two.
@@ -966,90 +1054,244 @@ function appendMessage(message: RoomMessage): void {
 }
 
 /**
- * Draw what was said before this window opened.
+ * Put a topic's posts in the room, in place of whatever was there.
  *
- * Read once, at launch, out of the room's log. It never follows along after
- * that, and the reason is the division the two surfaces are built on: the room
- * starts empty every run (#48), so what is beside this strip is this run and
- * what is in it is everything before. A strip that grew as posts arrived would
- * be a second drawing of the conversation already on the glass next to it, and
- * the boundary that tells the two apart would stop existing.
+ * Picking a topic is picking where the conversation is, so what is drawn is the
+ * topic itself and not a strip beside it. #48 held the opposite — the room
+ * started empty and the past was read in a column of its own — and #115
+ * overwrites that line: the column is a list of topics now, and the room is
+ * where a topic is read.
  *
- * Oldest first, as the file holds them and as the room draws them, and opened
- * at the end. The two are one reading: the last line here was said just before
- * the first line of the room beside it, so the bottom of this strip is where
- * the conversation is continuous and the top is months back. A panel that
- * opened at its oldest entry would put the far side of the log in front of the
- * person every time, and the log has no ceiling to keep that distance short.
+ * The watermark is cleared rather than set to the last line drawn. These posts
+ * are not on the floor: entering a topic empties it and puts the seats back to
+ * its start (`RoomState::enter_topic`). A watermark naming a post the floor
+ * does not hold resolves to position 0, which is the same answer as declaring
+ * none — so clearing it says the true thing rather than the equivalent one.
  *
- * The colour is derived from the name, because the log does not carry the
- * declaration (see `LoggedPost`). `own` is passed false for the same reason —
- * the file records what was said, not who was watching — so nothing here is
- * drawn in this screen's accent.
+ * The ids are kept, because they are on the glass: a refusal that hands back
+ * the whole retained floor must not draw a line twice (#108).
+ *
+ * The colour is derived from the name and `own` is false for every line. The
+ * log carries neither declaration (see `LoggedPost`), so nothing read back is
+ * in this screen's accent — this screen's own past words included.
  */
-function renderHistory(posts: LoggedPost[]): void {
-  historyListEl.replaceChildren();
+function drawTopic(posts: LoggedPost[]): void {
+  roomEl.replaceChildren();
+  lastSeenId = null;
+  drawnIds.clear();
 
-  if (posts.length === 0) {
+  for (const post of posts) {
+    roomEl.appendChild(
+      roomLine({
+        speaker: post.speaker,
+        colour: speakerColor(post.speaker, null, false),
+        to: post.to ?? null,
+        ts: post.ts,
+        // The day as well as the clock. A topic spans days, and a bare 14:32
+        // could be any of them.
+        stamp: shortDateTime(post.ts),
+        content: post.content,
+        past: true,
+      }),
+    );
+    drawnIds.add(post.message_id);
+  }
+
+  // Opened at the end, which is where the conversation continues.
+  roomEl.scrollTop = roomEl.scrollHeight;
+}
+
+/** When a topic was made, for a list that spans months. */
+function topicWhen(iso: string): string {
+  const at = new Date(iso);
+  if (Number.isNaN(at.getTime())) return "";
+  const day = at.toLocaleDateString([], {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  });
+  return `${day} ${at.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`;
+}
+
+/**
+ * The topics, newest first, with the current one marked.
+ *
+ * Newest first because that is the end a list of conversations is read from.
+ * The file keeps them in the order they happened, which is the order an append
+ * produces; the reversal is a reading decision rather than a storage one.
+ *
+ * The current topic is drawn whether or not the index names it. A launch opens
+ * a new topic and writes nothing until something is said in it, so at the top
+ * of every run there is exactly one topic in the room and not in the list
+ * (#115).
+ */
+function renderTopics(): void {
+  topicListEl.replaceChildren();
+
+  const listed = [...topics].reverse();
+  const current = currentTopic;
+  if (current && !listed.some((one) => one.topic_id === current.topic_id)) {
+    // Not yet written down, and drawn as itself rather than as a gap. A room
+    // whose own topic is missing from its own list would read as a fault.
+    listed.unshift({
+      topic_id: current.topic_id,
+      title: "",
+      created_at: current.created_at,
+      sessions: {},
+    });
+  }
+
+  if (listed.length === 0) {
     const empty = document.createElement("li");
     empty.className = "empty";
-    // Not an error, and not "history unavailable". A room nobody has spoken in
-    // yet is the first run of the app, and it has a log that says so.
-    empty.textContent = "記録なし";
-    historyListEl.appendChild(empty);
+    empty.textContent = "トピックなし";
+    topicListEl.appendChild(empty);
     return;
   }
 
-  for (const post of posts) {
-    const entry = document.createElement("li");
-    entry.className = "entry";
-    entry.style.setProperty("--speaker", speakerColor(post.speaker, null, false));
-
-    const meta = document.createElement("div");
-    meta.className = "meta";
-
-    const speaker = document.createElement("span");
-    speaker.className = "speaker";
-    speaker.textContent = post.speaker;
-    meta.appendChild(speaker);
-
-    if (post.to) {
-      const to = document.createElement("span");
-      to.className = "to";
-      to.textContent = `→ ${post.to}`;
-      meta.appendChild(to);
+  for (const topic of listed) topicListEl.appendChild(topicRow(topic));
+}
+
+/** One row of the list: the whole row is the control that opens it. */
+function topicRow(topic: Topic): HTMLLIElement {
+  const row = document.createElement("li");
+  row.className = "topic";
+  if (topic.topic_id === currentTopic?.topic_id) row.classList.add("current");
+
+  const pick = document.createElement("button");
+  pick.type = "button";
+  pick.className = "pick";
+
+  const name = document.createElement("span");
+  name.className = topic.title ? "name" : "name unnamed";
+  // A topic nobody has spoken in yet. Said rather than left blank: blank is
+  // also what a row would look like if its title had failed to read.
+  name.textContent = topic.title || "未命名";
+  pick.appendChild(name);
+
+  const when = document.createElement("span");
+  when.className = "when";
+  when.textContent = topicWhen(topic.created_at);
+  pick.appendChild(when);
+
+  pick.addEventListener("click", () => void openTopic(topic));
+  // Renamed where it is read. The generated title is a starting point in an
+  // editable field, the same thing an account's name is (#115, decision 9).
+  pick.addEventListener("dblclick", (event) => {
+    event.preventDefault();
+    beginRename(row, topic);
+  });
+
+  row.appendChild(pick);
+  return row;
+}
+
+/**
+ * Rename one topic in place.
+ *
+ * Escape and losing focus both mean 取消, Enter means 決定 — the three ways out
+ * the account form has. The row is redrawn from the list on every path, so none
+ * of them leaves half an edit applied.
+ */
+function beginRename(row: HTMLLIElement, topic: Topic): void {
+  const field = document.createElement("input");
+  field.type = "text";
+  field.className = "rename";
+  field.value = topic.title;
+  field.spellcheck = false;
+
+  let settled = false;
+  const cancel = (): void => {
+    if (settled) return;
+    settled = true;
+    renderTopics();
+  };
+  const commit = (): void => {
+    if (settled) return;
+    settled = true;
+    const title = field.value.trim();
+    if (!title || title === topic.title) {
+      renderTopics();
+      return;
+    }
+    void invoke("room_rename_topic", { topicId: topic.topic_id, title })
+      .then(() => status(`トピックを「${title}」にしました。`))
+      .catch((err) => status(`トピック名を変えられませんでした: ${err}`, "error"))
+      // The list arrives on `room-topics` when the rename lands. This redraw is
+      // for the path where it did not: a field left standing over a failed
+      // rename is an edit that looks like it took.
+      .finally(() => renderTopics());
+  };
+
+  field.addEventListener("keydown", (event) => {
+    if (event.isComposing) return;
+    if (event.key === "Enter") {
+      event.preventDefault();
+      commit();
+    } else if (event.key === "Escape") {
+      event.preventDefault();
+      cancel();
     }
+  });
+  field.addEventListener("blur", () => cancel());
 
-    const time = document.createElement("time");
-    time.className = "ts";
-    time.dateTime = post.ts;
-    // The date as well as the clock. In the room the day is the one being
-    // lived through and the clock alone reads; here it is whichever day this
-    // was said on, and a bare 14:32 could be any of them.
-    time.textContent = shortDateTime(post.ts);
-    meta.appendChild(time);
-
-    const body = document.createElement("div");
-    body.className = "body";
-    body.textContent = post.content;
-
-    entry.append(meta, body);
-    historyListEl.appendChild(entry);
+  row.replaceChildren(field);
+  field.focus();
+  field.select();
+}
+
+/**
+ * Put a topic back in the room.
+ *
+ * The room is told first and the posts are read second: the room decides where
+ * the next post is written down, and drawing a topic the room is not in would
+ * show one conversation while another was being recorded.
+ *
+ * Nothing is launched. A topic opens whether or not the sessions it held can be
+ * resumed, and resuming one is a press of ▶ on its row afterwards (#115,
+ * decision 6).
+ */
+async function openTopic(topic: Topic): Promise<void> {
+  if (topic.topic_id === currentTopic?.topic_id) return;
+  try {
+    await invoke("room_select_topic", {
+      topicId: topic.topic_id,
+      createdAt: topic.created_at,
+    });
+    currentTopic = { topic_id: topic.topic_id, created_at: topic.created_at };
+    drawTopic(await invoke<LoggedPost[]>("room_topic_log", { topicId: topic.topic_id }));
+    renderTopics();
+    status(`トピック「${topic.title || "未命名"}」を開きました。`);
+  } catch (err) {
+    status(`トピックを開けませんでした: ${err}`, "error");
   }
+}
 
-  // The scroller is the panel, not the list: the heading is inside it and stays
-  // where it is only because it scrolls off with everything else, which is the
-  // same thing the account panel does.
-  historyEl.scrollTop = historyEl.scrollHeight;
+/**
+ * Cut here: a new topic, and an empty room.
+ *
+ * The boundary is drawn by hand and by nothing else. Starting the app opens one
+ * too, but the two are independent — one run may hold several topics, and one
+ * topic may span several runs (#115, decision 1).
+ */
+async function startNewTopic(): Promise<void> {
+  try {
+    currentTopic = await invoke<TopicRef>("room_new_topic");
+    drawTopic([]);
+    renderTopics();
+    status("新しいトピックを始めました。");
+  } catch (err) {
+    status(`新しいトピックを始められませんでした: ${err}`, "error");
+  }
 }
 
-/** Say on the history strip why it has nothing to show. */
-function historyFailed(reason: string): void {
-  historyListEl.replaceChildren();
+/** Say on the topic list why it has nothing to show. */
+function topicsFailed(reason: string): void {
+  topicListEl.replaceChildren();
   const line = document.createElement("li");
   line.className = "empty";
-  line.textContent = `履歴を読めませんでした: ${reason}`;
-  historyListEl.appendChild(line);
+  line.textContent = `トピックを読めませんでした: ${reason}`;
+  topicListEl.appendChild(line);
 }
 
 /**
@@ -1770,6 +2012,9 @@ function resolveLocalAccount(): void {
       // person speaks as themselves, and there is no launch to select a style
       // on.
       character: null,
+      // And for the same reason again: a person is not resumed into a topic,
+      // they are at the screen when it is opened.
+      resume_command: null,
     };
     accounts.push(account);
     saveAccounts();
@@ -2377,7 +2622,14 @@ async function startSession(account: Account): Promise<void> {
       cols: view.term.cols,
       rows: view.term.rows,
     });
-    status(`${name} を起動しました。${started.mcp_config} に登録済み。`);
+    // Which of the two lines ran is said, because the person is the one who
+    // can tell whether it mattered. A seat that came back fresh in a reopened
+    // topic is a legitimate outcome and not a silent one (#115, decision 6).
+    status(
+      started.resumed
+        ? `${name} を再開しました。${started.mcp_config} に登録済み。`
+        : `${name} を起動しました。${started.mcp_config} に登録済み。`,
+    );
     await refreshSeats();
     await followSession(view, started);
   } catch (err) {
@@ -2528,6 +2780,10 @@ function openAccountDialog(account: Account | null): void {
         // launches on whatever the working directory's own settings say, which
         // is an answer. A guessed name that resolves to no style is not.
         character: null,
+        // Nothing, for the same shape of reason: a resume line naming the wrong
+        // flag fails at the one moment it is needed, and the person has no
+        // reason to go looking at a field they never filled in.
+        resume_command: null,
       };
 
   dialogTitleEl.textContent = account ? "アカウントの編集" : "アカウントの追加";
@@ -2537,6 +2793,7 @@ function openAccountDialog(account: Account | null): void {
   dialogCwdEl.value = draft.cwd ?? "";
   dialogCharacterEl.value = draft.character ?? "";
   dialogOptionsEl.value = joinArgs(draft.args);
+  dialogResumeEl.value = draft.resume_command ?? "";
   dialogDeleteEl.hidden = account === null;
   disarmDelete();
   dialogError("");
@@ -2614,6 +2871,10 @@ async function commitAccountDialog(): Promise<boolean> {
     // Blank clears it, and clearing it is a state: the account goes back to
     // launching on whatever its working directory's own settings name.
     character: kind === "ai" ? character || null : null,
+    // Blank is a state here too, and the common one: an account with no resume
+    // line joins a reopened topic as a new session and reads back what it needs
+    // through the room's own pull instead (#115, decision 4C).
+    resume_command: kind === "ai" ? dialogResumeEl.value.trim() || null : null,
     args,
   };
 
@@ -2793,6 +3054,13 @@ async function main(): Promise<void> {
     trackAddress(event.payload);
   });
   await listen<Participant[]>("room-participants", (event) => renderRoster(event.payload));
+  // The index changed underneath: a topic realised by its own first post, or a
+  // session id recorded by a launch. Both happen without the screen asking, and
+  // the first is how a topic gets the name the list shows it under (#115).
+  await listen<Topic[]>("room-topics", (event) => {
+    topics = event.payload;
+    renderTopics();
+  });
   // The room went on without the log. Saying so is the whole of what this does
   // — a log that had quietly stopped recording would still look like a log, and
   // the next person to go looking would read the gap as nothing having been
@@ -2804,6 +3072,10 @@ async function main(): Promise<void> {
   // and the poll below is only for a listener that attached too late.
   await listen<number>("room-ready", (event) => renderSocket(event.payload));
 
+  // The one thing that draws a topic boundary. Beside the list it appears in,
+  // which is where ＋ sits on the panel opposite (#59).
+  topicNewEl.addEventListener("click", () => void startNewTopic());
+
   sendEl.addEventListener("click", () => void send());
   inputEl.addEventListener("keydown", (event) => {
     if (event.key === "Enter" && !event.shiftKey && !event.isComposing) {
@@ -2840,6 +3112,7 @@ async function main(): Promise<void> {
     dialogCwdEl,
     dialogCharacterEl,
     dialogOptionsEl,
+    dialogResumeEl,
   ]) {
     field.addEventListener("input", () => disarmDelete());
   }
@@ -2886,14 +3159,21 @@ async function main(): Promise<void> {
     status(`設定を読み込めませんでした: ${err}`, "error");
   }
 
-  // The history, read once. Outside the room's try below and independent of it:
-  // the log is a file this app wrote, so a room that never answers is no reason
-  // for the strip to stay blank — what was said last week is readable whether
-  // or not anything is listening now (#48).
+  // The topics, read once. Outside the room's try below and independent of it:
+  // the index is a file this app wrote, so a room that never answers is no
+  // reason for the list to stay blank — what was said last week is readable
+  // whether or not anything is listening now (#48).
+  //
+  // The room itself is left empty. Starting the app opens a new topic and does
+  // not continue the last one (#115, Master 判断5), so there is nothing to draw
+  // into it — which is the behaviour #48 had for a different reason and this
+  // keeps for its own: the past is opened by being picked.
   try {
-    renderHistory(await invoke<LoggedPost[]>("room_log"));
+    topics = await invoke<Topic[]>("room_topics");
+    currentTopic = await invoke<TopicRef>("room_current_topic");
+    renderTopics();
   } catch (err) {
-    historyFailed(String(err));
+    topicsFailed(String(err));
   }
 
   // Before the room, and outside its try. A session running under a seat this
diff --git a/src/styles.css b/src/styles.css
index 7c48bbc..bbc7e07 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -490,7 +490,7 @@ body {
   padding: 0.15rem 0.4rem;
 }
 
-/* ── history ─────────────────────────────────────────────────────────────── */
+/* ── topics ──────────────────────────────────────────────────────────────── */
 
 /* The other column, and the pair to #participants below: same width, same
    ground, and the border on the side that faces the conversation. Two panels
@@ -501,7 +501,11 @@ body {
    The rule below is the whole of what makes them a pair — `border-right` here
    against `border-left` there. Nothing else needs saying twice, because the
    parts inside are the panel's own vocabulary (`.panel-head`, `.panel-title`,
-   `.empty`) and those are shared. */
+   `.empty`) and those are shared.
+
+   The id is still `history`: what this column is for did not change — it is
+   where the past is reached from — and only its unit did, from a post to a
+   topic (#115). */
 #history {
   width: 16.5rem;
   flex: none;
@@ -528,67 +532,87 @@ body {
   font-weight: 600;
 }
 
-#history .history {
+/* 新規, and the same shape ＋ has on the panel opposite: the window's ground
+   with a border, because what separates a control from the surface it sits on
+   is the border and not a fill (see 二つの地色 in docs/0-requirements.md). */
+#history .panel-head button {
+  font: inherit;
+  line-height: 1;
+  color: var(--fg);
+  background: var(--bg);
+  border: 1px solid var(--line);
+  border-radius: 4px;
+  padding: 0.15rem 0.4rem;
+  cursor: pointer;
+}
+
+#history .topics {
   margin: 0;
   padding: 0 0.3rem 0.6rem;
   list-style: none;
   display: flex;
   flex-direction: column;
-  gap: 0.5rem;
+  gap: 0.15rem;
 }
 
-/* One past post. The same shape a line in the room has — a rule in the
-   speaker's colour down the left, the meta above the words — at the panel's
-   size rather than the conversation's. Reading it has to be reading the same
-   thing, or the two surfaces stop being one conversation seen from two
-   distances.
-
-   It does not carry `--room-font-size`. That size is declared on the two
-   elements rendering the conversation's own words and nowhere else (#81), and
-   this is a panel; it takes the panel's size like the roster beside it. */
-#history .entry {
-  border-left: 3px solid var(--speaker, var(--line));
-  padding: 0.1rem 0.4rem 0.1rem 0.5rem;
+/* One topic. A row that is picked, so it is the shape a picked row has on the
+   panel opposite — the whole row is the control, and the selected one is lifted
+   out of the panel's surface rather than tinted (#75). */
+#history .topic .pick {
+  width: 100%;
+  min-width: 0;
+  display: block;
+  font: inherit;
+  text-align: left;
+  color: var(--fg);
+  background: none;
+  border: 1px solid transparent;
+  border-radius: 4px;
+  padding: 0.3rem 0.4rem;
+  cursor: pointer;
 }
 
-#history .entry .meta {
-  display: flex;
-  align-items: baseline;
-  gap: 0.4rem;
-  font-size: 0.9em;
-  color: var(--muted);
+#history .topic.current .pick {
+  background: var(--bg);
+  border-color: var(--line);
 }
 
-#history .entry .speaker {
-  font-weight: 600;
-  color: var(--fg);
+/* The name, and the one part of the row that can be long. It takes one line and
+   ellipses: a list is read down its left edge, and a title that wrapped to three
+   lines would put the next topic wherever the last one happened to end. */
+#history .topic .name {
+  display: block;
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
 }
 
-/* Written in the speaker's colour, not the addressee's: it is part of what this
-   speaker said. Same reading as `.message .to`. */
-#history .entry .to {
-  color: var(--speaker, var(--accent));
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+/* A topic nobody has spoken in yet. Said rather than left blank, because blank
+   is what a row with a failed read would also look like. */
+#history .topic .name.unnamed {
+  color: var(--muted);
 }
 
-/* The time takes what the two above leave, and never shrinks: a stamp that
-   ellipsed would be the one part of the row that cannot be guessed from the
-   rest of it. */
-#history .entry .ts {
-  margin-left: auto;
-  flex: none;
+/* When it was made. The day, and the clock under it — a list of topics spans
+   months, so the day is the part that places one. */
+#history .topic .when {
+  display: block;
+  margin-top: 0.05rem;
+  color: var(--muted);
+  font-size: 0.9em;
 }
 
-#history .entry .body {
-  white-space: pre-wrap;
-  overflow-wrap: anywhere;
-  line-height: 1.5;
-  margin-top: 0.1rem;
+/* Renaming, in place. The generated title is a starting point in an editable
+   field, which is the same thing an account's name is (#115, decision 9), so it
+   is edited where it is read rather than in a form of its own. */
+#history .topic input.rename {
+  width: 100%;
+  font: inherit;
+  color: var(--fg);
+  background: var(--bg);
+  border: 1px solid var(--line);
+  border-radius: 4px;
+  padding: 0.25rem 0.35rem;
 }
 
 #history .empty {
@@ -596,6 +620,20 @@ body {
   color: var(--muted);
 }
 
+/* A line that was said before this window opened, drawn in the room among the
+   lines being said in it now.
+
+   Picking a topic puts its posts back in the room (#115, decision 2), which is
+   the constraint #48 held the other way — that one is overwritten. What is
+   drawn is the log, and the log carries no declared colour and no viewer's
+   position, so these lines take a colour derived from the name and none of them
+   is this screen's accent (see `LoggedPost` in src/main.ts). Nothing marks them
+   as past beyond that: they are the same conversation, and a badge saying which
+   side of a launch a line fell on would be an axis the room does not have. */
+#room .message.past .meta {
+  opacity: 0.75;
+}
+
 /* ── participants ────────────────────────────────────────────────────────── */
 
 #participants {