peertable 0.3.8 → 0.3.10

package/skill/scripts/parent-join.sh

@@ -1,31 +1,40 @@
 #!/bin/bash
 # 親（ベル等）が room へ着卓する。
-# usage: parent-join.sh <project_dir> [name] [model] [effort]
+# usage: parent-join.sh <project_dir> [name] [model] [effort] [vendor]
 #   name 既定は bell。broadcast廃止に伴いkickoff投稿は行わない。
-#   model / effort は任意。親はオーナーの対話セッション（決定40）なので、席と違って
+#   model / effort / vendor は任意。親はオーナーの対話セッション（決定40）なので、席と違って
 #   起動時に確定した値を script が知らない——**渡された時だけ**参加者一覧の素性として登録する。
 #   渡さなければ欄ごと出ない（「不明」ではなく「素性を名乗っていない」）。
+#   vendor は claude（既定）または codex。model だけ渡して vendor を渡さない場合は claude とみなす
+#   （後方互換）。
 # 親は MCP を後付けできないので room へは HTTP API 直で入る（決定40 の operating notes）。
 set -e
-proj="$1"; name="${2:-bell}"; model="$3"; effort="$4"
+proj="$1"; name="${2:-bell}"; model="$3"; effort="$4"; vendor="$5"
 state="$proj/.team/setup-state.json"
 room=$(python3 -c "import json;print(json.load(open('$state'))['room'])")
 url=$(python3 -c "import json;print(json.load(open('$state'))['server_url'])")
+mode=$(python3 -c "import json;print(json.load(open('$state')).get('mode',''))")
 
 if [ -z "${PEERTABLE_POST_TOKEN:-}" ] && [ -f "$HOME/.config/peertable.env" ]; then
   . "$HOME/.config/peertable.env"
 fi
 
-member=$(python3 - "$name" "$model" "$effort" <<'PY'
+# 親はAiterm席ではない。Claude/Codexとも、親自身が所有するparent-watchを配送先にする。
+# tmux observeやCodex thread IDを登録すると、通常席bridge／外部resumeへ誤配送される。
+parent_vendor="${vendor:-claude}"
+member=$(python3 - "$name" "$model" "$effort" "$parent_vendor" <<'PY'
 import json, sys
-name, model, effort = sys.argv[1:4]
+name, model, effort, vendor = sys.argv[1:5]
 body = {'name': name}
 # 渡された欄だけ載せる。空欄を送ると、素性を持つ既存登録を空で上書きしうる
+if model or vendor:
+    body['vendor'] = vendor or 'claude'
 if model:
-    body['vendor'] = 'claude'
     body['model'] = model
 if effort:
     body['effort'] = effort
+body['observe'] = None
+body['delivery'] = {'kind': 'parent_watch', 'host': vendor}
 print(json.dumps(body))
 PY
 )
@@ -34,4 +43,35 @@ curl -sf -X POST "$url/api/$room/members" \
   -d "$member" > /dev/null
 echo "joined: ${name}（room=${room}）"
 
+here="$(cd "$(dirname "$0")" && pwd)"
+
+# owner裁定[46]④: 子processのexportは親shellへ伝播しないため、Lattice mutation
+# （todo reopen 等）に要る actor 環境変数は親自身が source する持続ファイルとして配る。
+if [ "$mode" = "lattice" ]; then
+  env_file="$proj/.team/parent-env.sh"
+  cat > "$env_file" <<EOF
+export LATTICE_TODO_ACTOR_HOST=mac
+export LATTICE_TODO_ACTOR_SESSION=${name}
+export LATTICE_TODO_ACTOR_AGENT=${name}
+EOF
+  echo "Lattice mutation（todo reopen 等）を打つ前に: source ${env_file}"
+fi
+
+if [ -f "$proj/.team/roles/parent.md" ]; then
+  echo "親役割は $proj/.team/roles/parent.md を読むこと"
+fi
+
+# parent-watchが初回headを固定する。以後のDMはwatcher不在時間を含め
+# 永続cursorからcatch-upされる。host内のbackground task自体は親セッションだけが所有できる。
+if PEERTABLE_PARENT_HOST="$parent_vendor" node "$here/parent-watch.mjs" "$proj" "$name" --prime; then
+  echo "parent-watch cursor ready: ${name}（host=${parent_vendor}）"
+  if [ "$parent_vendor" = "codex" ]; then
+    echo "PARENT_WATCH_START_REQUIRED: Codex親のbackground taskで1秒ごとに ${here}/codex-parent-watch.sh ${proj} ${name} を都度実行し、空でないstdoutだけを親turnへnotifyすること。background taskはloopを続けるが、Node processや端末sessionは常駐させない"
+  else
+    echo "PARENT_WATCH_START_REQUIRED: Claude Monitor（persistent）で ${here}/parent-watch.mjs ${proj} ${name} --follow を1回だけ起動し、通知後も同じMonitorで待機を続けること"
+  fi
+else
+  echo "WARN: PARENT_WATCH_PRIME_FAILED: 親（${name}）のDM cursorを準備できない" >&2
+fi
+
 curl -sf "$url/api/$room/members" | python3 -c "import json,sys;print('members:', ', '.join(m['name'] for m in json.load(sys.stdin)['members']))"

package/skill/scripts/parent-watch.mjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+// 親セッション自身が所有するバックグラウンド通知用の room watcher。
+// room/SSE の解釈はここへ集約し、Claude Monitor / Codex background task は
+// この process が stdout へ出す構造化 event を親へ返すことだけを担う。
+//
+// usage: parent-watch.mjs <project_dir> [parent_name] --prime
+//        parent-watch.mjs <project_dir> [parent_name] --poll
+//        parent-watch.mjs <project_dir> [parent_name] --next
+//        parent-watch.mjs <project_dir> [parent_name] --follow
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const args = process.argv.slice(2)
+const project = args.shift()
+let parent = 'bell'
+if (args[0] && !args[0].startsWith('--')) parent = args.shift()
+const mode = args.shift() ?? '--follow'
+if (!project || !['--prime', '--poll', '--next', '--follow'].includes(mode) || args.length > 0) {
+  console.error('usage: parent-watch.mjs <project_dir> [parent_name] <--prime|--poll|--next|--follow>')
+  process.exit(2)
+}
+
+const team = join(project, '.team')
+const setupPath = join(team, 'setup-state.json')
+const statePath = join(team, 'parent-watch.json')
+const lockPath = join(team, 'parent-watch.lock')
+const setup = JSON.parse(readFileSync(setupPath, 'utf8'))
+const room = setup.room
+const serverUrl = setup.server_url.replace(/\/$/u, '')
+const latticeCli = setup.lattice_cli || process.env.LATTICE_CLI || 'lattice'
+const api = `${serverUrl}/api/${encodeURIComponent(room)}`
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+const now = () => new Date().toISOString()
+const ROOM_UPDATE_BODY = 'room全体の状況が更新された。roomログを読み、状況を把握して次の行動を判断する。'
+const staffingBody = ({ ready, active }) => `現在、着手可能工程は ${ready} 件、着手中工程は ${active} 件になりました。標準は ${ready + active}＋監査担当数です。円卓メンバー数を検討してください。`
+
+function readLatticeState(previous = null) {
+  const manifest = join(project, '.lattice', 'todo', 'manifest.json')
+  if (!existsSync(manifest)) return null
+  let info
+  try { info = statSync(manifest) } catch { return null }
+  const source = `${info.mtimeMs}:${info.size}`
+  if (previous?.source === source && previous.error === undefined) return previous
+  try {
+    const status = JSON.parse(execFileSync(latticeCli, ['todo', 'status', '--json'], {
+      cwd: project,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }))
+    if (!Array.isArray(status.next_ready) || !Array.isArray(status.active_set)) {
+      throw new Error('invalid schema')
+    }
+    return { ready: status.next_ready.length, active: status.active_set.length, source }
+  } catch {
+    return { error: 'LATTICE_TODO_STATUS_FAILED', source }
+  }
+}
+
+function loadState() {
+  if (!existsSync(statePath)) return null
+  try {
+    const saved = JSON.parse(readFileSync(statePath, 'utf8'))
+    if (saved.room !== room || saved.server_url !== serverUrl || saved.parent !== parent) return null
+    if (!Number.isSafeInteger(saved.last_seq) || saved.last_seq < 0) return null
+    return saved
+  } catch {
+    return null
+  }
+}
+
+function saveState(state) {
+  const temp = `${statePath}.${process.pid}.tmp`
+  writeFileSync(temp, `${JSON.stringify(state)}\n`, { mode: 0o600 })
+  renameSync(temp, statePath)
+}
+
+async function readJson(path) {
+  const response = await fetch(`${api}${path}`)
+  if (!response.ok) throw new Error(`${path} ${response.status}`)
+  return response.json()
+}
+
+async function ensurePrimed() {
+  const saved = loadState()
+  if (saved) {
+    let lattice = saved.lattice
+    if (!lattice?.source) {
+      const observed = readLatticeState()
+      lattice = observed?.error ? null : observed
+    }
+    const next = {
+      ...saved,
+      lattice,
+      ready_at: now(),
+      host: process.env.PEERTABLE_PARENT_HOST || saved.host || null,
+    }
+    saveState(next)
+    return next
+  }
+  const summary = await readJson('/summary')
+  const observed = readLatticeState()
+  const state = {
+    schema: 'peertable.parent-watch-state.v1',
+    room,
+    server_url: serverUrl,
+    parent,
+    last_seq: Number.isSafeInteger(summary.seq) ? summary.seq : 0,
+    lattice: observed?.error ? null : observed,
+    ready_at: now(),
+    host: process.env.PEERTABLE_PARENT_HOST || null,
+  }
+  saveState(state)
+  return state
+}
+
+let state = await ensurePrimed()
+if (mode === '--prime') process.exit(0)
+
+const alive = pid => { try { process.kill(pid, 0); return true } catch { return false } }
+function acquireLock() {
+  try {
+    writeFileSync(lockPath, `${process.pid}\n`, { flag: 'wx', mode: 0o600 })
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error
+    let owner = null
+    try { owner = Number(readFileSync(lockPath, 'utf8').trim()) } catch {}
+    if (Number.isSafeInteger(owner) && !alive(owner)) {
+      unlinkSync(lockPath)
+      writeFileSync(lockPath, `${process.pid}\n`, { flag: 'wx', mode: 0o600 })
+      return
+    }
+    console.error(`PARENT_WATCH_ALREADY_RUNNING: pid ${Number.isSafeInteger(owner) ? owner : '不明'}`)
+    process.exit(1)
+  }
+}
+function releaseLock() {
+  try {
+    if (Number(readFileSync(lockPath, 'utf8').trim()) === process.pid) unlinkSync(lockPath)
+  } catch {}
+}
+acquireLock()
+process.on('exit', releaseLock)
+
+const addressedToParent = message => message?.from !== parent
+  && (message?.to === 'all' || message?.to === parent
+    || (Array.isArray(message?.to_names) && message.to_names.includes(parent)))
+
+async function writeEvent(event) {
+  await new Promise((resolve, reject) => {
+    process.stdout.write(`${JSON.stringify(event)}\n`, error => error ? reject(error) : resolve())
+  })
+}
+
+async function acceptLatticeState(next) {
+  if (next === null) return false
+  const previous = state.lattice
+  if (next.error !== undefined) {
+    if (previous?.error === next.error && previous.source === next.source) return false
+    state = { ...state, lattice: { ...previous, ...next }, last_event_at: now() }
+    saveState(state)
+    await writeEvent({
+      schema: 'peertable.parent-watch-event.v1',
+      type: 'parent_lattice_error',
+      parent,
+      code: next.error,
+      body: 'Lattice工程状態を取得できませんでした。親番犬のroom追従は継続します。',
+    })
+    return true
+  }
+  const changed = Number.isSafeInteger(previous?.ready) && Number.isSafeInteger(previous?.active)
+    && previous.ready + previous.active !== next.ready + next.active
+  state = { ...state, lattice: next, last_event_at: now() }
+  saveState(state)
+  if (!changed) return false
+  await writeEvent({
+    schema: 'peertable.parent-watch-event.v1',
+    type: 'parent_lattice_update',
+    parent,
+    ready: next.ready,
+    active: next.active,
+    standard_worker_count: next.ready + next.active,
+    body: staffingBody(next),
+  })
+  return true
+}
+
+async function acceptMessage(message) {
+  if (!Number.isSafeInteger(message?.seq) || message.seq <= state.last_seq) return false
+  const matched = addressedToParent(message)
+  if (matched) {
+    const roomUpdate = message.to === 'all'
+    await writeEvent({
+      schema: 'peertable.parent-watch-event.v1',
+      type: roomUpdate ? 'parent_room_update' : 'parent_dm',
+      parent,
+      seq: message.seq,
+      from: message.from,
+      to: message.to ?? null,
+      to_names: message.to_names ?? null,
+      body: roomUpdate ? ROOM_UPDATE_BODY : message.body,
+      message: roomUpdate
+        ? { seq: message.seq, ts: message.ts, from: message.from, to: message.to }
+        : message,
+    })
+  }
+  state = { ...state, last_seq: message.seq, last_event_at: now() }
+  saveState(state)
+  return matched
+}
+
+async function catchUp() {
+  if (await acceptLatticeState(readLatticeState(state.lattice)) && mode === '--next') return true
+  const body = await readJson(`/messages?since=${state.last_seq}`)
+  for (const message of body.messages ?? []) {
+    if (await acceptMessage(message) && mode === '--next') return true
+  }
+  return false
+}
+
+// Codex親のbackground task向け。HTTP catch-upを一度だけ行って即終了する。
+// 長寿命なのはbackground taskのloopだけで、端末sessionやNode processは常駐させない。
+if (mode === '--poll') {
+  await catchUp()
+  process.exit(0)
+}
+
+const nextWindowMs = Number(process.env.PEERTABLE_PARENT_WATCH_WINDOW_MS ?? 55_000)
+if (mode === '--next' && (!Number.isFinite(nextWindowMs) || nextWindowMs < 100)) {
+  console.error('PARENT_WATCH_WINDOW_INVALID')
+  process.exit(2)
+}
+
+let consecutiveFailures = 0
+for (;;) {
+  const deadline = mode === '--next' ? Date.now() + nextWindowMs : Number.POSITIVE_INFINITY
+  try {
+    if (await catchUp()) process.exit(0)
+    const controller = new AbortController()
+    const remaining = Number.isFinite(deadline) ? Math.max(1, deadline - Date.now()) : null
+    const timer = remaining === null ? null : setTimeout(() => controller.abort(), remaining)
+    try {
+      const response = await fetch(`${api}/events`, { signal: controller.signal })
+      if (!response.ok) throw new Error(`events ${response.status}`)
+      consecutiveFailures = 0
+      let buffer = ''
+      for await (const chunk of response.body) {
+        buffer += Buffer.from(chunk).toString('utf8')
+        const frames = buffer.split('\n\n')
+        buffer = frames.pop()
+        for (const frame of frames) {
+          const lines = frame.split('\n')
+          const eventName = lines.find(line => line.startsWith('event: '))?.slice(7).trim()
+          const data = lines.filter(line => line.startsWith('data: ')).map(line => line.slice(6)).join('\n')
+          if (eventName === 'ping') {
+            const head = Number(data)
+            if (await acceptLatticeState(readLatticeState(state.lattice)) && mode === '--next') process.exit(0)
+            if (Number.isSafeInteger(head) && head > state.last_seq && await catchUp()) process.exit(0)
+            continue
+          }
+          if (eventName !== undefined && eventName !== 'message') continue
+          if (!data) continue
+          if (await acceptMessage(JSON.parse(data)) && mode === '--next') process.exit(0)
+        }
+      }
+      throw new Error('events disconnected')
+    } finally {
+      if (timer !== null) clearTimeout(timer)
+    }
+  } catch (error) {
+    if (mode === '--next' && error.name === 'AbortError' && Date.now() >= deadline) process.exit(0)
+    consecutiveFailures += 1
+    if (consecutiveFailures >= 10) {
+      await writeEvent({
+        schema: 'peertable.parent-watch-event.v1',
+        type: 'watch_error',
+        parent,
+        code: 'PARENT_WATCH_UNREACHABLE',
+        detail: error.message,
+      })
+      process.exit(1)
+    }
+    if (mode === '--next' && Date.now() >= deadline) process.exit(0)
+    await sleep(Math.min(2000, Math.max(1, deadline - Date.now())))
+  }
+}

package/skill/scripts/seat-credential.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// 席の書込credentialを、秘密値をargv/envへ載せず作成・利用・撤去する境界。
+import { createHash } from 'node:crypto'
+import {
+  chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync,
+  readdirSync, renameSync, rmdirSync, unlinkSync, writeFileSync,
+} from 'node:fs'
+import { homedir } from 'node:os'
+import { join, relative, resolve } from 'node:path'
+import { parsePostTokenEnvFile } from './seat-usage.mjs'
+
+const fail = (code, message) => {
+  process.stderr.write(`${code}: ${message}\n`)
+  process.exit(1)
+}
+
+const credentialRoot = project => resolve(project, '.team', 'credentials')
+const memberKey = member => createHash('sha256').update(member).digest('hex').slice(0, 12)
+const credentialPath = (project, room, member) => {
+  const roomKey = createHash('sha256').update(room).digest('hex').slice(0, 12)
+  return join(credentialRoot(project), `${memberKey(member)}-${roomKey}.token`)
+}
+
+const assertOwnedPath = (project, path) => {
+  const root = credentialRoot(project)
+  const target = resolve(path)
+  const rel = relative(root, target)
+  if (!rel || rel.startsWith('..') || rel.includes('/../'))
+    fail('SEAT_CREDENTIAL_PATH_INVALID', 'credential pathが対象projectの所有範囲外')
+  return { root, target }
+}
+
+const readCredential = path => {
+  let token
+  try { token = readFileSync(path, 'utf8').trim() } catch {
+    fail('SEAT_CREDENTIAL_UNREADABLE', 'credential fileを読めない')
+  }
+  if (!token) fail('SEAT_CREDENTIAL_INVALID', 'credential fileが空')
+  return token
+}
+
+const [action, ...args] = process.argv.slice(2)
+switch (action) {
+  case 'path': {
+    const [project, room, member] = args
+    if (!project || !room || !member) fail('SEAT_CREDENTIAL_ARGS_INVALID', 'path <project> <room> <member>')
+    process.stdout.write(credentialPath(project, room, member) + '\n')
+    break
+  }
+  case 'prepare': {
+    const [project, room, member] = args
+    if (!project || !room || !member) fail('SEAT_CREDENTIAL_ARGS_INVALID', 'prepare <project> <room> <member>')
+    const source = process.env.PEERTABLE_TOKEN_SOURCE_FILE
+      || join(process.env.HOME || homedir(), '.config', 'peertable.env')
+    let sourceText
+    try { sourceText = readFileSync(source, 'utf8') } catch {
+      fail('SEAT_CREDENTIAL_SOURCE_UNREADABLE', '書込トークン設定fileを読めない')
+    }
+    const token = parsePostTokenEnvFile(sourceText)
+    if (!token) fail('SEAT_CREDENTIAL_TOKEN_MISSING', '書込トークン設定fileに値が無い')
+
+    const root = credentialRoot(project)
+    mkdirSync(root, { recursive: true, mode: 0o700 })
+    chmodSync(root, 0o700)
+    const target = credentialPath(project, room, member)
+    for (const entry of readdirSync(root)) {
+      if (entry.startsWith(`${memberKey(member)}-`) && entry.endsWith('.token') && join(root, entry) !== target)
+        unlinkSync(join(root, entry))
+    }
+    const temporary = join(root, `.${process.pid}.${Date.now()}.tmp`)
+    let fd
+    try {
+      fd = openSync(temporary, 'wx', 0o600)
+      writeFileSync(fd, token + '\n', 'utf8')
+      fsyncSync(fd)
+      closeSync(fd)
+      fd = undefined
+      chmodSync(temporary, 0o600)
+      renameSync(temporary, target)
+      chmodSync(target, 0o600)
+    } catch (error) {
+      if (fd !== undefined) closeSync(fd)
+      if (existsSync(temporary)) unlinkSync(temporary)
+      fail('SEAT_CREDENTIAL_PREPARE_FAILED', error.message)
+    }
+    process.stdout.write(target + '\n')
+    break
+  }
+  case 'request': {
+    const [credential, method, url, body = ''] = args
+    if (!credential || !method || !url) fail('SEAT_CREDENTIAL_ARGS_INVALID', 'request <credential> <method> <url> [json-body]')
+    const token = readCredential(credential)
+    let response
+    try {
+      response = await fetch(url, {
+        method,
+        headers: { 'Content-Type': 'application/json', 'X-Peertable-Token': token },
+        ...(body ? { body } : {}),
+      })
+    } catch {
+      fail('SEAT_CREDENTIAL_REQUEST_UNREACHABLE', 'roomへ到達できない')
+    }
+    const responseBody = await response.text()
+    if (!response.ok) fail('SEAT_CREDENTIAL_REQUEST_FAILED', `HTTP ${response.status}`)
+    process.stdout.write(responseBody)
+    break
+  }
+  case 'remove': {
+    const [project, path] = args
+    if (!project || !path) fail('SEAT_CREDENTIAL_ARGS_INVALID', 'remove <project> <credential>')
+    const { root, target } = assertOwnedPath(project, path)
+    if (existsSync(target)) unlinkSync(target)
+    if (existsSync(root) && readdirSync(root).length === 0) rmdirSync(root)
+    break
+  }
+  default:
+    fail('SEAT_CREDENTIAL_ARGS_INVALID', 'prepare|path|request|remove を指定する')
+}

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

@@ -14,7 +14,9 @@
 //             確認ダイアログで停止した席が busy と `esc to interrupt` 不在から idle 側に誤判定され、
 //             動けない席へ卓が代走を申し出るところまで進んだ。判定順は busy → blocked → idle
 //             （承認プロンプト表示中は `esc to interrupt` が消えるので、この順で正しい）
-//   dead    = tmux セッションが無い／`pane_dead=1`
+//   dead    = tmux セッションが無い／`pane_dead=1`／画面は idle 風だが中の CLI プロセスが停止
+//             （`ps` stat 先頭 `T`。Lattice pull run の accept hold が attach 済み worker へ
+//             SIGSTOP を送る局面等。2026-08-11 実測）
 //   idle    = 生きていて busy でも blocked でもない
 //
 // 送信は「変化した時」＋「変化が無くても心拍」の2本立て。変化時だけだと、**bridge が死んだのか状態が
@@ -24,7 +26,7 @@ import { execFileSync } from 'node:child_process'
 import { existsSync, readFileSync, renameSync, writeFileSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { classifyPaneTail, decideBridgeContinuation, deriveMissingSession, parsePaneTokenHint, resolvePostToken, resolveSeatObservation, resolveTmuxSocket, supportsMemberObservation } from './seat-usage.mjs'
+import { classifyPaneTail, decideBridgeContinuation, deriveMissingSession, isPaneProcessStopped, parsePaneTokenHint, resolvePostToken, resolveSeatObservation, resolveTmuxSocket, supportsMemberObservation, tmuxPanePid } from './seat-usage.mjs'
 
 const args = process.argv.slice(2)
 const proj = args[0]
@@ -108,7 +110,12 @@ function readSeat(member, previous, observedAt) {
   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)
+  const tentativeStatus = classifyPaneTail(tail)
+  // pane 自体は生きたまま中の CLI プロセスだけが停止する局面（Lattice pull run の accept hold 等）を
+  // 拾う。画面の残像だけでは idle に誤判定するため、idle と読めた時だけ実プロセスの stat を見る。
+  const status = tentativeStatus === 'idle' && isPaneProcessStopped(tmuxPanePid(target.socket, target.target))
+    ? 'dead'
+    : tentativeStatus
   const busySince = status === 'busy' || status === 'blocked'
     ? ((previous?.status === 'busy' || previous?.status === 'blocked') && previous.busySince ? previous.busySince : observedAt)
     : null

package/skill/scripts/seat-usage.mjs

@@ -101,12 +101,16 @@ export function parsePostTokenEnvFile(text) {
 }
 
 /**
- * launch-seat.sh:25-27 と同じ解決規則で書込トークンを決める（env が先・無ければ設定ファイル）。
- * 規則を二重に書かない——bash 側だけが自力解決を持ち、.mjs 側が起こす側の env に丸投げしていたのが
- * 上記 403 の構造的な原因だった。readFile は試験のための注入口で、既定は実ファイルを読む。
+ * launch-seat.sh:25-27 と同じ解決規則で書込トークンを決める（直接env → 席別credential → 設定file）。
+ * 規則を二重に書かない——常駐bridgeは起こし側のshell envを継承しないため、席別credentialのpathを
+ * 明示的に渡す。readFileは試験のための注入口で、既定は実ファイルを読む。
  */
 export function resolvePostToken(env, readFile = path => { try { return readFileSync(path, 'utf8') } catch { return null } }) {
   if (env.PEERTABLE_POST_TOKEN) return env.PEERTABLE_POST_TOKEN
+  if (env.PEERTABLE_CREDENTIAL_FILE) {
+    const token = readFile(env.PEERTABLE_CREDENTIAL_FILE)
+    return typeof token === 'string' ? token.trim() : ''
+  }
   return parsePostTokenEnvFile(readFile(join(env.HOME || homedir(), '.config', 'peertable.env'))) ?? ''
 }
 
@@ -153,6 +157,43 @@ export function classifyPaneTail(tail) {
   return 'idle'
 }
 
+/**
+ * pane 内で実行中の CLI プロセスの pid（`#{pane_pid}`）を読む。tmux pane 自体は生きたまま
+ * （`pane_dead=0`）、中の CLI プロセスだけが停止する局面があるため、pane の生死とは別に
+ * このプロセス自身の状態を見る必要がある。
+ */
+export function tmuxPanePid(socket, target, exec = execFileSync) {
+  try {
+    const out = exec('tmux', ['-S', socket, 'list-panes', '-t', target, '-F', '#{pane_pid}'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+    const pid = out.trim().split('\n')[0]
+    return pid && /^[0-9]+$/.test(pid) ? pid : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * pane プロセス（またはその直接の子）が stopped（`ps` stat の先頭が `T`）かどうかを見る。
+ * 実測（2026-08-11, bell/suzune）: Lattice pull run の accept hold は attach 済み worker
+ * （pane の子で pid===pgid のもの）へ SIGSTOP を送る。tmux pane は shell も含めて生きたまま
+ * （`pane_dead=0`）で、末尾の画面は停止直前のまま残るため、`classifyPaneTail` だけでは
+ * `idle` と誤判定する。
+ */
+export function isPaneProcessStopped(panePid, exec = execFileSync) {
+  if (!panePid) return false
+  try {
+    const out = exec('ps', ['-o', 'pid=,ppid=,stat=', '-A'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+    return out.split('\n').some((line) => {
+      const match = /^\s*(\d+)\s+(\d+)\s+(\S+)/u.exec(line)
+      if (!match) return false
+      const [, pid, ppid, stat] = match
+      return (pid === String(panePid) || ppid === String(panePid)) && stat.startsWith('T')
+    })
+  } catch {
+    return false
+  }
+}
+
 /**
  * paneのstatus行が公開しているtoken値だけを読む。
  * vendor固有のログや課金単価は推測せず、表示が無い席はnullのままにする。

package/skill/scripts/setup.sh

@@ -51,6 +51,34 @@ else
   mode=lattice
 fi
 
+# `.team/` は setup が所有する使い捨ての生成領域だが、既存 project の資産を
+# その名前だけで所有物だと決めてはいけない。追跡済み file は project の意図した資産、
+# 未追跡の残りは前卓の残骸か利用者の資産かを setup だけでは判定できない。
+# どちらも write 前に typed conflict として止め、退避・削除・上書きはしない。
+team_dir="$proj/.team"
+team_existing=""
+if [ -L "$team_dir" ] || { [ -e "$team_dir" ] && [ ! -d "$team_dir" ]; }; then
+  team_existing="$team_dir"
+elif [ -d "$team_dir" ]; then
+  team_existing=$(find "$team_dir" -mindepth 1 -print | sort)
+fi
+team_tracked=""
+if git -C "$proj" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  team_tracked=$(git -C "$proj" ls-files --cached -- .team)
+fi
+if [ -n "$team_existing" ] || [ -n "$team_tracked" ]; then
+  echo "PEERTABLE_SETUP_TEAM_CONFLICT: .team/ に既存資産があるため、setup は書き込まない" >&2
+  if [ -n "$team_tracked" ]; then
+    echo "  tracked（project所有として扱い、上書きしない）:" >&2
+    printf '    %s\n' "$team_tracked" >&2
+  fi
+  if [ -n "$team_existing" ]; then
+    echo "  existing（前卓の残骸か利用者資産かを推測せず、触らない）:" >&2
+    printf '    %s\n' "$team_existing" >&2
+  fi
+  exit 1
+fi
+
 # Lattice 併用モードは、公開CLIをprojectへ何か置く前に確定する。通常はglobal installされた
 # lattice を使い、release前のsource treeを実測する時だけ `LATTICE_CLI` で同じtreeのbinを明示する。
 # **work-order adapter binary はもう要らない**（配車を撤去したので登録しない）。ここで見るのは
@@ -74,13 +102,13 @@ if [ "$mode" = "lattice" ]; then
   }
 fi
 
-mkdir -p "$tdir/roles"
+mkdir -p "$tdir/roles" "$tdir/scripts"
 cp "$tpl/charter.md" "$tdir/CLAUDE.md"
+cp "$tpl/parent.md" "$tdir/roles/parent.md"
 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"
   # claim 範囲は席へ渡す文書に焼き込む。範囲の出典を「誰かの記憶」でなく role 文書にする
   if [ ${#phases[@]} -eq 0 ]; then
     scope="この卓の claim 範囲は plan 全体（phase 指定なしで立っている）。"
@@ -90,7 +118,6 @@ else
   sed -e "s|{{PLAN_KEY}}|$plan|g" -e "s|{{CLAIM_SCOPE}}|$scope|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