peertable 0.3.8 → 0.3.10

package/skill/scripts/wakeup-bridge.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-// Codex 席の起床ブリッジ。room の SSE を購読し、明示的にその席宛の新着が来たら
-// tmux の席へ素送信して起こす。Claude 席は channels が同じ役をするので対象外。
+// room のSSEを購読し、明示宛先の新着を current member descriptor の通常席へ
+// 素送信して起こす。親セッションは parent-watch が所有し、このbridgeでは扱わない。
 //
-// usage: wakeup-bridge.mjs <project_dir> <seat> [seat...]     起動（前面。nohup で常駐させる）
+// usage: wakeup-bridge.mjs <project_dir> [legacy-seat...]     起動（前面。nohup で常駐させる）
 //        wakeup-bridge.mjs <project_dir> --stop               停止
 //
 // 生死の作法は Lattice ADR 0157 に倣う: 自分の pid を記録に置き、起動時に前の記録を掃除し、
@@ -15,21 +15,52 @@ import { execFile } from 'node:child_process'
 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'
+import { resolveSeatObservation } from './seat-usage.mjs'
 
 const run = promisify(execFile)
 const [proj, ...rest] = process.argv.slice(2)
-if (!proj || rest.length === 0) {
+if (!proj) {
   console.error('usage: wakeup-bridge.mjs <project_dir> <seat> [seat...] | <project_dir> --stop')
   process.exit(1)
 }
 
 const record = join(proj, '.team', 'wakeup-bridge.json')
-const socketResult = resolveTmuxSocket(process.env)
-const sock = socketResult.socket
+const deliveryStatePath = join(proj, '.team', 'wakeup-bridge-delivery.json')
+const startupLock = `${record}.lock`
 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}`)
+let lockHeld = false
+const releaseStartupLock = () => {
+  if (!lockHeld) return
+  try { if (existsSync(startupLock)) unlinkSync(startupLock) } catch {}
+  lockHeld = false
+}
+process.on('exit', releaseStartupLock)
+
+async function acquireStartupLock() {
+  const deadline = Date.now() + 10_000
+  for (;;) {
+    try {
+      writeFileSync(startupLock, `${process.pid}\n`, { flag: 'wx', mode: 0o600 })
+      lockHeld = true
+      return
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error
+      let owner = null
+      try { owner = Number(readFileSync(startupLock, 'utf8').trim()) } catch {}
+      if (owner !== null && Number.isInteger(owner) && !alive(owner)) {
+        try { unlinkSync(startupLock) } catch {}
+        continue
+      }
+      if (Date.now() >= deadline) {
+        console.error(`WAKEUP_BRIDGE_START_LOCKED: 起動処理中のbridge（pid ${owner ?? '不明'}）がlockを保持している`)
+        process.exit(1)
+      }
+      await sleep(200)
+    }
+  }
+}
 
 async function stopRecorded() {
   if (!existsSync(record)) return
@@ -49,37 +80,62 @@ async function stopRecorded() {
   log(`前のブリッジを停止した（pid ${pid}）`)
 }
 
+await acquireStartupLock()
 await stopRecorded()
 if (rest[0] === '--stop') process.exit(0)
 
-const seats = rest
+// 起動引数は supervisor の後方互換として記録するだけで、配送対象の正本にはしない。
+// 宛先は常に room の現在 member name から descriptor を解決する。
+const requestedSeats = rest
 const state = JSON.parse(readFileSync(join(proj, '.team', 'setup-state.json'), 'utf8'))
 const { room, server_url: url } = state
 writeFileSync(record, JSON.stringify({
-  pid: process.pid, room, server_url: url, seats, started_at: new Date().toISOString(),
+  pid: process.pid, room, server_url: url, requested_seats: requestedSeats, started_at: new Date().toISOString(),
 }) + '\n')
+releaseStartupLock()
 
 const cleanup = () => { if (existsSync(record)) unlinkSync(record); process.exit(0) }
 process.on('SIGTERM', cleanup)
 process.on('SIGINT', cleanup)
 
-// 席ごとに未配達を溜めて、2秒ごとにまとめて1回起こす（連投で席を何度も起こさない）
-const pending = new Map(seats.map(s => [s, []]))
+// 席ごとに未配達を溜めて、2秒ごとにまとめて1回起こす（連投で席を何度も起こさない）。
+// pending は room message の宛先名から作る。起動引数や vendor は候補集合を決めない。
+const pending = new Map() // name -> Map<seq, message>
+const deliveryStates = new Map() // seq -> { message, targets, delivered }
+let seats = []
 let members = new Map()
+let membersObserved = false
+function reconcileSeats() {
+  const next = new Set()
+  if (membersObserved) {
+    for (const member of members.values()) {
+      if (typeof member.name !== 'string' || member.name.length === 0) continue
+      if (member.delivery?.kind === 'parent_watch') continue
+      next.add(member.name)
+      if (!pending.has(member.name)) pending.set(member.name, new Map())
+    }
+  }
+  const previous = seats.join(',')
+  seats = [...next]
+  if (previous !== seats.join(',')) log(`監視席を更新: ${seats.join(',') || 'なし'}`)
+}
 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()
+    if (!Array.isArray(body.members)) throw new Error('members response is not an array')
     members = new Map(body.members.map(member => [member.name, member]))
+    membersObserved = true
+    reconcileSeats()
     return true
   } catch (error) {
-    // 記述子の更新が読めないことは起床停止の理由にしない。直前の map を保ち、
-    // 未登録席は wake() の legacy target へ戻す。縮退を必ずログに残す。
-    log(`member 記述子を更新できないので直前の観測先で続ける: ${error.message}`)
+    // 直前の member map は保持するが、起動引数や既定 socketへ縮退しない。
+    log(`member 記述子を更新できないので直前の観測を保持する: ${error.message}`)
     return false
   }
 }
+reconcileSeats()
 await refreshMembers()
 function markReady() {
   const next = { ...JSON.parse(readFileSync(record, 'utf8')), ready_at: new Date().toISOString() }
@@ -88,58 +144,189 @@ function markReady() {
   renameSync(temp, record)
 }
 
-async function wake(seat, msgs) {
-  const last = msgs[msgs.length - 1]
-  const audience = Array.isArray(last.to_names) ? last.to_names.join(', ') : last.to
-  const text = msgs.length === 1
-    ? `room に新着あり（${last.from} → ${audience}）。read_unread で読むこと。`
-    : `room に新着 ${msgs.length} 件（最新: ${last.from} → ${audience}）。read_unread で読むこと。`
+function loadDeliveryState() {
   try {
-    // 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', observation.socket, 'send-keys', '-t', observation.target, 'Enter'])
-    log(`起こした: ${seat} ← ${msgs.length} 件（最新 seq ${last.seq}）`)
-  } catch (error) {
-    // 席が畳まれていれば tmux が落ちる。黙って飲まず、毎回出す（何件落としたかも出す）
-    log(`起こせなかった: ${seat} ← ${msgs.length} 件（最新 seq ${last.seq}）: ${error.message.split('\n')[0]}`)
+    const saved = JSON.parse(readFileSync(deliveryStatePath, 'utf8'))
+    if (saved.room !== room || saved.server_url !== url) return { primed: false, lastSeq: 0, delivered: new Set() }
+    return {
+      primed: saved.primed === true,
+      lastSeq: Number.isSafeInteger(saved.last_seq) && saved.last_seq >= 0 ? saved.last_seq : 0,
+      delivered: new Set(Array.isArray(saved.delivered) ? saved.delivered.filter(key => typeof key === 'string') : []),
+    }
+  } catch {
+    return { primed: false, lastSeq: 0, delivered: new Set() }
   }
 }
 
-setInterval(async () => {
-  for (const [seat, msgs] of pending) {
-    if (msgs.length === 0) continue
-    pending.set(seat, [])
-    await wake(seat, msgs)
+const deliveryState = loadDeliveryState()
+let lastSeq = deliveryState.lastSeq
+const delivered = deliveryState.delivered
+let primed = deliveryState.primed
+function saveDeliveryState() {
+  const temp = `${deliveryStatePath}.${process.pid}.tmp`
+  writeFileSync(temp, JSON.stringify({
+    room,
+    server_url: url,
+    primed,
+    last_seq: lastSeq,
+    delivered: [...delivered].slice(-10_000),
+  }) + '\n')
+  renameSync(temp, deliveryStatePath)
+}
+
+function deliveryKey(seq, seat) {
+  return `${seq}:${seat}`
+}
+
+const BROADCAST_RECIPIENT = 'all'
+function recipientNames(msg) {
+  if (Array.isArray(msg.to_names)) {
+    if (msg.to_names.includes(BROADCAST_RECIPIENT)) return []
+    return [...new Set(msg.to_names.filter(name => typeof name === 'string' && name.length > 0))]
   }
-}, 2000)
+  if (msg.to === BROADCAST_RECIPIENT) return [...members.keys()].filter(name => name !== msg.from)
+  if (typeof msg.to === 'string' && msg.to.length > 0 && msg.to !== BROADCAST_RECIPIENT) return [msg.to]
+  return []
+}
+
+function advanceLastSeq() {
+  let advanced = false
+  for (;;) {
+    const state = deliveryStates.get(lastSeq + 1)
+    if (!state) break
+    if (![...state.targets].every(seat => state.delivered.has(seat))) break
+    deliveryStates.delete(lastSeq + 1)
+    lastSeq += 1
+    advanced = true
+  }
+  if (advanced) saveDeliveryState()
+}
+
+async function wake(seat, msgs) {
+  const last = msgs[msgs.length - 1]
+  const text = msgs.map(msg => {
+    const audience = Array.isArray(msg.to_names) ? msg.to_names.join(', ') : msg.to
+    if (msg.to === BROADCAST_RECIPIENT) {
+      return `[Peertable #${msg.seq}] room全体の状況が更新された。room.read_logで部屋を読み、状況を把握して次の行動を判断する。`
+    }
+    const body = String(msg.body).replace(/\s*\n+\s*/gu, ' / ')
+    return `[Peertable DM #${msg.seq}] ${msg.from} → ${audience}: ${body}`
+  }).join(' || ')
+  // 配送直前に member ledger を取り直し、current name -> descriptor の一経路だけを使う。
+  await refreshMembers()
+  const member = members.get(seat)
+  const delivery = member?.delivery
+  const observation = resolveSeatObservation(member, null)
+  if (observation === null) {
+    const code = members.has(seat) ? 'DESCRIPTOR_MISSING' : 'MEMBER_MISSING'
+    const error = new Error(`${code}: ${seat}`)
+    error.code = code
+    throw error
+  }
+  // Codexの入力欄は本文とEnterを同じtmux commandで送ると、初回turn完了後に
+  // 本文が入力欄へ残ることがある。再試行時の半入力も含め、正規のsubmitを分離する。
+  // 最後のEnterまで成功しない限りwakeは成功扱いにせず、flushSeatのreceiptも確定しない。
+  await run('tmux', ['-S', observation.socket, 'send-keys', '-t', observation.target, 'C-u'])
+  await sleep(100)
+  await run('tmux', ['-S', observation.socket, 'send-keys', '-l', '-t', observation.target, text])
+  await sleep(750)
+  await run('tmux', ['-S', observation.socket, 'send-keys', '-t', observation.target, 'Enter'])
+  log(`起こした: ${seat} ← ${msgs.length} 件（最新 seq ${last.seq}）`)
+}
 
 function dispatch(msg) {
-  for (const seat of seats) {
-    if (msg.from === seat) continue
-    if (Array.isArray(msg.to_names) ? !msg.to_names.includes(seat) : msg.to !== seat) continue
-    pending.get(seat).push(msg)
+  if (deliveryStates.has(msg.seq)) return
+  const targets = recipientNames(msg).filter(seat => members.has(seat)
+    && members.get(seat)?.delivery?.kind !== 'parent_watch')
+  const state = { message: msg, targets: new Set(targets), delivered: new Set() }
+  for (const seat of targets) {
+    if (delivered.has(deliveryKey(msg.seq, seat))) state.delivered.add(seat)
   }
+  deliveryStates.set(msg.seq, state)
+  for (const seat of targets) {
+    if (state.delivered.has(seat)) continue
+    if (!pending.has(seat)) pending.set(seat, new Map())
+    pending.get(seat).set(msg.seq, msg)
+  }
+  advanceLastSeq()
 }
 
-// 再接続で取りこぼさないために、配達済みの最大 seq を持つ。
-// SSE は切れている間の発言を後から届けてくれないので、繋ぎ直したら必ず穴を埋める。
-let lastSeq = 0
-function dispatchNew(msg) {
-  // seq の無いイベントで lastSeq を汚さない。`undefined <= 数値` は false なので、
-  // 素通しにすると lastSeq が undefined に化け、以後の比較が全部 false になって
-  // 「取りこぼし回収が毎回 since=undefined で 0 件」という静かな故障になる（実測で踏んだ）
-  if (typeof msg.seq !== 'number') {
-    log(`seq を持たないイベントを捨てた: ${JSON.stringify(msg).slice(0, 120)}`)
-    return
+const flushing = new Set()
+async function flushSeat(seat) {
+  if (flushing.has(seat)) return
+  const queue = pending.get(seat)
+  if (!queue || queue.size === 0) return
+  flushing.add(seat)
+  const msgs = [...queue.values()].sort((a, b) => a.seq - b.seq)
+  try {
+    await wake(seat, msgs)
+    const receipts = []
+    for (const msg of msgs) {
+      if (queue.get(msg.seq) !== msg) continue
+      const state = deliveryStates.get(msg.seq)
+      if (!state) continue
+      state.delivered.add(seat)
+      delivered.add(deliveryKey(msg.seq, seat))
+      receipts.push({ msg, state })
+    }
+    // lastSeq が先行seqの別宛先失敗で止まっても、今回成功した宛先のreceiptは失わない。
+    // durable receiptを先に確定してからpendingを消すので、再起動後に成功席へ重複wakeしない。
+    if (receipts.length > 0) {
+      try {
+        saveDeliveryState()
+      } catch (error) {
+        for (const { msg, state } of receipts) {
+          state.delivered.delete(seat)
+          delivered.delete(deliveryKey(msg.seq, seat))
+        }
+        throw error
+      }
+      for (const { msg } of receipts) queue.delete(msg.seq)
+    }
+    advanceLastSeq()
+  } catch (error) {
+    // 失敗時はpendingもreceiptもcursorも動かさない。次のmember refreshで
+    // descriptor/PTYが復旧した時、同じseqを同じ宛先へ一度だけ再試行する。
+    log(`WAKEUP_BRIDGE_DELIVERY_FAILURE ${JSON.stringify({
+      recipient: seat,
+      code: typeof error.code === 'string' ? error.code : 'INJECTION_FAILED',
+      seqs: msgs.map(msg => msg.seq),
+      detail: error.message.split('\n')[0],
+    })}`)
+  } finally {
+    flushing.delete(seat)
+  }
+}
+
+setInterval(() => {
+  for (const [seat, queue] of pending) {
+    if (queue.size > 0) flushSeat(seat).catch(error => log(`WAKEUP_BRIDGE_FLUSH_FAILED: ${error.message}`))
   }
-  if (msg.seq <= lastSeq) return
-  lastSeq = msg.seq
-  dispatch(msg)
+}, 2000)
+
+// 再接続で取りこぼさないために、全宛先の成功が揃った最大 seq を持つ。
+// 失敗した宛先がある限り lastSeq は前進せず、GET since から同じseqを回収する。
+let dispatchQueue = Promise.resolve()
+function dispatchNew(msg) {
+  // 心拍由来のcatch-upとSSE本文は同時に到着しうる。refreshMembers() の await より
+  // 前でseqを判定すると、同じmsgが両方の経路から二重に積まれ、lastSeqも逆行する。
+  // 判定・members同期・カーソル更新・dispatchを一本の順序へ直列化する。
+  const queued = dispatchQueue.then(async () => {
+    // seq の無いイベントで lastSeq を汚さない。`undefined <= 数値` は false なので、
+    // 素通しにすると lastSeq が undefined に化け、取りこぼし回収が静かに壊れる。
+    if (typeof msg.seq !== 'number') {
+      log(`seq を持たないイベントを捨てた: ${JSON.stringify(msg).slice(0, 120)}`)
+      return
+    }
+    if (msg.seq <= lastSeq) return
+    // SSEのmessageだけでは席追加と競合する。DMを積む直前にmembersを取り直し、
+    // 配送時にはさらにdescriptorを解決する。refresh失敗でも静的席へ縮退しない。
+    await refreshMembers()
+    if (msg.seq <= lastSeq || deliveryStates.has(msg.seq)) return
+    dispatch(msg)
+  })
+  dispatchQueue = queued.catch(() => {})
+  return queued
 }
 
 // 繋がったまま黙って死ぬ接続を検出する。SSE は無音でも生きていられるので、
@@ -150,7 +337,6 @@ const IDLE_MS = 75_000
 
 // 起動直後の1回だけは配達しない。既に流れ終わった過去ログで席を起こしても意味がなく、
 // 卓が長いほど巨大な起床通知になる。初回は「ここまでは読んだこと」にして頭出しするだけ。
-let primed = false
 let catching = false
 async function catchUp(reason) {
   // 再接続直後と心拍由来の回収が重なると二重に取りにいく。取りこぼし回収は1本だけ走らせる
@@ -163,11 +349,12 @@ async function catchUp(reason) {
     if (!primed) {
       primed = true
       if (messages.length > 0) lastSeq = messages[messages.length - 1].seq
+      saveDeliveryState()
       log(`頭出し: seq ${lastSeq} まで既読として開始する`)
       return
     }
     log(`取りこぼし確認（${reason}・since ${lastSeq}）: ${messages.length} 件`)
-    for (const msg of messages) dispatchNew(msg)
+    for (const msg of messages) await dispatchNew(msg)
   } finally {
     catching = false
   }
@@ -218,7 +405,7 @@ for (;;) {
           const line = lines.find(l => l.startsWith('data: '))
           if (name === 'ping') { if (line) onHeartbeat(line.slice(6)); continue }
           if (name !== undefined && name !== 'message') continue
-          if (line) dispatchNew(JSON.parse(line.slice(6)))
+          if (line) await dispatchNew(JSON.parse(line.slice(6)))
         }
       }
       log('SSE 切断（再接続する）')

package/skill/templates/charter.md

@@ -2,13 +2,19 @@
 
 これはチーム作業である。自分が引き受けたタスクの完了はミッションの完了ではない。全タスク完了までチームは解散しない。
 
-1. 拘束力を持つのは**工程正本への記録**と room ログに残った決定だけ（工程正本＝Lattice 併用モードなら Lattice の todo 記録、単独円卓モードなら room の宣言そのもの）。宛先は影響を受けるメンバーだけを明示する。room ログは全員がpullで読めるので、broadcastによる周知を決定の成立条件にしない
-2. 進捗は room に一行で報告する: claim・join、完了時・詰まり自覚時・方針変更時。task 外でも成果物になる作業（実測・検証・CI）は着手前に一言。仲間を五里霧中に置かない
-3. **仕事を選ぶのも始めるのも自分である。** どのモードでも、`read_log`で先行claimを確認してからroomへ`[claim] <タスク>`を記録する。起こす必要のある相手だけを宛先へ入れ、記録だけなら自分宛でよい。**装置から仕事が降ってくることはないし、着手前に装置の許可を待つこともない**（オーナー裁定 2026-08-09）。Lattice の実行層を使う卓では、`todo start` の後に自分で `run intake` して隔離 worktree を受け取る——それは設備の供給であって許可証ではなく、装置が返すのは競合した時の「留まれ」だけである（タスクの呼び名は Lattice 併用モードなら task_id、単独円卓モードなら `.team/tasks.md` の議題名）。同じタスクへの先行 claim があれば取り下げるか `[join] <タスク>` へ切り替える
+1. 拘束力を持つのは**工程正本への記録**と room ログに残った決定だけ（工程正本＝Lattice 併用モードなら Lattice の todo 記録、単独円卓モードなら room の宣言そのもの）。room の `to: "all"` は部屋全体への通常発言、名前指定はDMである
+2. room の宛先規則はこれだけである。claim は `post(to: "all")`、ターン終了時の次の行動は `post(to: "<自分の名前>")`、工程完了は `post(to: "all")`、誰かへの用事は `post(to: "<相手の名前>")` で送る。誰に聞けばよいか分からないことは `post(to: "all")` で聞く。実装・監査・readyが本当に無い時の待機宣言は最終手段として親だけへDMし、`all`へ送らない。別の通知機構は使わない
+3. **仕事を選ぶのも始めるのも自分である。** どのモードでも、`read_log`で先行claimを確認してから `post(to: "all", message: "[claim] <タスク>")` を送る。これが唯一の着手通知であり、別の着手通知は送らない。**装置から仕事が降ってくることはないし、着手前に装置の許可を待つこともない**（オーナー裁定 2026-08-09）。Lattice の実行層を使う卓では、その後 `todo start` し、自分で `run intake` して隔離 worktree を受け取る——それは設備の供給であって許可証ではなく、装置が返すのは競合した時の「留まれ」だけである（タスクの呼び名は Lattice 併用モードなら task_id、単独円卓モードなら `.team/tasks.md` の議題名）。同じタスクへの先行 claim があれば取り下げるか `[join] <タスク>` へ切り替える
 4. 分からないことは room で聞く。台帳はない。自分の変更が他の部位に影響するなら、聞かれる前に影響を受けるメンバーを明示宛先にして通知する
-5. 判断は情報を持つ者がする。タスクは席ではなく現場。合流（join）は歓迎される。詰まった仲間には目を貸す。手が足りないだけなら自分のサブエージェントを使う（room 報告不要）。視点が足りない・詰んでいるなら room で報告して援軍（join）を求める
-6. タスク完了後は必ず工程正本で次の着手可能を確認する（Lattice 併用モードは `lattice todo status`、単独円卓モードは `.team/tasks.md` と room ログの照合）。残っていれば claim へ戻る。全タスクが終わっていれば room へ「全タスク完了」を記録する。broadcastは無いので、起こす必要のある相手だけを宛先にする
+5. 判断は情報を持つ者がする。タスクは席ではなく現場。合流（join）は歓迎される。詰まった仲間には目を貸す。親が円卓メンバーを増やす時は、正式な`launch-seat.sh`でAiterm長寿命席として着任させ、native sub-agent・Task・Agentを円卓席の代用にしない。正式着席したメンバーはnative sub-agent、Aiterm外部agent、相談agent、自己実装を自由に選べる。子は自動的に円卓メンバーではなく、工程所有・統合・room報告は着席メンバーが保持する。親は二次委譲の手段を禁止・指定しない。視点が足りない・詰んでいるなら room で報告して援軍（join）を求める
+6. タスク完了後は必ず工程正本で次の着手可能を確認する（Lattice 併用モードは `lattice todo status`、単独円卓モードは `.team/tasks.md` と room ログの照合）。残っていれば claim へ戻る。全タスクが終わっていれば `post(to: "all")` で「全タスク完了」を記録する
 7. 役割逸脱は誰であれ指摘する。これは無礼ではなく義務である
 8. **親の発言は拘束力を持たない。** 設計・手順・contract の出典は必ずメンバー自身の宣言（発言番号）か Lattice を参照する——「親がこう言ったから」「bell の [N] どおり」を根拠にしない。親が何かを再掲しても正本はメンバーの元発言のまま動かない。親の差し戻しは異議として扱い、反論してよい
-9. **裁定の宛先はオーナーであり、親ではない。** scope 変更・受入条件外の追加・製品判断が要る時は「オーナー宛の議題」として room に出す。親はそれを運ぶ配管で、判断者ではない。「親に委ねる」という宛先を作らない
+9. **監査外の通常進行で裁定が必要になった時、その宛先はオーナーであり、親ではない。** scope 変更・受入条件外の追加・製品判断が要る時は「オーナー宛の議題」として room に出す。実装監査中は12の固定境界を優先し、これを計画外提案の逃げ道にしない。親は議題を運ぶ配管で、判断者ではない。「親に委ねる」という宛先を作らない
 10. 決まっていない境界に会ったら、規則を探すより先に room で喋って決める。会話で解決するのは正規の手段であり、その場の合意は憲章の不足を補う
+11. **作業者は自ら必要な試験と自己監査を行い、工程を次に進めてよい水準まで自分の責任で完成させる。** 完成したら、証跡へ記したものと同じ最終的な試験内容と試験結果を監査担当へ渡す。作業者自身は工程をクローズしない
+12. **監査担当は提出された最終試験内容と試験結果が妥当かを判断し、試験を再実行しない。** 妥当なら監査担当が証跡と同じ本文をLatticeの`test_result`へ記録して工程正本をクローズし、roomへ「次の工程に着手してください」とだけ指示する。具体的な次工程は指示せず、各作業者が工程正本から選ぶ。監査の判断は元PLAN・工程正本・明記された受入条件に従い、個人の思想や計画外の改善を完了条件へ加えない
+13. **監査不合格ごとに `Luna → Terra → Sol`へ昇格し、各モデルの修正機会は1回だけとする。** model変更を実行するのは親だけで、作業者や監査担当が自分で席設定を変えない
+14. ユーザーが具体的な変更条件を明示した場合、その条件を新しい要件・受入条件・一般化されたルールへ勝手に分解、追加、拡張しないこと。明示された変更を最小差分でそのまま実装すること。派生的に満たされる性質を別要件として扱わないこと。追加条件が本当に必要な場合のみ、その理由を示して提案すること。提案を実装条件へ勝手に昇格させないこと。
+15. **通し試験は完成確認にだけ使い、原因調査には使わない。** 通し試験が失敗したら、担当者は失敗した機能を切り分け、focused testで原因を確定して修正し、最後に通し試験を確認する
+16. **後続工程へ着手した後に先行工程由来の不具合が判明しても、先行工程をreopenせず、前担当者へ戻さず、修正工程も追加しない。** 現在の工程担当者が、現在の工程を成立させる修正として自ら直し、必要なfocused testと自己監査を行い、最終試験結果へ「発見した不具合を含めて修正した」と記す