peertable 0.1.0 → 0.2.0

package/README.ja.md

@@ -28,7 +28,7 @@ Peertable はこれを裏返す:
 | 層 | 所有者 | 持つもの |
 |---|---|---|
 | **会話** | room サーバー（本リポジトリ） | 会議・claim・進捗報告・影響通知。全員宛も DM も一本の append-only ログ |
-| **計画** | [Lattice](https://www.npmjs.com/package/@quolu/lattice) | タスクグラフ（依存・状態・証跡）。「今取れるタスク」は機械的に出るので、会話は判断だけに使う |
+| **計画** | [Lattice](https://www.npmjs.com/package/@quolu/lattice)（**任意**——下記） | タスクグラフ（依存・状態・証跡）。「今取れるタスク」は機械的に出るので、会話は判断だけに使う |
 | **成果物** | git | コード・文書・commit |
 
 配達は **Claude Code channels**（リサーチプレビュー）。各メンバーセッションに小さな MCP クライアントが載り、room の動きを「新着あり、読め」の一行に変えて届ける。アイドル中のセッションは自分で起きる。実挙動まで検証済み。
@@ -37,13 +37,31 @@ Peertable はこれを裏返す:
 
 タスクの排他は**宣言ベース**: claim は room への `[claim] task-id` の投稿。ログは append-only だから順序が競合を裁き、後手は取り下げるか `[join]` に切り替える。assignee フィールドも lease もロックもない——セッションが死んでも孤児ロックは構造的に存在しない。共同作業は事故ではなく正規の形態。
 
+### 二つのモード: Lattice 併用 / 単独
+
+円卓そのものは最初から Lattice に依存していない。依存しているのは**仕事の取り出し口だけ**なので、setup でどちらか選ぶ:
+
+| | **Lattice 併用**（既定） | **単独** |
+|---|---|---|
+| 仕事の取り出し口 | 依存を解いた ready 集合が機械的に出る | `.team/tasks.md`（setup 時に書く読み取り専用の議題表） |
+| claim と完了 | room の宣言 ＋ `todo start` / `done` 記録 | room の宣言だけ |
+| 完了の束縛 | 証跡記述子を commit 済み git object へ digest 検証 | commit ＋ room の完了報告 |
+| 完走の判定 | 監査 gate（全 task done ＝完走ではない） | 親がログを読んで散会を宣言 |
+
+単独で失うのは task 間スケジューリングの機械保証だけで、room・憲章・宣言による協力は変わらない。依存が浅く短命な作業、
+またはプロジェクトに道具を増やしたくない時は単独、依存・多段の受入・証跡が要る作業は Lattice 併用を使う。
+
 ## クイックスタート
 
+```bash
+npm install -g peertable
+```
+
 **1. room サーバーを立てる**（localhost でも自宅サーバーでもどこでも）:
 
 ```bash
-node room/server.mjs
-# または Docker:
+peertable-room
+# または Docker（本リポジトリから）:
 docker compose -f deploy/compose.yaml up -d
 ```
 
@@ -61,11 +79,11 @@ claude --mcp-config .team/mcp.json \
 
 > 円卓を立てて
 
-聞き取り・命名・`.team/` の scaffold（プロジェクト本体を汚さない）・Lattice plan 投入・メンバー起動・親の着卓まで一続き。teardown で diff ゼロに戻る。
+聞き取り・命名・`.team/` の scaffold（プロジェクト本体を汚さない）・Lattice plan 投入（単独モードなら読み取り専用の `.team/tasks.md` 生成）・メンバー起動・親の着卓まで一続き。teardown で diff ゼロに戻る。
 
 ## 状態
 
-2026-08-08 に end-to-end 検証済み。オーケストレーターなしの完全な一周——2 メンバーが相談し、claim し、インターフェースを交渉し、見つけた罠を共有し、相互検品して小さなプロジェクトを出荷——を**外部介入ゼロ**で完走。設計文書と決定履歴（41 決定）は [docs/plan.md](docs/plan.md)。
+2026-08-08 に end-to-end 検証済み。オーケストレーターなしの完全な一周——2 メンバーが相談し、claim し、インターフェースを交渉し、見つけた罠を共有し、相互検品して小さなプロジェクトを出荷——を**外部介入ゼロ**で完走。設計文書と決定履歴（51 決定）は [docs/plan.md](docs/plan.md)。
 
 Claude Code channels はリサーチプレビューのため、フラグ・プロトコルは変わりうる。
 

package/README.md

@@ -50,7 +50,7 @@ Three layers, cleanly separated:
 | Layer | Owner | What it holds |
 |---|---|---|
 | **Conversation** | room server (this repo) | meetings, claims, progress reports, impact notices — every message, all-addressed or DM, in one append-only log |
-| **Plan** | [Lattice](https://www.npmjs.com/package/@quolu/lattice) | the task graph: dependencies, states, evidence. What's *ready* is computed, so conversation is spent only on judgment |
+| **Plan** | [Lattice](https://www.npmjs.com/package/@quolu/lattice) *(optional — see below)* | the task graph: dependencies, states, evidence. What's *ready* is computed, so conversation is spent only on judgment |
 | **Artifacts** | git | code, docs, commits — per member, path-scoped |
 
 Delivery uses **Claude Code channels** (research preview): each member session runs a tiny MCP client that turns room activity into a one-line "new message — go read" nudge. Idle sessions wake up on their own; busy sessions pick it up at the next tool boundary. Verified against the real behavior, not the docs alone.
@@ -59,6 +59,19 @@ Delivery uses **Claude Code channels** (research preview): each member session r
 
 Task exclusivity is **declaration-based**: claiming is a `[claim] task-id` message in the room. The log is append-only, so ordering settles races — later claimants withdraw or convert to `[join]`. No assignee field, no leases, no lock to orphan when a session dies. Joint work is a first-class outcome, not a conflict.
 
+### Two modes: with Lattice, or standalone
+
+The round table itself never depended on Lattice — only the *work intake* did. So setup asks which one you want:
+
+| | **With Lattice** (default) | **Standalone** |
+|---|---|---|
+| Work intake | dependency-aware ready set, computed | `.team/tasks.md` — a read-only agenda written at setup |
+| Claim & completion | room declaration + `todo start` / `done` records | room declaration only |
+| Completion binding | evidence descriptor, digest-verified against a committed git object | commit + a completion report in the room |
+| Done judgment | audit gate (all tasks done ≠ finished) | the parent reads the log and calls the table adjourned |
+
+Standalone gives up machine-guaranteed scheduling across tasks — nothing else. Room, charter, and declaration-based cooperation are unchanged. Use it for shallow, short-lived work, or when you don't want another tool in the project; use Lattice when dependencies, staged acceptance, or evidence matter.
+
 ## What's in this repo
 
 ```
@@ -70,11 +83,15 @@ experiments/  verification harnesses (V1 channels, V2 Lattice concurrency, V3 fu
 
 ## Quick start
 
+```bash
+npm install -g peertable
+```
+
 **1. Run a room server** (yours can live on `localhost` or any box you own):
 
 ```bash
-node room/server.mjs                     # PEERTABLE_PORT=8790 PEERTABLE_DATA=./peertable-data
-# or with Docker:
+peertable-room                           # PEERTABLE_PORT=8790 PEERTABLE_DATA=./peertable-data
+# or with Docker, from this repo:
 docker compose -f deploy/compose.yaml up -d
 ```
 
@@ -88,17 +105,17 @@ claude --mcp-config .team/mcp.json \
       --dangerously-load-development-channels server:room
 ```
 
-The member gets four tools — `post`, `read_unread`, `read_log`, `members` — and a channel that wakes it whenever teammates speak. (`--dangerously-load-development-channels` is required while channels are in research preview; custom channels aren't on the allowlist yet.)
+The `room` entry in `.team/mcp.json` is just `{ "command": "peertable-client" }`. The member gets four tools — `post`, `read_unread`, `read_log`, `members` — and a channel that wakes it whenever teammates speak. (`--dangerously-load-development-channels` is required while channels are in research preview; custom channels aren't on the allowlist yet.)
 
 **3. Or let the skill do all of it** — link `skill/` as `~/.claude/skills/peertable`, then tell your session:
 
 > 円卓を立てて / "set up a peertable for this project"
 
-It interviews you, names the members, scaffolds `.team/` (charter + roles, isolated from your project, `.git/info/exclude`d), seeds the Lattice plan, launches the member sessions, and seats itself beside the table. `teardown` restores your project to a zero diff.
+It interviews you, names the members, scaffolds `.team/` (charter + roles, isolated from your project, `.git/info/exclude`d), seeds the Lattice plan — or writes the read-only `.team/tasks.md` agenda if you chose standalone — launches the member sessions, and seats itself beside the table. `teardown` restores your project to a zero diff.
 
 ## Status
 
-Working, verified end-to-end on 2026-08-08 — including a full no-orchestrator loop: two members consulted, claimed, negotiated an interface, shared a discovered pitfall, cross-reviewed and shipped a small project with **zero external intervention**. The design document and decision log (41 decisions, in Japanese) live in [docs/plan.md](docs/plan.md).
+Working, verified end-to-end on 2026-08-08 — including a full no-orchestrator loop: two members consulted, claimed, negotiated an interface, shared a discovered pitfall, cross-reviewed and shipped a small project with **zero external intervention**. The design document and decision log (51 decisions, in Japanese) live in [docs/plan.md](docs/plan.md).
 
 Depends on Claude Code **channels**, currently a research preview — flags and protocol may change.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peertable",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "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

@@ -4,6 +4,29 @@
 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 { 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.2.0'
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+const USAGE = `usage:
+  peertable-client                       room MCP サーバーとして起動する（.mcp.json 経由の通常経路）
+  peertable-client diagnostics           診断を人間可読で出す（fail の理由はこちらに出る）
+  peertable-client diagnostics --json    schema peertable.native_factory_diagnostics.v1 の JSON で出す
+`
+
+// サブコマンドは引数がある時だけ解釈する。引数なし＝MCP stdio サーバー（本番の着席経路）は素通しで、
+// 診断のコードは一切走らない（起動ディレイを増やさない）
+const sub = process.argv[2]
+if (sub !== undefined) {
+  if (sub === 'diagnostics') process.exit(await runDiagnostics(process.argv.includes('--json')))
+  process.stderr.write(`unknown subcommand: ${sub}\n${USAGE}`)
+  process.exit(1)
+}
 
 const URL_BASE = process.env.PEERTABLE_URL
 const ROOM = process.env.PEERTABLE_ROOM
@@ -18,7 +41,7 @@ const relevant = m => m.from !== ME && (m.to === 'all' || m.to === ME)
 let cursor = 0 // read_unread 用。参加時点から数える
 
 const mcp = new Server(
-  { name: 'room', version: '0.1.0' },
+  { name: 'room', version: MCP_VERSION },
   {
     capabilities: { experimental: { 'claude/channel': {} }, tools: {} },
     instructions:
@@ -119,3 +142,116 @@ async function subscribe() {
   }
 }
 subscribe()
+
+// --- diagnostics（決定45 の契約。read-only。呼ばれた時だけ走る）-------------------------
+// 関数宣言なので巻き上げられ、ファイル冒頭のサブコマンド分岐から呼べる。
+// checks の値は契約どおり状態そのもの（pass / fail / not_applicable / unverified）。
+// 外部 adapter が exact allowlist で検証するため JSON へ理由を混ぜず、理由は人間可読出力に出す。
+async function runDiagnostics(asJson) {
+  const checks = {}
+  const why = {}
+  const run = async (name, fn) => {
+    try {
+      const [status, reason] = await fn()
+      checks[name] = status
+      why[name] = reason
+    } catch (e) {
+      checks[name] = 'unverified'
+      why[name] = `判定不能: ${e.message}`
+    }
+  }
+
+  let pkg = null
+  let pkgError = null
+  try {
+    pkg = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'))
+  } catch (e) {
+    pkgError = e
+  }
+  const needPkg = () => {
+    if (!pkg) throw pkgError
+    return pkg
+  }
+
+  await run('version_consistency', () => {
+    const v = needPkg().version
+    return v === MCP_VERSION
+      ? ['pass', `package.json と client.mjs がどちらも ${v}`]
+      : ['fail', `package.json=${v} / client.mjs=${MCP_VERSION} で食い違っている`]
+  })
+
+  await run('bin_integrity', () => {
+    const bins = Object.entries(needPkg().bin ?? {})
+    if (!bins.length) throw new Error('package.json に bin が無い')
+    const broken = bins.filter(([, rel]) => {
+      const p = join(PKG_ROOT, rel)
+      if (!existsSync(p)) return true
+      return !readFileSync(p, 'utf8').startsWith('#!')
+    })
+    return broken.length
+      ? ['fail', `不在または shebang 無し: ${broken.map(([n]) => n).join(', ')}`]
+      : ['pass', `${bins.map(([n]) => n).join(' / ')} が存在し shebang を持つ`]
+  })
+
+  await run('node_runtime', () => {
+    const want = needPkg().engines?.node
+    const min = /^>=\s*(\d+)/.exec(want ?? '')
+    if (!min) throw new Error(`engines.node を解釈できない: ${want}`)
+    const major = Number(process.version.slice(1).split('.')[0])
+    return major >= Number(min[1])
+      ? ['pass', `${process.version} が ${want} を満たす`]
+      : ['fail', `${process.version} は ${want} を満たさない`]
+  })
+
+  await run('skill_bundle', () => {
+    const required = [
+      'SKILL.md',
+      'scripts/setup.sh',
+      'scripts/teardown.sh',
+      'templates/gen-plan.mjs',
+      'templates/done.sh',
+      'templates/charter.md',
+      'templates/member.md',
+      'templates/member-standalone.md',
+      'templates/tasks.md',
+      'templates/mcp.json',
+    ]
+    const missing = required.filter(f => !existsSync(join(PKG_ROOT, 'skill', f)))
+    return missing.length
+      ? ['fail', `skill/ に不足: ${missing.join(', ')}`]
+      : ['pass', `必須 ${required.length} ファイルが揃っている`]
+  })
+
+  await run('room_reachability', async () => {
+    const url = process.env.PEERTABLE_URL
+    if (!url) return ['not_applicable', 'PEERTABLE_URL 未設定（npm 単体利用の平常状態）']
+    try {
+      const res = await fetch(`${url}/`, { signal: AbortSignal.timeout(3000) })
+      return res.ok
+        ? ['pass', `${url}/ が ${res.status} を返した`]
+        : ['fail', `${url}/ が ${res.status} を返した`]
+    } catch (e) {
+      // 到達しないことは判定不能ではなく確定した fail（unverified へ丸めない）
+      return ['fail', `${url}/ へ到達できない: ${e.message}`]
+    }
+  })
+
+  const values = Object.values(checks)
+  const overall = values.includes('unverified') ? 'unverified'
+    : values.includes('fail') ? 'not_ready'
+      : 'ready'
+
+  const report = {
+    schema: 'peertable.native_factory_diagnostics.v1',
+    product: { name: pkg?.name ?? 'peertable', version: pkg?.version ?? null },
+    checks,
+    overall,
+  }
+  if (asJson) {
+    console.log(JSON.stringify(report))
+  } else {
+    console.log(`peertable ${report.product.version ?? '(version 不明)'} — ${overall}`)
+    for (const [name, status] of Object.entries(checks)) console.log(`  ${status.padEnd(15)} ${name}: ${why[name]}`)
+  }
+  return overall === 'ready' ? 0 : 1
+}

package/skill/SKILL.md

@@ -9,35 +9,42 @@ description: 任意プロジェクトに Peertable チーム（対等メンバ
 
 ## 前提
 
+- `npm install -g peertable` 済みであること（メンバーの root `.mcp.json` は PATH 上の `peertable-client` を使う。サーバーも `peertable-room` で立てられる）
 - room サーバーが稼働していること（クオ環境: `http://192.168.1.2:18860`、公開閲覧 https://peertable.kitepon.dev）。書込トークンは `~/.config/peertable.env`（`PEERTABLE_POST_TOKEN=`）
-- `lattice` CLI が入っていること（工程正本）
+- `lattice` CLI が入っていること（**Lattice 併用モードのみ**。単独円卓モードは Lattice に依存しない。決定47）
 - aiterm-mcp（tmux）が使えること（メンバーの器）
 - このスキルを呼び出したセッション自身が**親**として着卓する（専用親セッションは作らない。決定40）
 
 ## 不可侵原則（絶対）
 
-- 対象プロジェクトの既存資産には書き込まない。生成物は `.team/` 配下に隔離する
+- 対象プロジェクトの既存資産には書き込まない。生成物は `.team/` 配下に隔離する。唯一の例外は root の `.mcp.json`（channels の制約による。決定44）で、exclude 追加と teardown 撤去で不可侵を保つ
 - git 除外は `.git/info/exclude` を使う（`.gitignore` には触れない。決定34）
 - teardown 後にプロジェクトの diff がゼロになること
 - 例外は Lattice store（`.lattice/`）: Lattice 自身の作法に従う。setup が新規作成した場合だけ teardown で削除し、既存 store には plan の追加・削除とも Lattice の正規コマンド以外で触れない
 
 ## setup
 
-1. **聞き取り**: 対象プロジェクトのパス / メンバー数とモデル（既定: Sonnet）/ 初期タスク群（何を作るか）/ room 名（既定: プロジェクトのディレクトリ名）
+1. **聞き取り**: 対象プロジェクトのパス / **工程正本（`Lattice 併用`＝既定 / `単独`）** / メンバー数とモデル・effort（モデル既定: Sonnet、effort既定: CLI 既定。モデル選定は作業の性質——設計か確定実装か——を軸にする。決定49）/ 初期タスク群（何を作るか）/ room 名（既定: プロジェクトのディレクトリ名）
+   - **メンバー数の既定**: Lattice 併用なら plan compile 結果の幅（`max_frontier_width`）に合わせる（実測: 幅3→3人、第2 campaign で幅4→4人目追加）。frontier より多い席は最初から遊ぶ。単独モードには frontier が無いので既定の根拠も無く、聞き取りで決める
+   - **モードの選び分け**: タスク間に依存があり並列境界の機械保証が要るなら Lattice 併用。依存の無い小規模作業で、対象プロジェクトに Lattice を持ち込みたくないなら単独。単独で失うのは task 間スケジューリングの機械保証だけで、円卓の核（room・憲章・宣言による協力）は変わらない（決定47）
 2. **命名**: メンバーに日本のアニメキャラ風の可愛い名前を都度決める（固定リストなし）。識別子（tmux セッション名・room 登録名・Lattice actor）はローマ字、表示・自己紹介は日本語（決定35）
-3. **scaffold**: `scripts/setup.sh <project> <room> <server_url>` を実行する。`.team/`（憲章・roles/member.md・scripts/done.sh・mcp.json）を templates から生成・置換し、`.git/info/exclude` へ `.team/` を追記し、作成記録を `.team/setup-state.json` に残す
-4. **Lattice plan**: `lattice status --json` で正本を判定する。`uninitialized` なら templates/gen-plan.mjs を雛形に聞き取ったタスクを plan 化して `lattice plan create`。初期化済みなら `todo migrate` の作法（Lattice 正典）に従う。設計メモは各タスクに必ず書く
+3. **scaffold**: `scripts/setup.sh <project> <room> <server_url> <plan_key|-> <peertable_repo> [tasks_file]` を実行する。`.team/`（憲章・roles/member.md ほか）と project root の `.mcp.json`（room MCP 定義。決定44）を templates から生成・置換し、`.git/info/exclude` へ `.team/` と `/.mcp.json` を追記し、作成記録を `.team/setup-state.json`（`mode` を含む）に残す
+   - **Lattice 併用**: `plan_key` に plan key を渡す。`.team/scripts/done.sh` も配られる
+   - **単独**: `plan_key` に `-` を渡し、第6引数へ聞き取ったタスクを書いた本文ファイル（`- タスク名: 何をどこまでやるか` の箇条書き。中間ファイルは scratchpad で可）を渡す。`.team/tasks.md`（読み取り専用の議題表）が生成され、`roles/member.md` は単独版になる。`done.sh` は配られない。**議題表を渡さないと setup.sh はエラーで止まる**（空の議題表を作らない）
+4. **Lattice plan（Lattice 併用モードのみ・単独はこの手順ごとスキップ）**: `lattice status --json` で正本を判定する。`uninitialized` なら templates/gen-plan.mjs を雛形に聞き取ったタスクを plan 化して `lattice plan create`。初期化済みなら `todo migrate` の作法（Lattice 正典）に従う。設計メモは各タスクに必ず書く
+   - 単独モードのタスク正本は手順3で生成した `.team/tasks.md` だけである。状態（誰が持っているか・何が終わったか）は持たせない——claim と完了は room の宣言だけが正（決定48 の延長）。ミニタスクトラッカーを別途作らない（決定36）
 5. **メンバー起動**（メンバーごとに aiterm PTY で）:
-   - export: `PEERTABLE_URL` / `PEERTABLE_ROOM` / `PEERTABLE_MEMBER=<romaji>` / `PEERTABLE_POST_TOKEN`（`~/.config/peertable.env` から）/ `PEERTABLE_PLAN=<plan_key>` / `LATTICE_TODO_ACTOR_HOST` / `LATTICE_TODO_ACTOR_SESSION=<romaji>` / `LATTICE_TODO_ACTOR_AGENT=<romaji>`
-   - 起動: `cd <project> && claude --model <model> --mcp-config .team/mcp.json --dangerously-skip-permissions --dangerously-load-development-channels server:room`（`--mcp-config` でプロジェクト root に `.mcp.json` を置かない＝不可侵原則。もし channels が `--mcp-config` のサーバーを解決しない場合だけ、root `.mcp.json` を置いて teardown で消すフォールバックを使い、その旨を報告する）
+   - 起動前に `pty_list` で既存の `peer-*` 席を確認し、前の卓の残骸が残っていれば回収してから立てる（2026-08-08 に他 campaign 由来の残骸を99席実測）
+   - export: `PEERTABLE_URL` / `PEERTABLE_ROOM` / `PEERTABLE_MEMBER=<romaji>` / `PEERTABLE_POST_TOKEN`（`~/.config/peertable.env` から）。**Lattice 併用モードは加えて** `PEERTABLE_PLAN=<plan_key>` / `LATTICE_TODO_ACTOR_HOST` / `LATTICE_TODO_ACTOR_SESSION=<romaji>` / `LATTICE_TODO_ACTOR_AGENT=<romaji>`（単独モードでは不要——渡さない）
+   - 起動: `cd <project> && claude --model <model> [--effort <level>] --dangerously-skip-permissions --dangerously-load-development-channels server:room`（**channels は `--mcp-config` の MCP server を解決しない**（実測 2026-08-08・Claude Code v2.1.226・決定44）ため、room の MCP 定義は setup.sh が project root へ置く `.mcp.json` が正。`.git/info/exclude` 追加と teardown での撤去で不可侵原則を保つ。project に既存 `.mcp.json` があった場合 setup.sh は上書きせず警告を出すので、AI が手動 merge して teardown で復元する）
    - ダイアログを画面確認しながら通す（MCP 同意 → 外部 import は状況判断 → bypass 承諾 → 開発 channel 警告）。バナーに `Channels (experimental) ... server:room` が出たら着席成立
    - 着任指示: 「あなたは「<日本語名>」。.team/roles/member.md を読んで着任し、作業ループを開始せよ。全タスク完了の宣言まで自律的に続けること。」
 6. **親の着卓**（このセッション）: room API へ member 登録（名は bell 等）し、SSE を Monitor で張る。post も API 直（下記「親の operating notes」）
-7. **起動確認**: room の members に全員いる / 各メンバーが Lattice へ到達（最初の claim が room に流れる）/ Web UI で観測できる、をチェックして報告する
+7. **起動確認**: room の members に全員いる / 最初の claim が room に流れる（Lattice 併用モードはそれが Lattice へ到達している＝`lattice todo status --json` の active に出ることも確認する。単独モードは room の claim 宣言だけが到達の証拠）/ Web UI で観測できる、をチェックして報告する
 
 ## teardown
 
-`scripts/teardown.sh <project> <room> <server_url>` が機械部分を行う: tmux セッション終了（先に殺す。`.team/` 消失後の参照事故防止）→ サーバー room 削除 → `.team/` 削除 → `.git/info/exclude` の追記行を戻す → setup が作った `.lattice/` なら削除。実行後 `git status` で diff ゼロを確認して報告する。
+`scripts/teardown.sh <project>` が機械部分を行う（room 名・server URL・作成記録は `.team/setup-state.json` から読むので引数は project だけ。書込トークンは環境変数 `PEERTABLE_POST_TOKEN`）: tmux セッション終了（先に殺す。`.team/` 消失後の参照事故防止）→ サーバー room 削除 → `.team/` 削除 → `.git/info/exclude` の追記行を戻す → setup が作った `.lattice/` なら削除。実行後 `git status` で diff ゼロを確認して報告する。
 
 ## 親の operating notes（このセッションの振る舞い）
 
@@ -46,11 +53,17 @@ description: 任意プロジェクトに Peertable チーム（対等メンバ
   - 発言: `curl -X POST $URL/api/$ROOM/messages -H "X-Peertable-Token: $TOKEN" -d '{"from":"bell","to":"all","body":"..."}'`
   - 観測: Monitor ツールで `curl -sN $URL/api/$ROOM/events` の SSE を張る（V3 実証済みの形）
 - 親の権能は進行・承認・監査・督促・オーナーとの接点だけ。**実務に落ちない**: バグを見つけても直さず、発見内容を room に送って会議に載せる。差し戻しは異議であり、平行線はメンバーが勝つ
-- 督促の検出源は room の報告途絶と Lattice 工程表の乖離
+- **宛先の規律**: channels の起床通知は宛先本人（と全員宛）にしか飛ばない（client の `relevant` フィルタ）。用件が特定メンバーだけなら `to` をそのメンバー名にする——1発言=全席1ターンの課金は全員宛の時だけで、名指しなら起きるのは宛先だけ。ログは宛先に関係なく全員が読める（決定42）ので情報の秘匿にはならない。全員宛を使うのは、決定・gate状態・全体への記録だけ
+- **発言規律（決定43・正典 §3.4）**: 親の room 発言は ①監査結果の事実（受理／異議。「次はこうせよ」を続けない）②承認 gate の状態 ③オーナー裁定の伝達（必ず「オーナー裁定」と明示）の3種だけ。メンバー間合意の再掲・とりまとめ・次タスクの指名・frontier の解説は、内容が正しくても**しない**——親が言い直した瞬間に出典が親へ書き換わり、卓が上下オーケストレーションへ滑る（初回実運用で実測）。裁定依頼が来たら自分で判断せず、オーナー宛の議題として運ぶ
+- 督促の検出源は room の報告途絶と Lattice 工程表の乖離。**単独円卓モードでは工程表が無いので、検出源は `.team/tasks.md` の議題と room ログの照合だけになる**——完走の判定も同じで、全議題に完了報告が揃ったことを親が room ログで確認し、散会を宣言する（この確認と宣言が単独モードの done gate である）
+- **席の縮退も親の進行権能**（散会と同じ性質。決定51）: frontier が細って遊休席が出たら親が畳む。順序を守る——①対象席へ**名指しで**通告（`to: <名前>`。全員宛にしない）②本人に WIP と未報告の作業が無いことを確認する（本人が「まだ持っている」と言えば畳まない。判断は情報を持つ本人がする）③`pty_close` でセッションを終了 ④`curl -X DELETE $URL/api/$ROOM/members/<名前> -H "X-Peertable-Token: $TOKEN"`（`room/server.mjs:94`。server 変更は不要）⑤room 全員宛へ縮退を宣言する。**先に member を消すと本人が最後の報告を出せない**。また member の削除は参加時と違って system 発言を出さないので、⑤を省くと席が黙って消えたように見える
+- **再着任表明（`[再着任] <名前>`）の受け方**: 確認するのはその席の claim 状態と工程正本の齟齬だけ。齟齬があれば監査事実として指摘する（Lattice 併用なら `lattice todo status --json` の active、単独なら room ログとの突き合わせ）。齟齬が無ければ受理も激励もせず黙って通す——1発言=全席1ターンであり、儀礼の返事は卓の燃料を焼くだけ。**代わりに作業を思い出させようとしない**（実務へ落ちる）
+- **散会（待機）の宣言は親の進行権能**: 会議が収束し実作業が外部待ち（承認・publish等）だけになったら、親が「待機。次の発言は<再開trigger>まで不要。この発言にも返信不要」を宣言して畳む。宣言しないと謝辞・同意の応酬が全席を起こし続ける（1発言=全セッション1ターン。会話には作業のdoneに当たる終端記号が無いため、収束後の卓は自然には黙らない——初回実運用で実測）
 
 ## 運用知識（V2/V3 実測の焼き込み）
 
-- Lattice 書込には actor 環境変数 3 点が必須。ready 複数時の start は `--parallel-frontier`
+- Lattice 書込には actor 環境変数 3 点が必須
+- `--parallel-frontier` が要るのは、**ready が複数あって誰も着手していない frontier の最初の start だけ**（無いと `PARALLEL_DISPATCH_REQUIRED / parallel_frontier_requires_declaration` で弾かれる）。ready が1件だけ、または既に誰かが着手している frontier へ後から乗る場合は素の `start` でよい。フラグが効くのは**取る task が `next_ready` に居る時だけ**で、他人が着手済みの task へ付けると `PARALLEL_DISPATCH_INVALID / parallel_frontier_not_applicable` になる——「フラグが使えない」ではなく「**その task はもう空いていない**」の意味である（`Lattice src/todo-cli.mjs:698-704` が唯一の発生条件。independence の compile 状態は無関係で、未 compile でもフラグ付き start は通る。2026-08-08 実測）
 - 同時書込は `STORE_WRITE_CONFLICT` 等で明示的に負ける。1〜2 秒待って再実行すれば通る（正常系）
 - evidence は記述子 JSON。記述子ファイル自体も repo 内相対パスに置く（repo 外絶対パスは INVALID_ARGUMENTS）。`.team/scripts/done.sh` が正規経路
 - channels はリサーチプレビュー。構文が変わったら V0 の要領で公式ドキュメント（code.claude.com/docs/en/channels-reference.md）を再確認する

package/skill/scripts/setup.sh

@@ -1,16 +1,43 @@
 #!/bin/bash
 # Peertable setup の機械部分: .team/ scaffold と git 除外。
-# usage: setup.sh <project_dir> <room> <server_url> <plan_key> <peertable_repo>
+# usage: setup.sh <project_dir> <room> <server_url> <plan_key|-> <peertable_repo> [tasks_file]
+#   plan_key に `-` を渡すと単独円卓モード（工程正本を持たない。決定47）。
+#   単独モードでは tasks_file（聞き取ったタスクを書いた本文）が必須で、議題表 .team/tasks.md になる。
 set -e
-proj="$1"; room="$2"; url="$3"; plan="$4"; repo="$5"
+proj="$1"; room="$2"; url="$3"; plan="$4"; repo="$5"; tasks="$6"
 tpl="$repo/skill/templates"
 tdir="$proj/.team"
 
-mkdir -p "$tdir/roles" "$tdir/scripts"
+if [ "$plan" = "-" ] || [ -z "$plan" ]; then
+  mode=standalone; plan=""
+  # 引数の検証は project へ何か置く前に済ませる（不可侵原則: 半端な .team/ を残さない）
+  if [ -z "$tasks" ] || [ ! -f "$tasks" ]; then
+    echo "ERROR: 単独円卓モードは議題表の本文ファイル（第6引数）が必須: setup.sh ... - <peertable_repo> <tasks_file>" >&2
+    exit 1
+  fi
+else
+  mode=lattice
+fi
+
+mkdir -p "$tdir/roles"
 cp "$tpl/charter.md" "$tdir/CLAUDE.md"
-sed "s|{{PLAN_KEY}}|$plan|g" "$tpl/member.md" > "$tdir/roles/member.md"
-cp "$tpl/done.sh" "$tdir/scripts/done.sh" && chmod +x "$tdir/scripts/done.sh"
-sed "s|{{PEERTABLE_REPO}}|$repo|g" "$tpl/mcp.json" > "$tdir/mcp.json"
+if [ "$mode" = "standalone" ]; then
+  cp "$tpl/member-standalone.md" "$tdir/roles/member.md"
+  cat "$tpl/tasks.md" "$tasks" > "$tdir/tasks.md"
+else
+  mkdir -p "$tdir/scripts"
+  sed "s|{{PLAN_KEY}}|$plan|g" "$tpl/member.md" > "$tdir/roles/member.md"
+  cp "$tpl/done.sh" "$tdir/scripts/done.sh" && chmod +x "$tdir/scripts/done.sh"
+fi
+
+# room MCP 定義は project root の .mcp.json が正（channels は --mcp-config を解決しない。決定44）
+added_root_mcp=false
+if [ -f "$proj/.mcp.json" ]; then
+  echo "WARN: $proj/.mcp.json が既に存在する。上書きしない。room の server 定義を手動 merge し、teardown で復元すること" >&2
+else
+  sed "s|{{PEERTABLE_REPO}}|$repo|g" "$tpl/mcp.json" > "$proj/.mcp.json"
+  added_root_mcp=true
+fi
 
 added_exclude=false
 if [ -d "$proj/.git" ] && ! grep -qx '\.team/' "$proj/.git/info/exclude" 2>/dev/null; then
@@ -18,10 +45,16 @@ if [ -d "$proj/.git" ] && ! grep -qx '\.team/' "$proj/.git/info/exclude" 2>/dev/
   echo '.team/' >> "$proj/.git/info/exclude"
   added_exclude=true
 fi
+added_mcp_exclude=false
+if [ "$added_root_mcp" = "true" ] && [ -d "$proj/.git" ] && ! grep -qx '/\.mcp\.json' "$proj/.git/info/exclude" 2>/dev/null; then
+  mkdir -p "$proj/.git/info"
+  echo '/.mcp.json' >> "$proj/.git/info/exclude"
+  added_mcp_exclude=true
+fi
 
 lattice_preexisting=false
 [ -d "$proj/.lattice" ] && lattice_preexisting=true
 
-printf '{"room":"%s","server_url":"%s","plan_key":"%s","added_exclude":%s,"lattice_preexisting":%s}\n' \
-  "$room" "$url" "$plan" "$added_exclude" "$lattice_preexisting" > "$tdir/setup-state.json"
+printf '{"room":"%s","server_url":"%s","mode":"%s","plan_key":"%s","added_exclude":%s,"lattice_preexisting":%s,"added_root_mcp":%s,"added_mcp_exclude":%s}\n' \
+  "$room" "$url" "$mode" "$plan" "$added_exclude" "$lattice_preexisting" "$added_root_mcp" "$added_mcp_exclude" > "$tdir/setup-state.json"
 echo "scaffold done: $tdir"

package/skill/scripts/teardown.sh

@@ -9,9 +9,19 @@ room=$(python3 -c "import json;print(json.load(open('$state'))['room'])")
 url=$(python3 -c "import json;print(json.load(open('$state'))['server_url'])")
 added=$(python3 -c "import json;print(json.load(open('$state'))['added_exclude'])")
 lat_pre=$(python3 -c "import json;print(json.load(open('$state'))['lattice_preexisting'])")
+# 旧 state（added_root_mcp 不在・手動フォールバック時代の root_mcp_json_fallback）も読む
+added_mcp=$(python3 -c "import json;d=json.load(open('$state'));print(d.get('added_root_mcp', d.get('root_mcp_json_fallback', False)))")
+added_mcp_ex=$(python3 -c "import json;d=json.load(open('$state'));print(d.get('added_mcp_exclude', d.get('root_mcp_json_fallback', False)))")
 
 curl -sf -X DELETE "$url/api/$room" -H "X-Peertable-Token: ${PEERTABLE_POST_TOKEN:-}" > /dev/null
 rm -rf "$proj/.team"
+if [ "$added_mcp" = "True" ] || [ "$added_mcp" = "true" ]; then
+  rm -f "$proj/.mcp.json"
+fi
+if [ "$added_mcp_ex" = "True" ] || [ "$added_mcp_ex" = "true" ]; then
+  grep -vx '/\.mcp\.json' "$proj/.git/info/exclude" > "$proj/.git/info/exclude.tmp" || true
+  mv "$proj/.git/info/exclude.tmp" "$proj/.git/info/exclude"
+fi
 if [ "$added" = "True" ] || [ "$added" = "true" ]; then
   grep -vx '\.team/' "$proj/.git/info/exclude" > "$proj/.git/info/exclude.tmp" || true
   mv "$proj/.git/info/exclude.tmp" "$proj/.git/info/exclude"

package/skill/templates/charter.md

@@ -2,10 +2,13 @@
 
 これはチーム作業である。自分の claim したタスクの完了はミッションの完了ではない。全タスク完了までチームは解散しない。
 
-1. 拘束力を持つのは Lattice への書き込みと room での決定だけ。DM（個別宛）で決まったことは決定ではない。部位を跨ぐ合意・設計判断は必ず room 全員宛で行う
-2. 進捗は room に一行で報告する: claim 時・join 時・完了時・詰まり自覚時・方針変更時。仲間を五里霧中に置かない
-3. claim の手順: room へ「[claim] <task_id>」を全員宛で投稿し、直後に read_unread で直前ログを確認する。同じタスクへの先行 claim があれば取り下げるか「[join] <task_id>」へ切り替える
+1. 拘束力を持つのは**工程正本への記録**と room での決定だけ（工程正本＝Lattice 併用モードなら Lattice の todo 記録、単独円卓モードなら room の宣言そのもの）。DM（個別宛）で決まったことは決定ではない。部位を跨ぐ合意・設計判断は必ず room 全員宛で行う
+2. 進捗は room に一行で報告する: claim 時・join 時・完了時・詰まり自覚時・方針変更時。task 外でも成果物になる作業（実測・検証・CI）は着手前に一言。仲間を五里霧中に置かない
+3. claim の手順: room へ「[claim] <タスク>」を全員宛で投稿し、直後に read_unread で直前ログを確認する（タスクの呼び名は Lattice 併用モードなら task_id、単独円卓モードなら `.team/tasks.md` の議題名）。同じタスクへの先行 claim があれば取り下げるか「[join] <タスク>」へ切り替える
 4. 分からないことは room で聞く。台帳はない。自分の変更が他の部位に影響するなら、聞かれる前に room 全員宛で通知する
 5. 判断は情報を持つ者がする。タスクは席ではなく現場。合流（join）は歓迎される。詰まった仲間には目を貸す。手が足りないだけなら自分のサブエージェントを使う（room 報告不要）。視点が足りない・詰んでいるなら room で報告して援軍（join）を求める
-6. タスク完了後は必ず Lattice で次の ready を確認する。ready があれば claim へ、全タスク done なら room へ「全タスク完了」を全員宛で宣言する
+6. タスク完了後は必ず工程正本で次の着手可能を確認する（Lattice 併用モードは `lattice todo status`、単独円卓モードは `.team/tasks.md` と room ログの照合）。残っていれば claim へ、全タスクが終わっていれば room へ「全タスク完了」を全員宛で宣言する
 7. 役割逸脱は誰であれ指摘する。これは無礼ではなく義務である
+8. **親の発言は拘束力を持たない。** 設計・手順・contract の出典は必ずメンバー自身の宣言（発言番号）か Lattice を参照する——「親がこう言ったから」「bell の [N] どおり」を根拠にしない。親が何かを再掲しても正本はメンバーの元発言のまま動かない。親の差し戻しは異議として扱い、反論してよい
+9. **裁定の宛先はオーナーであり、親ではない。** scope 変更・受入条件外の追加・製品判断が要る時は「オーナー宛の議題」として room に出す。親はそれを運ぶ配管で、判断者ではない。「親に委ねる」という宛先を作らない
+10. 決まっていない境界に会ったら、規則を探すより先に room で喋って決める。会話で解決するのは正規の手段であり、その場の合意は憲章の不足を補う

package/skill/templates/member-standalone.md

@@ -0,0 +1,27 @@
+# メンバー役割（単独円卓モード）
+
+あなたはこのプロジェクトの対等なメンバーである。指揮者はいない。判断はメンバーが行う。親（bell 等）が卓に居ることがあるが、それは監査・承認 gate・オーナー窓口の係であって判断の主体ではない——親の発言を仕様の出典にせず、裁定が要る議題はオーナー宛として出す（憲章8・9）。あなたの名前は環境変数 `PEERTABLE_MEMBER` にある。room ツール（post / read_unread / read_log / members)で仲間と話せる。
+
+この卓は**単独円卓モード**である。工程管理ツールは使わない。議題の正本は読み取り専用の `.team/tasks.md`、**進行の正本は room の宣言だけ**（誰が何を持っているか・何が終わったかは room ログにしか無い）。tasks.md を書き換えても進行は動かないので書き換えない。
+
+## 作業ループ
+
+1. `.team/tasks.md` で議題を見る。`read_log` で既存の claim と完了報告を照合し、まだ誰も持っていないものを選ぶ
+2. 憲章の手順で room に `[claim] <タスク>` を全員宛で宣言し、直後に `read_unread` で先行 claim が無いか確かめる
+3. 実装する。インターフェースなど他タスクに影響する決定は、決めた時点で room 全員宛に一行で共有する
+4. 完了手順:
+   - 何を作り、どう確認したかを自分で確かめる（テスト・実行・実測。「たぶん動く」で閉じない）
+   - 変更ファイルを `git add` して commit する（メッセージは日本語一行。対象ファイルを明示して他人の作業中変更を巻き込まない）
+5. room へ `[done] <タスク>` を全員宛で報告する（何を作り、どう確認したかを一行で添える）。**この報告が完了の唯一の記録である**——書かなければ完了していない
+6. 1 へ戻る
+
+## 再着任（context が要約されたら）
+
+自分の context が要約された（＝会話の前半が手元に無い）と気づいたら、実装を続ける前に `.team/roles/member.md` と `.team/CLAUDE.md` を読み直して着任し直し、room へ `[再着任] <名前>` を一行投稿する。進行中 claim の状態は自分の記憶でなく**工程正本で取り直す**——この卓の工程正本は room の宣言だけなので、`read_log` で自分の claim・他人の claim・完了報告を全部照合する（機械に問い合わせる先は無い）。記憶と正本が食い違ったら、正本を正として食い違いを room で報告する。
+
+## 注意
+
+- 誰が何を持っているかを機械に問い合わせられない卓である。claim と完了の宣言を落とした瞬間に重複作業になるので、宣言を省かない
+- room の新着通知が来たら read_unread で読む。返事が要るものには post で応える
+- 全タスクの完了報告が揃ったかの判定と散会の宣言は親が行う。自分の担当が終わっても散会宣言までは卓に残り、仲間の求めに応える
+- 憲章（.team/CLAUDE.md）が全ての基底である

package/skill/templates/member.md

@@ -1,12 +1,12 @@
 # メンバー役割
 
-あなたはこのプロジェクトの対等なメンバーである。親（オーケストレーター）はいない。判断はメンバーが行う。あなたの名前は環境変数 `PEERTABLE_MEMBER` にある。room ツール（post / read_unread / read_log / members)で仲間と話せる。plan key は `{{PLAN_KEY}}`。
+あなたはこのプロジェクトの対等なメンバーである。指揮者はいない。判断はメンバーが行う。親（bell 等）が卓に居ることがあるが、それは監査・承認 gate・オーナー窓口の係であって判断の主体ではない——親の発言を仕様の出典にせず、裁定が要る議題はオーナー宛として出す（憲章8・9）。あなたの名前は環境変数 `PEERTABLE_MEMBER` にある。room ツール（post / read_unread / read_log / members)で仲間と話せる。plan key は `{{PLAN_KEY}}`。
 
 ## 作業ループ
 
 1. `lattice todo status --json` で ready なタスクを見る
 2. 憲章の手順で room に claim を宣言する
-3. `lattice todo start --plan {{PLAN_KEY}} --task <id> --parallel-frontier` で着手を記録する
+3. `lattice todo start --plan {{PLAN_KEY}} --task <id>` で着手を記録する。**誰も着手しておらず ready が2件以上ある frontier の先頭を取る時だけ `--parallel-frontier` が必須**（無いと `PARALLEL_DISPATCH_REQUIRED / parallel_frontier_requires_declaration` で弾かれる）。ready が1件だけ、または既に誰かが着手している frontier へ後から乗る時は素の start でよい
 4. 実装する。インターフェースなど他タスクに影響する決定は、決めた時点で room 全員宛に一行で共有する
 5. 完了手順:
    - 証跡ファイル `evidence/<task_id>.md` に「何を作り、どう確認したか」を書く
@@ -14,8 +14,15 @@
    - `.team/scripts/done.sh <task_id>` を実行する（evidence 記述子の生成と `lattice todo done` をやってくれる）
 6. room に完了を一行報告し、1 へ戻る
 
+## 再着任（context が要約されたら）
+
+自分の context が要約された（＝会話の前半が手元に無い）と気づいたら、実装を続ける前に `.team/roles/member.md` と `.team/CLAUDE.md` を読み直して着任し直し、room へ `[再着任] <名前>` を一行投稿する。進行中 claim の状態は自分の記憶でなく**工程正本で取り直す**——`lattice todo status --json` の active に自分の task が居るかを確認し、`read_log` で自分の claim と完了報告を照合する。記憶と正本が食い違ったら、正本を正として食い違いを room で報告する。
+
 ## 注意
 
 - Lattice の書き込みが `STORE_WRITE_CONFLICT` 等で弾かれたら、1〜2 秒待って同じコマンドを再実行する（同時書込の正常な負け方であり、壊れてはいない）
+- `--parallel-frontier` を付けた start が `parallel_frontier_not_applicable` で弾かれたら、それは**その task がもう `next_ready` に居ない**（他人が着手済み・依存で塞がった）という意味である。フラグの不具合ではないので付け外しで粘らず、`lattice todo status --json` と room ログで claim 状況を確認し直す
+- claim が衝突したら、Lattice の start 記録（誰が in-progress か）を機械の事実として使う。会話の言った言わないより先に工程正本を見る
+- **note が持つものを room の散文へ二重化しない**。設計メモ・タスク固有の経緯は `lattice todo note` に置き、room には決定と進捗だけを流す
 - room の新着通知が来たら read_unread で読む。返事が要るものには post で応える
 - 憲章（.team/CLAUDE.md）が全ての基底である

package/skill/templates/tasks.md

@@ -0,0 +1,8 @@
+# タスク一覧（単独円卓モード・読み取り専用）
+
+setup の聞き取りで確定した議題表である。**読み取り専用**——この表は状態を持たない。誰が何を持っているか・何が終わったかは room の宣言だけが正（憲章1）。ここへ担当や進捗を書き込んでも進行は動かない。
+
+依存関係の機械保証は無い。順序や排他が要る議題に会ったら、規則を探すより先に room で喋って決める（憲章10）。
+
+## 議題
+