peertable 0.3.7 → 0.3.9

package/README.ja.md

@@ -75,6 +75,8 @@ docker compose -f deploy/compose.yaml up -d
 
 ライブビューはメンバーごとに vendor / model / effort と**稼働状態**（作業中・待機・**承認待ち**（許可ダイアログで止まっている）・停止）を出す。作業中の席はアイコンが動き、完了宣言（`[done]` / `[完了]` / `受理:` 等）の瞬間に席の上へ印が浮く。状態変化は SSE で押し込むので、30秒の再取得を待たず観測周期（約8秒）で切り替わる。発言にはログ番号（`[123]`）が付き、ライブ新着はブロック単位で現れる。**点が付かない席は「誰も報告していない席」**——状態の送信は別プロセス（スキルが起こす）で、**書けない時は常駐せずに死ぬ**ので「起きているのに黙っている」状態は存在しない。
 
+観測先は**席自身が名乗る**（`observe: {tmux_socket, tmux_target}`）。席の起動スクリプトと、席の中で動く MCP クライアントの両方が自分の tmux socket / session を登録するので、**スキル以外の経路で立てた席（aiterm の素の pane など）もそのまま観測対象になる**。表示名から `peer-<名前>` を推測しないので、任意のセッション名で立てた席が消える問題は起きない。名乗っていない古い席だけが従来の推測へ落ちる。常駐は専用 tmux セッションが保持し、**起動側は「起こした」ではなく「最初の観測が届いた」ことを確かめてから成功を返す**（確かめられなければログ末尾を出して非ゼロで落ちる）。
+
 API: `GET /api/<room>/messages` / `members` / `summary`（約120バイト・`seq`・`last_ts`・`member_count`）/ `events`（SSE）、`POST /api/<room>/messages` / `members`。
 
 **2. メンバーを着席させる。** room の MCP 定義は**プロジェクト root の `.mcp.json`** に置く:

package/README.md

@@ -111,6 +111,8 @@ Open `http://localhost:8790` — every room gets a live web view (SSE). **The we
 
 The live view shows, per member: vendor / model / reasoning effort, and a **working state** — 作業中 (busy) · 待機 (idle) · 承認待ち (blocked on a permission prompt) · 停止 (dead). A busy seat's avatar animates; a completion (`[done]` / `[完了]` / `受理:` …) pops a marker over the seat. State changes are pushed over SSE, so the icon turns within the observer's polling interval (~8s), not on the next 30-second refresh. Messages carry their log number (`[123]`) for quoting, and live arrivals reveal block by block. **A seat with no dot is one nobody is reporting on** — the state feed is a separate opt-in process (the skill starts it for you), and it refuses to run if it cannot write, so "running but silent" cannot happen.
 
+Seats **declare where to watch them** (`observe: {tmux_socket, tmux_target}`). Both the seat launcher and the MCP client running inside the seat register their own tmux socket and session, so **a seat you started outside the skill — a bare aiterm pane, say — is observed too**. Nothing infers `peer-<name>` from the display name, so a seat under an arbitrary session name no longer vanishes from the view; only seats that never declared fall back to the old guess. The state feed lives in its own tmux session, and whatever starts it waits for the **first observation to land** before reporting success — not merely for a process to exist. If it never lands, the starter prints the log tail and exits non-zero.
+
 Endpoints: `GET /api/<room>/messages` · `GET /api/<room>/members` · `GET /api/<room>/summary` (≈120 bytes: `seq`, `last_ts`, `member_count`) · `GET /api/<room>/events` (SSE) · `POST /api/<room>/messages` · `POST /api/<room>/members`.
 
 **2. Seat a member session.** The room MCP definition must live in the **project-root `.mcp.json`**:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peertable",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "A round table of peer agents. No orchestrator at the head. Turn Claude Code sessions into a team of equal, long-lived peers.",
   "type": "module",
   "license": "MIT",

package/room/client.mjs

@@ -5,12 +5,13 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'
 import { existsSync, readFileSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 // client.mjs 側のハードコード版数。package.json の version と一致していることを
 // diagnostics の version_consistency が見る（2 つの版数源の drift 検出。決定45）
-const MCP_VERSION = '0.3.7'
+const MCP_VERSION = '0.3.9'
 const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
 
 const USAGE = `usage:
@@ -121,10 +122,38 @@ await mcp.connect(new StdioServerTransport())
 // 素性（vendor/model/effort）は launch-seat.sh が env へ入れる。**登録のたびに載せる**——
 // 登録は client の起動ごとに繰り返し起きるので、1回きりの経路に置くと
 // member の状態が失われた時に二度と戻らない（server 側は渡された欄だけ更新する upsert）
+function observeSelf() {
+  if (!process.env.TMUX) {
+    process.stderr.write('peertable-client: observe unavailable: TMUX 不在\n')
+    return null
+  }
+  if (!process.env.TMUX_PANE) {
+    process.stderr.write('peertable-client: observe unavailable: TMUX_PANE 不在\n')
+    return null
+  }
+  const socket = process.env.TMUX.split(',')[0]
+  if (!socket) {
+    process.stderr.write('peertable-client: observe unavailable: TMUX の socket が空\n')
+    return null
+  }
+  try {
+    const target = execFileSync('tmux', ['-S', socket, 'display-message', '-p', '-t', process.env.TMUX_PANE, '#S'], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+    if (!target) throw new Error('session 名が空')
+    return { tmux_socket: socket, tmux_target: target }
+  } catch (error) {
+    process.stderr.write(`peertable-client: observe unavailable: ${error.message}\n`)
+    return null
+  }
+}
+
+const observe = observeSelf()
 const IDENTITY = Object.fromEntries(Object.entries({
   vendor: process.env.PEERTABLE_VENDOR,
   model: process.env.PEERTABLE_MODEL,
   effort: process.env.PEERTABLE_EFFORT,
+  observe,
 }).filter(([, v]) => v))
 await fetch(api('members'), { method: 'POST', headers, body: JSON.stringify({ name: ME, ...IDENTITY }) })
 {

package/skill/SKILL.md

@@ -46,11 +46,12 @@ description: 任意プロジェクトに Peertable チーム（対等メンバ
    - 着任指示を第6引数に渡すと着席後に送る。文面: 「あなたは「<日本語名>」。.team/roles/member.md を読んで着任し、作業ループを開始せよ。全タスク完了の宣言まで自律的に続けること。」
    - 席が読む env は script が組み立てる（`PEERTABLE_URL` / `PEERTABLE_ROOM` / `PEERTABLE_MEMBER` / `PEERTABLE_POST_TOKEN`、Lattice 併用なら `PEERTABLE_PLAN` と actor 3点）。**channels は `--mcp-config` の MCP server を解決しない**（実測 2026-08-08・Claude Code v2.1.226・決定44）ため、room の MCP 定義は setup.sh が project root へ置く `.mcp.json` が正。project に既存 `.mcp.json` があった場合 setup.sh は上書きせず警告を出すので、AI が手動 merge して teardown で復元する
    - **Codex 席**（`vendor=codex`）: Codex には channels が無いので、room は `-c` 上書きの stdio MCP として差す（`mcp_servers.room.command="peertable-client"` と `mcp_servers.room.env={…}`）。**env は closed mode で親環境を継がない**ので `PATH` を含む全変数を明示列挙する。effortはmember metadataだけでなく`model_reasoning_effort`へも同じ値を渡す。モデル名は ChatGPT アカウントで使える slug を渡す（`~/.codex/config.toml` の `model` が既定値の参考。使えない slug は起動後の最初のターンで 400 になって初めて分かる）。Codex 席を混ぜたら**必ず起床ブリッジを立てる**（下記）——立てないと room の新着で起きない
-6. **起床ブリッジ（Codex 席がある時だけ）**: `nohup node scripts/wakeup-bridge.mjs <project> <codex席名>… > <project>/.team/wakeup-bridge.log 2>&1 &`。room の SSE を購読し、明示的にその席宛の新着（自分の発言は除く）だけを tmux へ素送信して起こす。**Codex はターン実行中でも素送信を受け付け、その文言をそのターンの中で読む**（実測）ので idle 待ちはしない。停止は `node scripts/wakeup-bridge.mjs <project> --stop`（teardown.sh が自動で行う）
+6. **起床ブリッジ（Codex 席がある時だけ）**: `scripts/ensure-bridge.sh <project> wakeup <codex席名>…`。room の SSE を購読し、明示的にその席宛の新着（自分の発言は除く）だけを tmux へ素送信して起こす。ensure は専用 tmux session で起動し、bridge の `ready_at` を待つ。確認できなければログ末尾を出して非ゼロで終わる。**Codex はターン実行中でも素送信を受け付け、その文言をそのターンの中で読む**（実測）ので idle 待ちはしない。停止は `node scripts/wakeup-bridge.mjs <project> --stop`（teardown.sh が自動で行う）
    - **黙って止まらないための三段**（決定58 の受信側の作法）: ①75秒なにも届かなければ自分から切って繋ぎ直す ②繋ぎ直したら `?since=<最終seq>` で切れていた間の発言を回収する ③**心拍が積んでくる room の最新 seq が自分より進んでいたら、繋がったままでも回収する**——③が要るのは、心拍が届き続ける限り①が原理的に発火しないため。**server 側の心拍（`event: ping`・25秒周期）が前提**なので、古い room サーバーへ繋ぐと①だけが効く形になる
    - ログは `.team/wakeup-bridge.log`。**0件でも0件と出す**ので、起こせているか・取りこぼしていないかはログを見れば分かる。再現ハーネスは `experiments/bridge-catchup-repro.mjs`
 
-6.5 **席の稼働状態ブリッジ（setup.sh が自動で起こす）**: 手順3の scaffold が `nohup node scripts/seat-status-bridge.mjs <project> > <project>/.team/seat-status-bridge.log 2>&1 &` を起こすので、**AI が手で叩く段は無い**（手で起こし直す時だけ同じ command を使う）。**room の members に居る席だけ**の tmux pane を読み（`peer-<名前>`）、`busy`（画面に `esc to interrupt` が在る。**Claude 席・Codex 席の共通マーカーで、スピナーの語は毎回変わるので使わない**）／`blocked`（既知の承認ダイアログ文言が在る。判定順は busy → blocked → idle——承認プロンプト表示中は `esc to interrupt` が消えるため。動けない席を「待機」と誤表示しない）／`idle`／`dead`（`pane_dead`・セッション消失）を判定して room サーバーへ送る。**AI は使わず、席へは1バイトも送らない**。参加者一覧に点が出て、**報告が途絶えたら `unknown`（中空の輪）へ落ちる**——古い状態を出し続けない。**server が稼働状態を保持しない版なら1件も送らない**（送ると保存されないうえに system 発言を撒く）。停止は `node scripts/seat-status-bridge.mjs <project> --stop`（**teardown.sh が自動で行う**）
+6.5 **席の稼働状態ブリッジ（setup.sh が自動で起こす）**: 手順3の scaffold が `ensure-bridge.sh <project> seat-status` で起こすので、**AI が手で叩く段は無い**。観測先は member の `observe: {tmux_socket, tmux_target}` を優先し、無い既存memberだけ `peer-<名前>` へ後方互換で落とす。socket は明示env → aiterm POSIX既定 → 検証済み`/tmp/aiterm-*.sock`1本 → 既定パスの順で解決し、bashからは`tmux-socket.mjs`を呼ぶ。既に立っている席はclient再起動まで`observe`を自己申告しないため、`peer-`以外の席で記述子が要る時は席かclientを再起動する。WSLではbridgeが読む**WSL側**の版が正で、Windows側だけの更新では直らない。
+   - **`nohup` は使わない（決定74）。** `ensure-bridge.sh` が専用 tmux セッション `peertable-<bridge>-<room>` で常駐を保持する。tmux は**呼び出し元シェルの寿命に縛られない**——WSL の `wsl -e bash -lc` 経由だと `nohup` の子が呼び出し元と一緒に殺され、**初回1回だけ送信して死ぬ**（2026-08-11 実測。macOS では死なないので、この症状は WSL でしか出ない）。ensure は手渡された `PEERTABLE_TMUX_SOCKET` / `PEERTABLE_POST_TOKEN` / `PEERTABLE_URL` を command 側で明示して渡す——新 session が継ぐのは tmux *server* の環境で、呼び出し元 client の環境ではないため
    - **setup が起こし、teardown が止める（対称）。** 2026-08-10 までは「起こすかは卓の任意」で手で `nohup` する設計だったが、それが2つの失敗を招いたので変えた: 起こし忘れと、**トークンを持たないシェルで起こすこと**。後者は実害が出た——`~/.config/peertable.env` の `export` 欠落により、`source` した shell から起こした常駐がトークンを持たず、**4時間 HTTP 403 を撃ち続けた**。参加者一覧には点が1つも出ず、**「起こしていない」と見分けがつかなかった**
    - **書込トークンは起こす側の env に依存しない。** ブリッジ自身が `launch-seat.sh:25-27` と同じ規則で解決する（env が先・無ければ `~/.config/peertable.env` を読む。`export` の有無を問わない）。同じ規則を `run-bridge.mjs` も使う
    - **書けない常駐は生まれない。** 一度も書けていないまま送信が全件失敗したら `SEAT_STATUS_BRIDGE_WRITE_DENIED` で常駐に入らず死ぬ。一度書けた後の連続失敗は10回で `SEAT_STATUS_BRIDGE_UNREACHABLE`（wakeup-bridge と同じ本数・決定54）。**席がまだ立っていない tick は失敗に数えない**ので、setup 直後に起こしても死なない
@@ -98,7 +99,7 @@ description: 任意プロジェクトに Peertable チーム（対等メンバ
 - **席の作法の正本は `templates/member.md` の「Lattice の実行層へ自分の着手を載せる」節**（intake→intervention 判定→attach→作業→`todo done`→accept の順・1席1 intake・禁止操作・検証の回し方・成果の正本）。ここに二重化しない
 - **席は自分の pid を装置へ渡す（attach）。** その pid は `.team/seats/<名前>.json`（`launch-seat.sh` が着席直後に書く）が持ち、席は読んで `schema` を足すだけで attach input になる。**raw argv を保存しない**——Codex 起動の argv には `PEERTABLE_POST_TOKEN` が載るので、保存すれば秘密の複製になる（2026-08-09 実測）。持つのは digest だけ
 - **run-bridge は可視化の中継であって、必須経路ではない**（決定63）。落ちていても席は自分で intake / attach / accept を打てるし、介入も `lattice run intake intervention --run <ref> --task <id>` で自分で読める。**見えなくなるだけ**である
-- **ブリッジの起動**: `PEERTABLE_POST_TOKEN=… nohup node scripts/run-bridge.mjs <project> [--lattice <path>] > <project>/.team/run-bridge.log 2>&1 &`。停止は `node scripts/run-bridge.mjs <project> --stop`（**teardown.sh が自動で行う**）。**spool dir も席名も取らない**（配車をしないので要らない。渡すと typed error で落ちる）。ADR 0157 の作法（pid 記録・起動時に前の記録を掃除・SIGTERM→SIGKILL）はそのまま
+- **ブリッジの起動**: `scripts/ensure-bridge.sh <project> run [--lattice <path>]`。停止は `node scripts/run-bridge.mjs <project> --stop`（**teardown.sh が自動で行う**）。**spool dir も席名も取らない**（配車をしないので要らない。渡すと typed error で落ちる）。ADR 0157 の作法（pid 記録・起動時に前の記録を掃除・SIGTERM→SIGKILL）はそのまま
   - `--lattice <path>` は release 前の source tree を実測する時に使う。**PATH の install は version 表示が同じでも未 publish の schema を読めない**（2026-08-09 に卓で3件実測）
   - bridge が返すのは2つだけで**どちらも読み取り**: `[run] <run-id> intake=[…] accepted=[…] hold=[…] closed=…`（変化時だけ）と、`hold` になった intake をその作業を始めた席宛へ返す `[介入]`
 

package/skill/scripts/archive-room-log.py

@@ -3,7 +3,7 @@
 
 usage:
   archive-room-log.py <server_url> <room> <out.md>   ログを書き出す
-  archive-room-log.py --members <server_url> <room>  member 名を空白区切りで出す（席を畳む相手）
+  archive-room-log.py --members [--json] <server_url> <room>  member を出す（席を畳む相手）
 
 本文は投稿時の Markdown をそのまま置く（引用ブロックで包むと表とコードが崩れる）。
 本文の無い発言（過去に本文なし POST が着地した分）は、欠落と分かる形で残す——
@@ -21,9 +21,13 @@ def fetch(url, path):
 
 def main(argv):
     if argv[:1] == ["--members"]:
-        url, room = argv[1], argv[2]
+        as_json = argv[1:2] == ["--json"]
+        url, room = argv[2:4] if as_json else argv[1:3]
         members = fetch(url, f"/api/{room}/members")["members"]
-        print(" ".join(m["name"] for m in members))
+        if as_json:
+            print(json.dumps([{"name": m["name"], "observe": m.get("observe")} for m in members]))
+        else:
+            print(" ".join(m["name"] for m in members))
         return 0
 
     url, room, out = argv[0], argv[1], argv[2]

package/skill/scripts/ensure-bridge.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# bridge を tmux に常駐させ、最初の ready_at まで待つ薄い supervisor。
+set -euo pipefail
+
+proj="$1"; name="$2"; shift 2
+case "$name" in seat-status) script="seat-status-bridge.mjs" ;; wakeup) script="wakeup-bridge.mjs" ;; run) script="run-bridge.mjs" ;; *) echo "usage: ensure-bridge.sh <project> <seat-status|wakeup|run> [args...]" >&2; exit 1 ;; esac
+team="$proj/.team"; record="$team/$name-bridge.json"; log="$team/$name-bridge.log"
+force=false
+if [ "${1:-}" = "--force" ]; then force=true; shift; fi
+if [ $# -eq 0 ] && [ -f "$record" ]; then
+  saved=()
+  while IFS= read -r arg; do saved+=("$arg"); done < <(node -e 'const x=require(process.argv[1]); for (const a of x.args||[]) console.log(a)' "$record")
+  set -- "${saved[@]}"
+fi
+if [ -f "$record" ]; then
+  pid=$(node -e 'try{process.stdout.write(String(require(process.argv[1]).pid||""))}catch{}' "$record")
+  if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then exit 0; fi
+  if ! "$force" && grep -q 'WRITE_DENIED' "$log" 2>/dev/null; then echo "${name}-bridge: 前回はWRITE_DENIEDで終了。--forceを指定すること" >&2; exit 1; fi
+fi
+sock=$(node "$(dirname "$0")/tmux-socket.mjs")
+room=$(node -e 'process.stdout.write(require(process.argv[1]).room)' "$team/setup-state.json")
+session="peertable-${name}-${room}"
+# **死んだ記録をここで消す。** 残すと下の loop が前回の `ready_at` を読んで、
+# 新しい bridge が1バイトも動いていない段階で success を返す——「起動していないのに
+# 起動したと言う」＝この supervisor が塞ぐはずの穴そのものになる。
+rm -f "$record"
+: > "$log"
+# **手渡された env を常駐へ渡す。** 新しい session が継ぐのは tmux *server* の環境であって
+# 呼び出し元 client の環境ではないので、素で起こすと `PEERTABLE_TMUX_SOCKET` の手渡しが黙って消え、
+# 常駐が別の socket（本番の既定）を観測しにいく（2026-08-11 実測）。決定73 と同じ形の裏返しである。
+env_prefix=""
+for v in PEERTABLE_TMUX_SOCKET PEERTABLE_POST_TOKEN PEERTABLE_URL; do
+  eval "val=\${$v:-}"
+  [ -n "$val" ] && env_prefix="$env_prefix $v=$(printf '%q' "$val")"
+done
+# **session が在るだけでは常駐が生きている証拠にならない**（中の node だけ死んで殻が残る）。
+# 上で pid 生存を確かめて here まで来た＝生きていないので、殻は畳んでから立て直す。
+tmux -S "$sock" kill-session -t "$session" 2>/dev/null || true
+tmux -S "$sock" new-session -d -s "$session" "env${env_prefix} node $(dirname "$0")/$script $(printf '%q ' "$proj" "$@") >> $(printf '%q' "$log") 2>&1"
+for _ in $(seq 1 30); do
+  if [ -f "$record" ] && node -e 'process.exit(require(process.argv[1]).ready_at?0:1)' "$record"; then
+    # **末尾は本物の改行にする。** `"\\n"` と書くと JS がリテラルの `\`+`n` を足し、
+    # record が JSON として壊れる——`--stop` も次回起動も `JSON.parse` で落ちて、
+    # 「止められない・建て直せない常駐」ができる（2026-08-11 実測）。一時 file→rename で原子的に。
+    node -e 'const fs=require("fs");const p=process.argv[1],a=process.argv.slice(2);
+      const t=`${p}.${process.pid}.tmp`;
+      fs.writeFileSync(t,JSON.stringify({...JSON.parse(fs.readFileSync(p,"utf8")),args:a})+"\n");
+      fs.renameSync(t,p)' "$record" "$@"
+    exit 0
+  fi
+  sleep .5
+done
+echo "${name}-bridge: ready_at を待てなかった。ログ末尾:" >&2
+tail -n 20 "$log" >&2 || true
+exit 1

package/skill/scripts/launch-seat.sh

@@ -20,7 +20,7 @@ if [ "$vendor" = "claude" ]; then
   esac
 fi
 
-sock="${PEERTABLE_TMUX_SOCKET:-${TMPDIR}claude-tmux-sockets/claude.sock}"
+sock=$(node "$(dirname "$0")/tmux-socket.mjs")
 sess="peer-$name"
 state="$proj/.team/setup-state.json"
 read -r room url mode plan <<EOF
@@ -43,6 +43,10 @@ tmux -S "$sock" kill-session -t "$sess" 2>/dev/null || true
 # **消すのは同名の自分の分だけ**——`peer-*` を一括で消すと同じマシンの別卓を巻き込む。
 rm -f "$proj/.team/seats/$name.json"
 tmux -S "$sock" new-session -d -s "$sess" -x 200 -y 50 -c "$proj"
+# Codex の closed env には launcher 自身でなく、今作った session の識別子を渡す。
+# 自己申告の observe が別 pane を指すと、稼働状態・起床とも別席を誤操作する。
+seat_tmux=$(tmux -S "$sock" display-message -p -t "$sess" '#{socket_path}')
+seat_tmux_pane=$(tmux -S "$sock" display-message -p -t "$sess" '#{pane_id}')
 
 # 素性は席の env にも入れる。client が**登録のたびに**載せるので、member の状態が失われても戻る
 env_line="export PEERTABLE_URL=$url PEERTABLE_ROOM=$room PEERTABLE_MEMBER=$name PEERTABLE_POST_TOKEN=$PEERTABLE_POST_TOKEN"
@@ -65,7 +69,7 @@ case "$vendor" in
     # Codex には channels が無いので room は stdio MCP として差す。
     # `[mcp_servers.X.env]` は closed mode（親 env を継がない）ので全変数を明示列挙する
     # （caveat `codex-cli-v0-130-0-mcp-servers-x-env-block-is-closed-mode-parent-env-not-inherited`）。
-    envtbl="PATH=\\\"$PATH\\\",PEERTABLE_URL=\\\"$url\\\",PEERTABLE_ROOM=\\\"$room\\\",PEERTABLE_MEMBER=\\\"$name\\\",PEERTABLE_POST_TOKEN=\\\"$PEERTABLE_POST_TOKEN\\\""
+    envtbl="PATH=\\\"$PATH\\\",PEERTABLE_URL=\\\"$url\\\",PEERTABLE_ROOM=\\\"$room\\\",PEERTABLE_MEMBER=\\\"$name\\\",PEERTABLE_POST_TOKEN=\\\"$PEERTABLE_POST_TOKEN\\\",TMUX=\\\"$seat_tmux\\\",TMUX_PANE=\\\"$seat_tmux_pane\\\""
     cmd="codex --model $model -C $proj --dangerously-bypass-approvals-and-sandbox"
     # Codexのeffortは環境変数だけでは適用されない。member metadataへ表示する値と、
     # 実際の推論設定を同じ引数から渡して食い違わせない。
@@ -188,10 +192,10 @@ fi
 # **欄が無い登録で既存の素性を消さない**（upsert）ことが前提である。
 # effort は渡された時だけ入れる——欄が無い＝「不明」ではなく「CLI 既定で走っている」。
 # ここが失敗しても席は着席済みなので落とさない。ただし黙っては飲まない。
-meta=$(python3 - "$name" "$vendor" "$model" "$effort" <<'PY'
+meta=$(python3 - "$name" "$vendor" "$model" "$effort" "$sock" "$sess" <<'PY'
 import json, sys
-name, vendor, model, effort = sys.argv[1:5]
-body = {'name': name, 'vendor': vendor, 'model': model}
+name, vendor, model, effort, sock, sess = sys.argv[1:7]
+body = {'name': name, 'vendor': vendor, 'model': model, 'observe': {'tmux_socket': sock, 'tmux_target': sess}}
 if effort:
     body['effort'] = effort
 print(json.dumps(body))
@@ -214,7 +218,7 @@ try:
 except Exception:
     members = []
 m = next((x for x in members if x.get('name') == sys.argv[1]), {})
-print('yes' if m.get('model') else 'no')
+print('yes' if m.get('model') and m.get('observe', {}).get('tmux_target') else 'no')
 PY
 )
   if [ "$stored" = yes ]; then
@@ -226,6 +230,12 @@ else
   echo "metadata の登録に失敗した: 席は着席済みで、参加者一覧に素性が出ないだけ（room の到達性とトークンを確認）" >&2
 fi
 
+if "$(dirname "$0")/ensure-bridge.sh" "$proj" seat-status; then
+  echo "seat-status-bridge: 起動確認済み"
+else
+  echo "seat-status-bridge の起動確認に失敗した（席は着席済み）" >&2
+fi
+
 if [ -n "$brief" ]; then
   sleep 2
   tmux -S "$sock" send-keys -t "$sess" "$brief"

package/skill/scripts/run-bridge.mjs

@@ -21,7 +21,7 @@
 // 生死の作法は Lattice ADR 0157 に倣う: 自分の pid を記録に置き、起動時に前の記録を掃除し、
 // 止まらなければ黙って諦めず typed error で落ちる。
 import { execFile } from 'node:child_process'
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { promisify } from 'node:util'
 
@@ -166,12 +166,21 @@ const runSummaries = new Map()      // run_ref -> 直近に記録した要約
 const interventions = new Map()     // `${run_ref}\0${task_id}` -> 直近に観測した介入の形
 const closedRuns = new Set()        // closed を観測した run。以後 poll しない
 let pollTicks = 0
+let readyRecorded = false
+function markReady() {
+  if (readyRecorded) return
+  const temp = `${record}.tmp`
+  writeFileSync(temp, JSON.stringify({ ...JSON.parse(readFileSync(record, 'utf8')), ready_at: new Date().toISOString() }) + '\n')
+  renameSync(temp, record)
+  readyRecorded = true
+}
 
 // **どの run を見るかは `run list` から取る。** 旧版は order の worktree_path から run dir を
 // 切り出していたが、その order がもう出ないので、装置に聞く形へ変えた。
 // `selection: 'pull'` だけを対象にする——legacy automatic run は席が居ないので中継しても意味がない。
 async function pullRunRefs() {
   const listed = await lattice(['run', 'list', '--json'])
+  markReady()
   return (listed.active_runs ?? [])
     .filter(entry => entry.selection === 'pull' && typeof entry.run_ref === 'string')
     .map(entry => entry.run_ref)

package/skill/scripts/seat-status-bridge.mjs

@@ -21,10 +21,10 @@
 // 変わっていないのかを server が区別できない**（決定58 の liveness と cursor の分離と同じ形）。
 // server 側は最終受信からの経過で `unknown` へ落とす——古い状態を出し続けるのが最悪だから。
 import { execFileSync } from 'node:child_process'
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs'
+import { existsSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { classifyPaneTail, decideBridgeContinuation, deriveMissingSession, parsePaneTokenHint, resolvePostToken, resolveTmuxSocket, supportsMemberObservation } from './seat-usage.mjs'
+import { classifyPaneTail, decideBridgeContinuation, deriveMissingSession, parsePaneTokenHint, resolvePostToken, resolveSeatObservation, resolveTmuxSocket, supportsMemberObservation } from './seat-usage.mjs'
 
 const args = process.argv.slice(2)
 const proj = args[0]
@@ -76,28 +76,36 @@ const room = setup.room
 const token = resolvePostToken(process.env)
 writeFileSync(pidPath, JSON.stringify({ pid: process.pid, started_at: new Date().toISOString() }) + '\n')
 
-// launch-seat.sh:14 が席を作るソケットと同じ解決規則（既定ソケットへ黙って fallback しない——
-// 見えないなら「見えない」と言う。同じルールを二重に書かない）
-const socket = resolveTmuxSocket(process.env)
-const tmux = (...a) => { try { return execFileSync('tmux', ['-S', socket, ...a], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }) } catch { return null } }
+// 記述子がある席は既定 socket を要らない。曖昧な既定 socket のせいで観測可能な席まで止めないよう、
+// legacy 席を読む時だけ解決する。
+let defaultSocketResolution = null
+let resolutionLogged = false
+let readyRecorded = false
+const defaultSocket = () => {
+  if (defaultSocketResolution === null) defaultSocketResolution = resolveTmuxSocket(process.env)
+  return defaultSocketResolution.socket
+}
+const tmux = (socket, ...a) => { try { return execFileSync('tmux', ['-S', socket, ...a], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }) } catch { return null } }
 
 // 監視するのは room の members に居る席だけ。tmux の `peer-*` を全部拾うと、同じマシンで走る別の卓を晒す
 async function seats() {
   const res = await fetch(`${url}/api/${encodeURIComponent(room)}/members`)
   const { members } = await res.json()
-  return members.map(m => m.name)
+  return members
 }
 
-function readSeat(name, previous, observedAt) {
-  const target = `peer-${name}`
-  const dead = tmux('list-panes', '-t', target, '-F', '#{pane_dead}')
+function readSeat(member, previous, observedAt) {
+  // まず記述子だけで解決する。socket が無い記述子／記述子なしの場合だけ既定を調べる。
+  const target = resolveSeatObservation(member, null) ?? resolveSeatObservation(member, defaultSocket())
+  if (target === null) return deriveMissingSession(previous)
+  const dead = tmux(target.socket, 'list-panes', '-t', target.target, '-F', '#{pane_dead}')
   // セッションが見つからない。tmux 席を持たない member（親など）は一度も観測できないので送らない
   // （`previous` が無い＝一度も観測できていない）。過去に観測できていた席が消えたなら実際に落ちた
   if (dead === null) return deriveMissingSession(previous)
   if (dead.trim().split('\n')[0] === '1') {
     return { status: 'dead', busySince: null, paneTokenHint: null }
   }
-  const pane = tmux('capture-pane', '-t', target, '-p')
+  const pane = tmux(target.socket, 'capture-pane', '-t', target.target, '-p')
   if (pane === null) return { status: 'dead', busySince: null, paneTokenHint: null }
   const tail = pane.split('\n').slice(-14).join('\n')
   const status = classifyPaneTail(tail)
@@ -138,9 +146,40 @@ const tokenBucket = value => value === null ? null : Math.floor(value / 1_000)
 // 数えないと、失敗を1行ずつ吐きながら永久に常駐する（2026-08-10 に4時間そうなった）
 const NOTHING_ATTEMPTED = { attempted: 0, failed: 0 }
 
+function hasDescriptor(member) {
+  return member?.observe && typeof member.observe === 'object'
+    && typeof member.observe.tmux_target === 'string' && member.observe.tmux_target.length > 0
+}
+
+function logResolution(members) {
+  if (resolutionLogged) return
+  resolutionLogged = true
+  const descriptors = members.filter(hasDescriptor).length
+  const legacy = members.length - descriptors
+  if (legacy === 0) {
+    console.error(`seat-status-bridge: 観測記述子 ${descriptors} 席、legacy 0 席、既定 socket は未使用`)
+    return
+  }
+  const resolved = defaultSocketResolution ?? resolveTmuxSocket(process.env)
+  defaultSocketResolution = resolved
+  const detail = resolved.error
+    ? `${resolved.source} (${resolved.error.code}: ${resolved.candidates.join(', ')})`
+    : `${resolved.source} (${resolved.socket})`
+  console.error(`seat-status-bridge: 観測記述子 ${descriptors} 席、legacy ${legacy} 席、既定 socket=${detail}`)
+}
+
+function recordReady() {
+  if (readyRecorded) return
+  readyRecorded = true
+  const record = JSON.parse(readFileSync(pidPath, 'utf8'))
+  const temporary = `${pidPath}.${process.pid}.tmp`
+  writeFileSync(temporary, JSON.stringify({ ...record, ready_at: new Date().toISOString() }) + '\n')
+  renameSync(temporary, pidPath)
+}
+
 async function tick() {
-  let names
-  try { names = await seats() } catch (e) { console.error(`seat-status-bridge: members を読めない: ${e.message}`); return NOTHING_ATTEMPTED }
+  let members
+  try { members = await seats() } catch (e) { console.error(`seat-status-bridge: members を読めない: ${e.message}`); return NOTHING_ATTEMPTED }
   // **送る前に、server が status を持つ版かを確かめる。**
   // 現行の `POST /members` は、既存メンバーでも `<名前> が参加した` を必ず room へ流す（`post()` が
   // `if (!members.has(name))` の外にある）。status を保持しない版へ投げると、**保存されないうえに
@@ -148,17 +187,20 @@ async function tick() {
   // 保持する版かどうかは GET で分かるので、**分かるまで投げない**。
   if (supported === null) {
     try { supported = await serverKeepsStatus() } catch { return NOTHING_ATTEMPTED }   // 判定できない間は送らない
+    recordReady()
     if (!supported) console.error('seat-status-bridge: この room サーバーは稼働状態を保持しない版（GET /members に status が無い）。送信すると保存されないうえに system 発言を撒くので、送信しない')
   }
-  if (!supported) { console.error(`seat-status-bridge: ${names.length} 席を見たが、server が未対応なので送っていない`); return NOTHING_ATTEMPTED }
+  logResolution(members)
+  if (!supported) { console.error(`seat-status-bridge: ${members.length} 席を見たが、server が未対応なので送っていない`); return NOTHING_ATTEMPTED }
   const now = Date.now()
   const observedAt = new Date(now).toISOString()
   let sent = 0
   let skipped = 0
   let failed = 0
-  for (const name of names) {
+  for (const member of members) {
+    const { name } = member
     const prev = last.get(name)
-    const observation = readSeat(name, prev, observedAt)
+    const observation = readSeat(member, prev, observedAt)
     // tmux 席を持たない member（親など）は一度も観測できないので送らない（deriveMissingSession が null を返す）
     if (observation === null) { skipped++; continue }
     const changed = !prev || prev.status !== observation.status
@@ -178,7 +220,7 @@ async function tick() {
     }
   }
   // 0件でも0件と言う（条件付きログにしない。沈黙する失敗を作らない・決定58）
-  console.error(`seat-status-bridge: ${names.length} 席を見て ${sent} 件送った（tmux席を持たず観測対象外: ${skipped}）`)
+  console.error(`seat-status-bridge: ${members.length} 席を見て ${sent} 件送った（tmux席を持たず観測対象外: ${skipped}）`)
   return { attempted: sent + failed, failed }
 }
 

package/skill/scripts/seat-usage.mjs

@@ -1,4 +1,5 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync, readdirSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
@@ -16,12 +17,68 @@ export function supportsMemberObservation(payload) {
   return payload?.capabilities?.member_observation_v1 === true
 }
 
+/** aiterm-mcp の POSIX 既定ソケット規則。 */
+export function defaultTmuxSocket(env) {
+  return join(env.TMPDIR || '/tmp', 'claude-tmux-sockets', 'claude.sock')
+}
+
+const defaultTmuxProbe = {
+  serverAlive(socket) {
+    try {
+      execFileSync('tmux', ['-S', socket, 'ls'], { stdio: 'ignore' })
+      return true
+    } catch {
+      return false
+    }
+  },
+  listAitermSockets() {
+    try {
+      return readdirSync('/tmp')
+        .filter(name => /^aiterm-.*\.sock$/u.test(name))
+        .map(name => join('/tmp', name))
+    } catch {
+      return []
+    }
+  },
+}
+
 /**
- * launch-seat.sh:14 と同じ解決規則で aiterm-mcp の tmux ソケットを決める。
- * 規則を二重に書かない——片方だけ直すと同じ穴がもう一度開く。
+ * 明示設定、既定、検証済み発見の順で tmux socket を決める。
+ * 見つからない既定値は launch-seat.sh が新しい server を作るために必要なので返す。
  */
-export function resolveTmuxSocket(env) {
-  return env.PEERTABLE_TMUX_SOCKET || `${env.TMPDIR}claude-tmux-sockets/claude.sock`
+export function resolveTmuxSocket(env, probe = defaultTmuxProbe) {
+  if (env.PEERTABLE_TMUX_SOCKET) {
+    return { socket: env.PEERTABLE_TMUX_SOCKET, source: 'explicit', candidates: [], error: null }
+  }
+  const fallback = defaultTmuxSocket(env)
+  if (probe.serverAlive(fallback)) {
+    return { socket: fallback, source: 'default', candidates: [], error: null }
+  }
+  const candidates = probe.listAitermSockets().filter(socket => probe.serverAlive(socket))
+  if (candidates.length === 1) {
+    return { socket: candidates[0], source: 'discovered', candidates, error: null }
+  }
+  if (candidates.length > 1) {
+    return {
+      socket: null,
+      source: 'none',
+      candidates,
+      error: { code: 'PEERTABLE_TMUX_SOCKET_AMBIGUOUS', message: '検証済み aiterm socket が複数あります' },
+    }
+  }
+  return { socket: fallback, source: 'default', candidates: [], error: null }
+}
+
+/** member の自己申告を優先し、無い既存 member だけ旧 session 名へ互換フォールバックする。 */
+export function resolveSeatObservation(member, defaultSocket) {
+  const observe = member?.observe
+  if (observe && typeof observe === 'object' && typeof observe.tmux_target === 'string' && observe.tmux_target) {
+    const socket = observe.tmux_socket || defaultSocket
+    return socket ? { socket, target: observe.tmux_target, source: 'descriptor' } : null
+  }
+  return defaultSocket && member?.name
+    ? { socket: defaultSocket, target: `peer-${member.name}`, source: 'legacy' }
+    : null
 }
 
 /**

package/skill/scripts/setup.sh

@@ -169,7 +169,10 @@ printf '{"room":"%s","server_url":"%s","public_url":"%s","mode":"%s","plan_key":
 # 4時間 HTTP 403 を撃ち続け、参加者一覧には点が1つも出なかった＝起こしていないのと見分けがつかない）。
 # AI は使わず席へも1バイト送らないので卓の作業を邪魔しない。**書けない時は常駐せずに死ぬ**ので、
 # ここで壊れた常駐が黙って残ることは無い。setup-state.json を読むので、必ずその後で起こす。
-nohup node "$repo/skill/scripts/seat-status-bridge.mjs" "$proj" > "$tdir/seat-status-bridge.log" 2>&1 &
-echo "seat-status-bridge: 起こした（ログ $tdir/seat-status-bridge.log・停止は teardown が行う）"
+if "$repo/skill/scripts/ensure-bridge.sh" "$proj" seat-status; then
+  echo "seat-status-bridge: ready_at を確認した（ログ $tdir/seat-status-bridge.log・停止は teardown が行う）"
+else
+  echo "seat-status-bridge: 起動を確認できなかった（ログ $tdir/seat-status-bridge.log）" >&2
+fi
 
 echo "scaffold done: $tdir"

package/skill/scripts/teardown.sh

@@ -60,17 +60,23 @@ fi
 
 # ---- 席（tmux）の終了。**`.team/` を消す前**に、この room の member だけを畳む ----
 # `peer-*` を全部畳むと、同じマシンの別の卓を巻き込む（bridge が members 起点にしているのと同じ理由）
-sock="${PEERTABLE_TMUX_SOCKET:-${TMPDIR}claude-tmux-sockets/claude.sock}"
-seats=$(python3 "$(dirname "$0")/archive-room-log.py" --members "$url" "$room" 2>/dev/null || true)
-if [ -z "$seats" ]; then
+sock=$(node "$(dirname "$0")/tmux-socket.mjs")
+members_json=$(python3 "$(dirname "$0")/archive-room-log.py" --members --json "$url" "$room" 2>/dev/null || true)
+seat_names=$(python3 "$(dirname "$0")/archive-room-log.py" --members "$url" "$room" 2>/dev/null || true)
+member_lines=$(python3 -c 'import json,sys; [print(json.dumps(x,separators=(",",":"))) for x in json.loads(sys.stdin.read())]' <<<"$members_json" 2>/dev/null || true)
+if [ -z "$members_json" ]; then
   miss "席の終了 — member 一覧が取れず、畳む相手を特定できない。手で確認: tmux -S \"$sock\" list-sessions | grep peer-"
 else
   closed=0
-  for name in $seats; do
-    if tmux -S "$sock" has-session -t "peer-$name" 2>/dev/null; then
-      tmux -S "$sock" kill-session -t "peer-$name" && closed=$((closed + 1))
+  while IFS= read -r member; do
+    [ -n "$member" ] || continue
+    name=$(python3 -c 'import json,sys; print(json.loads(sys.argv[1])["name"])' "$member")
+    target=$(python3 -c 'import json,sys; x=json.loads(sys.argv[1]); print((x.get("observe") or {}).get("tmux_target") or "peer-" + x["name"])' "$member")
+    member_sock=$(python3 -c 'import json,sys; x=json.loads(sys.argv[1]); print((x.get("observe") or {}).get("tmux_socket") or sys.argv[2])' "$member" "$sock")
+    if tmux -S "$member_sock" has-session -t "$target" 2>/dev/null; then
+      tmux -S "$member_sock" kill-session -t "$target" && closed=$((closed + 1))
     fi
-  done
+  done <<<"$member_lines"
   if [ "$closed" -gt 0 ]; then did "席の終了（${closed}席）"; else skip "席の終了（生きている席なし）"; fi
   left=$(tmux -S "$sock" list-sessions 2>/dev/null | grep -c '^peer-' || true)
   [ "${left:-0}" -eq 0 ] || echo "teardown: [注記] 他の卓の peer-* が ${left}件 残っている（この卓のものではないので畳まない）"
@@ -242,12 +248,12 @@ if [ "$mode" = archive ]; then
   if [ -z "${PEERTABLE_POST_TOKEN:-}" ]; then
     miss "メンバー登録の解除 — TOKEN_MISSING: \`~/.config/peertable.env\` の定義が \`export\` 付きでないと子 process へ渡らない"
     echo "teardown: [手当] 参加者は次で外せる: curl -X DELETE \"$url/api/$room/members/<名前>\" -H \"X-Peertable-Token: \$PEERTABLE_POST_TOKEN\"" >&2
-  elif [ -z "$seats" ]; then
+  elif [ -z "$seat_names" ]; then
     skip "メンバー登録の解除（一覧が取れていない）"
   else
     # 履歴に解散の区切りを残す。**部屋が続く以上、どこで卓が変わったかが読めないと
     # 過去ログが一続きの会話に見えてしまう**（次の campaign の発言と地続きになる）
-    body="解散。この卓はここまで。参加者: ${seats}。部屋と過去ログはこのまま残り、次の卓も同じ部屋で続く。"
+    body="解散。この卓はここまで。参加者: ${seat_names}。部屋と過去ログはこのまま残り、次の卓も同じ部屋で続く。"
     python3 -c "
 import json,sys,urllib.request
 req=urllib.request.Request('$url/api/$room/messages', method='POST',
@@ -256,10 +262,12 @@ req=urllib.request.Request('$url/api/$room/messages', method='POST',
 urllib.request.urlopen(req, timeout=10).read()
 " 2>/dev/null && did "解散の区切りを履歴へ" || skip "解散の区切り（投稿できず・撤去は続行）"
     n=0
-    for name in $seats; do
+    while IFS= read -r member; do
+      [ -n "$member" ] || continue
+      name=$(python3 -c 'import json,sys,urllib.parse; print(urllib.parse.quote(json.loads(sys.argv[1])["name"], safe=""))' "$member")
       c=$(curl -s -o /dev/null -w '%{http_code}' -X DELETE "$url/api/$room/members/$name" -H "X-Peertable-Token: $PEERTABLE_POST_TOKEN" || true)
       [ "$c" = 200 ] && n=$((n + 1))
-    done
+    done <<<"$member_lines"
     did "メンバー登録の解除（${n}名）— **部屋と過去ログは残す**（$url/$room）"
   fi
 # room 削除は --purge だけ。トークンを要する唯一の段で、ここだけが外部サービスへの依存境界

package/skill/scripts/tmux-socket.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { resolveTmuxSocket } from './seat-usage.mjs'
+
+const result = resolveTmuxSocket(process.env)
+if (result.error?.code === 'PEERTABLE_TMUX_SOCKET_AMBIGUOUS') {
+  console.error(`${result.error.code}: ${result.candidates.join(', ')}`)
+  process.exit(1)
+}
+if (process.argv.includes('--source')) console.log(result.source)
+else console.log(result.socket)

package/skill/scripts/wakeup-bridge.mjs

@@ -12,9 +12,10 @@
 // 送った文言はそのターンの中で読まれ、指示どおりに動いた（steering が効く）。したがって
 // idle 待ちの経路は持たない——待ちを入れると、混んでいる席ほど起床が遅れる。
 import { execFile } from 'node:child_process'
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { promisify } from 'node:util'
+import { resolveSeatObservation, resolveTmuxSocket } from './seat-usage.mjs'
 
 const run = promisify(execFile)
 const [proj, ...rest] = process.argv.slice(2)
@@ -24,7 +25,8 @@ if (!proj || rest.length === 0) {
 }
 
 const record = join(proj, '.team', 'wakeup-bridge.json')
-const sock = process.env.PEERTABLE_TMUX_SOCKET ?? `${process.env.TMPDIR}claude-tmux-sockets/claude.sock`
+const socketResult = resolveTmuxSocket(process.env)
+const sock = socketResult.socket
 const alive = pid => { try { process.kill(pid, 0); return true } catch { return false } }
 const sleep = ms => new Promise(r => setTimeout(r, ms))
 const log = line => console.log(`[${new Date().toISOString()}] ${line}`)
@@ -63,6 +65,28 @@ process.on('SIGINT', cleanup)
 
 // 席ごとに未配達を溜めて、2秒ごとにまとめて1回起こす（連投で席を何度も起こさない）
 const pending = new Map(seats.map(s => [s, []]))
+let members = new Map()
+async function refreshMembers() {
+  try {
+    const res = await fetch(`${url}/api/${encodeURIComponent(room)}/members`)
+    if (!res.ok) throw new Error(`members ${res.status}`)
+    const body = await res.json()
+    members = new Map(body.members.map(member => [member.name, member]))
+    return true
+  } catch (error) {
+    // 記述子の更新が読めないことは起床停止の理由にしない。直前の map を保ち、
+    // 未登録席は wake() の legacy target へ戻す。縮退を必ずログに残す。
+    log(`member 記述子を更新できないので直前の観測先で続ける: ${error.message}`)
+    return false
+  }
+}
+await refreshMembers()
+function markReady() {
+  const next = { ...JSON.parse(readFileSync(record, 'utf8')), ready_at: new Date().toISOString() }
+  const temp = `${record}.tmp`
+  writeFileSync(temp, JSON.stringify(next) + '\n')
+  renameSync(temp, record)
+}
 
 async function wake(seat, msgs) {
   const last = msgs[msgs.length - 1]
@@ -71,9 +95,14 @@ async function wake(seat, msgs) {
     ? `room に新着あり（${last.from} → ${audience}）。read_unread で読むこと。`
     : `room に新着 ${msgs.length} 件（最新: ${last.from} → ${audience}）。read_unread で読むこと。`
   try {
-    await run('tmux', ['-S', sock, 'send-keys', '-t', `peer-${seat}`, text])
+    // bridge 起動後の着席も次の配達で取り直す。初回だけの snapshot にすると
+    // 新席を「member 不明」として永久に起こせず、旧 peer- 互換より後退する。
+    await refreshMembers()
+    const observation = resolveSeatObservation(members.get(seat) ?? { name: seat }, sock)
+    if (observation === null) throw new Error(`観測記述子も既定 socket も無い: ${seat}`)
+    await run('tmux', ['-S', observation.socket, 'send-keys', '-t', observation.target, text])
     await sleep(400)
-    await run('tmux', ['-S', sock, 'send-keys', '-t', `peer-${seat}`, 'Enter'])
+    await run('tmux', ['-S', observation.socket, 'send-keys', '-t', observation.target, 'Enter'])
     log(`起こした: ${seat} ← ${msgs.length} 件（最新 seq ${last.seq}）`)
   } catch (error) {
     // 席が畳まれていれば tmux が落ちる。黙って飲まず、毎回出す（何件落としたかも出す）
@@ -172,6 +201,7 @@ for (;;) {
       if (!res.ok) throw new Error(`events ${res.status}`)
       failures = 0
       log('SSE 接続')
+      markReady()
       await catchUp('再接続')
       let buf = ''
       for await (const chunk of res.body) {