monster-orchestrator 3.5.0 → 3.7.7

package/scripts/monster-deathcheck

@@ -40,7 +40,8 @@ exit code:
   MONSTER_ROOT      monster レジストリの場所（既定 ~/.claude/monsters）
   TMUX_BIN          tmux の絶対パス（既定は PATH → /opt/homebrew/bin/tmux の順に探索）
                     ⚠️ 非対話 SSH では PATH に /opt/homebrew/bin が乗らないため必要
-  CLAUDE_PROJECTS_ROOT  transcript の場所（既定 ~/.claude/projects）
+  CLAUDE_PROJECTS_ROOT  transcript の場所（既定 ~/.claude/projects）。足跡が無い席（移行前）だけ読む
+  BLUELAMP_FOOTPRINTS_ROOT  足跡の場所（既定 ~/.bluelamp/footprints・箱 n=2475 §足跡の形 v1）
 """
 
 import glob
@@ -247,11 +248,11 @@ def find_ghosts(monsters, tmux):
         # 🚨 GHOST と STALLED は同時に成立しうる（実測: 23b47504）。
         #    片方が他方を隠さないよう、ghost 側にも API 状態を載せる。
         gid = next((k for k in monsters if k.startswith(short)), None) or short
-        readable, is_err, status = read_last_api_state(gid)
+        readable, stalled, _cause = read_api_verdict(gid)
         out.append({
             "session": sess,
             "short_id": short,
-            "stalled": classify_api_error(is_err, status) if readable else None,
+            "stalled": stalled if readable else None,
             "stalled_unverified": not readable,
             "spawned_at": spawned.get(sess, ""),
             "detail": ("tmux にセッションが在るが state.json にエントリが無い。"
@@ -330,6 +331,109 @@ def read_last_api_state(monster_id):
     return (False, None, None)
 
 
+# ---------------------------------------------------------------------------
+# 足跡（箱 n=2475 §足跡の形 v1）— 席は会話の記録を書かない（CLAUDE_CODE_SKIP_PROMPT_HISTORY=1）。
+#   起動子のフックが本文なしの 1 行を ~/.bluelamp/footprints/<cwd のスラグ>/<sid>.jsonl に足す:
+#     {"v":1,"ts":…,"sid":…,"cwd":…,"ev":"api_error","err":"rate_limit"} 等
+#   transcript 版と同じ問い（最後の応答は API エラーか）を、本文を持たない足跡で答える:
+#     最後の ev=api_error の後に、席が応答した印（FOOTPRINT_RESPONDED）が 1 つも無ければ止まっている。
+#   🔑 prompt は応答の印に数えない（transcript 版も user 行の後に assistant 行が来るまで最後のエラーを見続ける）。
+#   ⚠️ 足跡が在る席は足跡だけを読む。足跡が無い席（移行前）だけ transcript を読む。
+# ---------------------------------------------------------------------------
+
+FOOTPRINTS_ROOT = os.environ.get("BLUELAMP_FOOTPRINTS_ROOT") or os.path.expanduser("~/.bluelamp/footprints")
+
+FOOTPRINT_TAIL_LINES = 200
+
+# api_error の後に来たら「席が応答した」印になる足跡の種別
+FOOTPRINT_RESPONDED = {"tool", "tool_fail", "stop", "session_start"}
+
+
+def footprint_dir(monster_id):
+    """monster の足跡のディレクトリ。無ければ None（＝移行前の席）。"""
+    hits = [d for d in glob.glob(os.path.join(FOOTPRINTS_ROOT, f"*monsters-{monster_id}*")) if os.path.isdir(d)]
+    return hits[0] if hits else None
+
+
+def last_footprint_error(lines):
+    """足跡の行列から、止めている api_error の err を返す純関数（--verify で単体検証する）。
+
+    返り値: None＝止まっていない／文字列＝最後の api_error の err（その後に応答の印が無い）
+    v が 1 でない行・壊れた行は読まない。
+    """
+    last_err = None
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            e = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(e, dict) or e.get("v") != 1:
+            continue
+        ev = e.get("ev")
+        if ev == "api_error":
+            err = e.get("err")
+            last_err = err if isinstance(err, str) and err else "unknown"
+        elif ev in FOOTPRINT_RESPONDED:
+            last_err = None
+    return last_err
+
+
+def read_last_footprint_state(monster_id):
+    """足跡から API 状態を返す。
+
+    返り値: None＝足跡が無い（ディレクトリが無い／1 本も無い＝移行前の席・transcript へ。
+      orchestrator の footprint.ts readSeatFootprintTail と同じ線引き）／(readable, err)
+      readable=False は「足跡のファイルは在るが読めない」。⚠️ 正常に丸めない。
+    """
+    d = footprint_dir(monster_id)
+    if d is None:
+        return None
+    files = glob.glob(os.path.join(d, "*.jsonl"))
+    if not files:
+        return None
+    try:
+        with open(max(files, key=os.path.getmtime), errors="replace") as f:
+            lines = f.readlines()[-FOOTPRINT_TAIL_LINES:]
+    except OSError:
+        return (False, None)
+    return (True, last_footprint_error(lines))
+
+
+def classify_footprint_error(err):
+    """足跡の err から判定名を返す純関数（--verify で単体検証する）。
+
+    transcript 版（classify_api_error）と同じ 3 つに畳む:
+      rate_limit（transcript では 429）→ STALLED-RATE-LIMIT
+      server_error・overloaded（transcript では 5xx・529 Overloaded）→ STALLED-BACKEND
+      （err の語は StopFailure の error＝箱 n=2475 の W1 実測・Claude Code 2.1.289 の列挙）
+      それ以外（authentication_failed 等・transcript では status なし）→ STALLED-API-ERROR
+    """
+    if not err:
+        return None
+    if err == "rate_limit":
+        return "STALLED-RATE-LIMIT"
+    if err in ("server_error", "overloaded"):
+        return "STALLED-BACKEND"
+    return "STALLED-API-ERROR"
+
+
+def read_api_verdict(monster_id):
+    """席の API 応答不能の判定。足跡が在れば足跡だけ、無ければ transcript（移行の間）。
+
+    返り値 (readable, verdict, cause)
+      verdict は STALLED-* か None。cause は詳細表示用（"HTTP 429" / "err=rate_limit"）。
+    """
+    fp = read_last_footprint_state(monster_id)
+    if fp is not None:
+        readable, err = fp
+        return (readable, classify_footprint_error(err) if readable else None, f"err={err}")
+    readable, is_err, status = read_last_api_state(monster_id)
+    return (readable, classify_api_error(is_err, status) if readable else None, f"HTTP {status}")
+
+
 def classify_api_error(is_api_error, status):
     """API エラー状態から判定名を返す純関数（--verify で単体検証する）。
 
@@ -345,15 +449,16 @@ def classify_api_error(is_api_error, status):
     return "STALLED-API-ERROR"
 
 
-def stalled_detail(verdict, status):
+def stalled_detail(verdict, cause):
+    """cause は詳細表示用の原因（transcript なら "HTTP 503"・足跡なら "err=server_error"）。"""
     if verdict == "STALLED-RATE-LIMIT":
-        return ("API が上限で応答しない（HTTP 429）。state.json は running・tmux も在席・"
+        return (f"API が上限で応答しない（{cause}）。state.json は running・tmux も在席・"
                 "session.log も更新され続けるが、次の 1 文字も出力できない。"
                 "盤面の稼働数が嘘になるので、配車先として数えないこと")
     if verdict == "STALLED-BACKEND":
-        return (f"API がバックエンド障害で応答しない（HTTP {status}）。"
-                "429 と違い、次の瞬間に回復しうる")
-    return f"API が応答しない（HTTP {status}）"
+        return (f"API がバックエンド障害で応答しない（{cause}）。"
+                "上限と違い、次の瞬間に回復しうる")
+    return f"API が応答しない（{cause}）"
 
 def tail_since_last_prompt(events):
     """最後の user_prompt / spawned 以降のイベント列を切り出す"""
@@ -383,15 +488,14 @@ def classify(mid, rec, events_by_id, tmux):
                     "state.json は running だが tmux セッションが3回とも取れない")
 
         # tmux に居ても API が応答しないことがある。
-        readable, is_err, status = read_last_api_state(mid)
+        readable, stalled, cause = read_api_verdict(mid)
         if not readable:
             # ⚠️ 読めなかったものを ALIVE に丸めない（正常と未確認は別物）
             return ("ALIVE-UNVERIFIED",
                     "tmux セッション在席を実測（3回確認）／"
-                    "⚠️ transcript が読めず、API に応答できるかは未確認")
-        stalled = classify_api_error(is_err, status)
+                    "⚠️ 足跡も transcript も読めず、API に応答できるかは未確認")
         if stalled:
-            return (stalled, stalled_detail(stalled, status))
+            return (stalled, stalled_detail(stalled, cause))
 
         return ("ALIVE", "tmux セッション在席を実測（3回確認）")
 
@@ -555,6 +659,52 @@ def verify_stalled():
     return ok
 
 
+def verify_footprint():
+    """足跡の判定の単体検証と、付け替え前後（transcript／足跡）が同じ判定を返すかの表（箱 n=2475）。
+
+    🚨 偽陽性の方が危険（働いている席を STALLED と誤ると「止めてよい」に見える）。
+    """
+    def fp(ev, **kw):
+        return json.dumps({"v": 1, "ts": "2026-10-04T08:00:00Z", "sid": "s", "cwd": "/x", "ev": ev, **kw})
+
+    # (場面, transcript の (is_api_error, status), 足跡の行列)
+    scenes = [
+        ("rate_limit（上限）", (True, 429), [fp("prompt"), fp("tool", tool="Bash", ok=True), fp("api_error", err="rate_limit")]),
+        ("authentication_failed（失効）", (True, None), [fp("prompt"), fp("api_error", err="authentication_failed")]),
+        ("server_error（バックエンド）", (True, 500), [fp("prompt"), fp("api_error", err="server_error")]),
+        ("overloaded（バックエンド）", (True, 529), [fp("prompt"), fp("api_error", err="overloaded")]),
+        ("billing_error（その他）", (True, 400), [fp("prompt"), fp("api_error", err="billing_error")]),
+        ("正常", (False, None), [fp("prompt"), fp("tool", tool="Bash", ok=True), fp("stop")]),
+        ("上限の後に回復", (False, None), [fp("api_error", err="rate_limit"), fp("prompt"), fp("tool", tool="Bash", ok=True)]),
+        ("上限の後に続きを投げたが未応答", (True, 429), [fp("api_error", err="rate_limit"), fp("prompt")]),
+        ("配下の席の終わり・pane の終わりは応答でない", (True, 429), [fp("api_error", err="rate_limit"), fp("subagent_stop"), fp("session_end")]),
+    ]
+    ok = True
+    seen = set()
+    for label, (is_err, status), lines in scenes:
+        before = classify_api_error(is_err, status)
+        after = classify_footprint_error(last_footprint_error(lines))
+        seen.add(after)
+        good = before == after
+        ok = ok and good
+        print(f"  {'OK ' if good else 'NG '}{label:<28} transcript={before} 足跡={after}")
+    # 壊れた行・v が違う行は読まない
+    for label, lines, want in [
+        ("壊れた行", ["{壊れた", ""], None),
+        ("v が 1 でない", [json.dumps({"v": 2, "ev": "api_error", "err": "rate_limit"})], None),
+        ("空", [], None),
+    ]:
+        got = classify_footprint_error(last_footprint_error(lines))
+        good = got == want
+        ok = ok and good
+        print(f"  {'OK ' if good else 'NG '}{label:<28} → {got}")
+    # 🔬 陽性対照: 表の判定が全部 None に潰れていない
+    good = {"STALLED-RATE-LIMIT", "STALLED-BACKEND", "STALLED-API-ERROR", None} <= seen
+    ok = ok and good
+    print(f"  {'OK ' if good else 'NG '}陽性対照: 場面で判定が変わる → {sorted(str(x) for x in seen)}")
+    return ok
+
+
 def verify():
     """対照実験: 測定器が既知ケースを正しく分類できるか。
 
@@ -565,6 +715,8 @@ def verify():
     ghost_ok = verify_ghost()
     print("\n--- API 応答不能の判定（純粋関数・実データ非依存）---")
     stalled_ok = verify_stalled()
+    print("\n--- 足跡の判定と付け替え前後の一致（純粋関数・実データ非依存・箱 n=2475）---")
+    stalled_ok = verify_footprint() and stalled_ok
     print(f"\n--- 死亡判定（既知ケース・実データ依存）---")
     cases = {
         # short_id: 期待する分類（人手で一次資料まで確認済み・2026-08-04）
@@ -607,7 +759,7 @@ def ghost_as_row(g):
     if g.get("stalled"):
         detail += f"／＋ {g['stalled']}: API が応答しない（2 つの死角に同時該当）"
     elif g.get("stalled_unverified"):
-        detail += "／＋ transcript が読めず、応答可能かは未確認"
+        detail += "／＋ 足跡も transcript も読めず、応答可能かは未確認"
     return {
         "short_id": g["short_id"],
         "spawned_at": g.get("spawned_at") or "(spawn 記録なし)",

package/scripts/tmux-guard.mjs

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+// 席の PreToolUse(Bash) hook（箱 n=2320・n=2311 の直し）。席が艦隊の tmux サーバを消す命令を撃つのを止める。
+//
+// 🔬 なぜ要るか（2026-10-02 17:54 実害）: 席が試験で `TMUX_TMPDIR=… tmux kill-server` を撃ち、
+// **$TMUX が TMUX_TMPDIR より優先されて**艦隊サーバに当たり 13 席が同時に落ちた（2026-09-25 に続き 2 回目）。
+// tmux は -S／-L が無いと $TMUX の socket を、$TMUX も無ければ `${TMUX_TMPDIR:-/tmp}/tmux-<uid>/default` を使う。
+//
+// 止める物: ① 行き先（-S／-L）の無い tmux kill-server（`tmux-gui.sh kill-server` を含む）
+//           ② pkill／killall の tmux
+//           ③ 行き先を明示していても、それが席自身のサーバ（$TMUX の 1 欄目）か既定サーバを指す kill-server
+//           （行き先が変数などで読めないときも止める＝fail-safe。消すのは使い捨てなので字で書ける）
+// 通す物: それ以外の全部（他のサーバを指す kill-server・kill-session 等の他の tmux 命令・tmux を含まない命令）
+//
+// 入出力（Claude Code の PreToolUse 規約）: stdin の JSON（tool_name／tool_input.command／cwd）を読み、
+// 止めるときは exit 2＋stderr に理由。それ以外は exit 0。読めない・壊れた入力も exit 0（fail-open・席を止めない）。
+// ⛔ python にしない（会員の機体に python3 がある保証は無い・node は orchestrator が必ず持つ）。
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const GUIDE =
+  "使い捨ての tmux は `env -u TMUX tmux -S /tmp/<短い名>.sock …` で立て、同じ -S で消せ。手順: {CTOリポ}/05手順/使い捨てのtmuxの立て方.md";
+
+const SHELLS = new Set(["bash", "sh", "zsh", "dash", "ksh"]);
+// tmux の大域オプションのうち引数を取るもの（tmux 3.x: -c shell-command -f file -L socket-name -S socket-path -T features）
+const TMUX_OPTS_WITH_ARG = new Set(["c", "f", "L", "S", "T"]);
+
+/**
+ * シェルの 1 行を「文（単語の列）」に割る。引用（' " \）を解き、; & | && || 改行 ( ) で文を切る。
+ * `$(…)` と `` `…` `` の中身は別の命令として nested に返す（引用 " の中でも実行されるので拾う。' の中は拾わない）。
+ * 閉じていない引用は残りを字として扱う（bash はその行を実行しないので、ここで止める理由は無い）。
+ * @param {string} src
+ * @returns {{ statements: string[][]; nested: string[] }}
+ */
+export function splitShell(src) {
+  /** @type {string[][]} */
+  const statements = [];
+  /** @type {string[]} */
+  const nested = [];
+  /** @type {string[]} */
+  let words = [];
+  let word = "";
+  let inWord = false;
+  const endWord = () => {
+    if (inWord) words.push(word);
+    word = "";
+    inWord = false;
+  };
+  const endStatement = () => {
+    endWord();
+    if (words.length > 0) statements.push(words);
+    words = [];
+  };
+  // `$(` の直後から対応する `)` までを返す（引用と入れ子を数える）
+  const readSubst = (start) => {
+    let depth = 1;
+    let j = start;
+    let q = "";
+    for (; j < src.length; j++) {
+      const c = src[j];
+      if (q === "'") {
+        if (c === "'") q = "";
+      } else if (q === '"') {
+        if (c === "\\") j++;
+        else if (c === '"') q = "";
+      } else if (c === "\\") j++;
+      else if (c === "'" || c === '"') q = c;
+      else if (c === "(") depth++;
+      else if (c === ")" && --depth === 0) break;
+    }
+    return { body: src.slice(start, j), end: j };
+  };
+  const readBacktick = (start) => {
+    let j = start;
+    while (j < src.length && src[j] !== "`") {
+      if (src[j] === "\\") j++;
+      j++;
+    }
+    return { body: src.slice(start, j), end: j };
+  };
+
+  for (let i = 0; i < src.length; i++) {
+    const c = src[i];
+    if (c === "\\") {
+      if (src[i + 1] === "\n") {
+        i++; // 行の継続
+        continue;
+      }
+      word += src[i + 1] ?? "";
+      inWord = true;
+      i++;
+    } else if (c === "'") {
+      const j = src.indexOf("'", i + 1);
+      const end = j === -1 ? src.length : j;
+      word += src.slice(i + 1, end);
+      inWord = true;
+      i = end;
+    } else if (c === '"') {
+      inWord = true;
+      let j = i + 1;
+      for (; j < src.length && src[j] !== '"'; j++) {
+        if (src[j] === "\\" && j + 1 < src.length && '"\\$`\n'.includes(src[j + 1])) {
+          if (src[j + 1] !== "\n") word += src[j + 1];
+          j++;
+        } else if (src[j] === "$" && src[j + 1] === "(") {
+          const s = readSubst(j + 2);
+          nested.push(s.body);
+          word += "$(" + s.body + ")";
+          j = s.end;
+        } else if (src[j] === "`") {
+          const s = readBacktick(j + 1);
+          nested.push(s.body);
+          word += "`" + s.body + "`";
+          j = s.end;
+        } else word += src[j];
+      }
+      i = j;
+    } else if (c === "$" && src[i + 1] === "(") {
+      const s = readSubst(i + 2);
+      nested.push(s.body);
+      word += "$(" + s.body + ")";
+      inWord = true;
+      i = s.end;
+    } else if (c === "`") {
+      const s = readBacktick(i + 1);
+      nested.push(s.body);
+      word += "`" + s.body + "`";
+      inWord = true;
+      i = s.end;
+    } else if (c === ";" || c === "&" || c === "|" || c === "\n" || c === "(" || c === ")") {
+      endStatement();
+    } else if (c === " " || c === "\t") {
+      endWord();
+    } else if (c === "#" && !inWord) {
+      // 単語の頭の # から行末まではコメント
+      const j = src.indexOf("\n", i);
+      i = j === -1 ? src.length : j - 1;
+    } else {
+      word += c;
+      inWord = true;
+    }
+  }
+  endStatement();
+  return { statements, nested };
+}
+
+const ASSIGN = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/s;
+
+/** `$VAR`・`${VAR}`・頭の `~` を展開する。展開できない物（未定義の変数・$(…)・`…`）が残れば null。 */
+function expand(value, vars, env) {
+  if (/`|\$\(/.test(value)) return null;
+  let unresolved = false;
+  let out = value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (_m, a, b) => {
+    const name = a ?? b;
+    const v = name in vars ? vars[name] : env[name];
+    if (v === undefined) {
+      unresolved = true;
+      return "";
+    }
+    return v;
+  });
+  if (unresolved || out.includes("$")) return null;
+  if (out === "~" || out.startsWith("~/")) {
+    if (!env.HOME) return null;
+    out = env.HOME + out.slice(1);
+  }
+  return out;
+}
+
+/** socket の道を比べられる形にする（macOS の /tmp → /private/tmp を realpath で揃える）。 */
+function canonical(p, cwd, realpath) {
+  const abs = path.resolve(cwd, p);
+  const dir = path.dirname(abs);
+  let real = dir;
+  try {
+    real = realpath(dir);
+  } catch {
+    // 無い道は字のまま比べる
+  }
+  return path.join(real, path.basename(abs));
+}
+
+/**
+ * tmux 呼び出しの引数から、kill-server を撃つか・行き先は何かを読む。
+ * tmux は `\;` で命令を続けられるので、全ての命令を見る。命令名は一意な前方一致も効く（kill-ser 以上）。
+ * @returns {{ kills: boolean; socket?: string; label?: string }}
+ */
+export function readTmuxArgs(args) {
+  /** @type {{ kills: boolean; socket?: string; label?: string }} */
+  const r = { kills: false };
+  let i = 0;
+  for (; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      i++;
+      break;
+    }
+    if (!a.startsWith("-") || a === "-") break;
+    // 束ねたフラグ（-2u）と、引数つきの直付け（-L名・-S/道）を読む
+    for (let k = 1; k < a.length; k++) {
+      const f = a[k];
+      if (TMUX_OPTS_WITH_ARG.has(f)) {
+        const val = k + 1 < a.length ? a.slice(k + 1) : args[++i];
+        if (f === "S") r.socket = val ?? "";
+        if (f === "L") r.label = val ?? "";
+        break;
+      }
+    }
+  }
+  let atCommand = true;
+  for (; i < args.length; i++) {
+    let a = args[i];
+    const ends = a.length > 1 && a.endsWith(";");
+    if (a === ";") {
+      atCommand = true;
+      continue;
+    }
+    if (ends) a = a.slice(0, -1);
+    if (atCommand && a.length >= "kill-ser".length && "kill-server".startsWith(a)) r.kills = true;
+    atCommand = ends;
+  }
+  return r;
+}
+
+/**
+ * Bash の命令 1 本を判定する。止めるなら理由（日本語 1 文）、通すなら null。
+ * @param {string} command
+ * @param {{ env?: Record<string, string | undefined>; cwd?: string; uid?: number; realpath?: (p: string) => string }} [ctx]
+ * @returns {string | null}
+ */
+export function verdict(command, ctx = {}) {
+  const env = ctx.env ?? process.env;
+  const cwd = ctx.cwd ?? process.cwd();
+  const uid = ctx.uid ?? (typeof process.getuid === "function" ? process.getuid() : 0);
+  const realpath = ctx.realpath ?? ((p) => fs.realpathSync.native(p));
+  return judge(command, { env, cwd, uid, realpath, vars: {} }, 0);
+}
+
+function judge(command, c, depth) {
+  if (typeof command !== "string" || command.length === 0 || depth > 4) return null;
+  const { statements, nested } = splitShell(command);
+  for (const sub of nested) {
+    const why = judge(sub, c, depth + 1);
+    if (why) return why;
+  }
+  for (const words of statements) {
+    const why = judgeStatement(words, c, depth);
+    if (why) return why;
+  }
+  return null;
+}
+
+function judgeStatement(words, c, depth) {
+  // 頭の代入（`X=1 cmd` の一時代入と、代入だけの文＝以後の行で効くシェル変数）
+  /** @type {Record<string, string>} */
+  const prefix = {};
+  let k = 0;
+  while (k < words.length && ASSIGN.test(words[k])) {
+    const [, name, value] = /** @type {RegExpMatchArray} */ (words[k].match(ASSIGN));
+    prefix[name] = expand(value, c.vars, c.env) ?? "";
+    k++;
+  }
+  if (k === words.length) {
+    Object.assign(c.vars, prefix);
+    return null;
+  }
+  if (words[k] === "export") {
+    for (const w of words.slice(k + 1)) {
+      const m = w.match(ASSIGN);
+      if (m) c.vars[m[1]] = expand(m[2], c.vars, c.env) ?? "";
+    }
+    return null;
+  }
+
+  const base = words.map((w) => path.basename(w));
+
+  // ② pkill／killall の tmux
+  const killer = base.findIndex((b) => b === "pkill" || b === "killall");
+  if (killer !== -1 && words.slice(killer + 1).some((w) => w.includes("tmux"))) {
+    return "pkill／killall の tmux は艦隊の tmux サーバを巻き込む";
+  }
+
+  // bash -c '…'・eval … の中身も命令として見る
+  const sh = base.findIndex((b) => SHELLS.has(b));
+  if (sh !== -1) {
+    const ci = words.indexOf("-c", sh + 1);
+    if (ci !== -1 && words[ci + 1] !== undefined) {
+      const why = judge(words[ci + 1], c, depth + 1);
+      if (why) return why;
+    }
+  }
+  if (base[k] === "eval") {
+    const why = judge(words.slice(k + 1).join(" "), c, depth + 1);
+    if (why) return why;
+  }
+
+  const t = base.findIndex((b) => b === "tmux" || b === "tmux-gui.sh");
+  if (t === -1) return null;
+  const r = readTmuxArgs(words.slice(t + 1));
+  if (!r.kills) return null;
+  if (base[t] === "tmux-gui.sh") {
+    return "tmux-gui.sh kill-server は艦隊の tmux サーバそのものを消す";
+  }
+
+  // この呼び出しで効く環境（`env -u TMUX`・一時代入・export を重ねる）
+  /** @type {Record<string, string | undefined>} */
+  const eff = { ...c.env, ...c.vars, ...prefix };
+  for (let j = k; j < t; j++) {
+    if (base[j] === "env") {
+      for (let m = j + 1; m < t; m++) {
+        if (words[m] === "-u" && words[m + 1] !== undefined) eff[words[++m]] = undefined;
+        else if (words[m].startsWith("--unset=")) eff[words[m].slice(8)] = undefined;
+        else if (ASSIGN.test(words[m])) {
+          const [, n, v] = /** @type {RegExpMatchArray} */ (words[m].match(ASSIGN));
+          eff[n] = expand(v, c.vars, c.env) ?? "";
+        }
+      }
+    }
+  }
+
+  if (r.socket === undefined && r.label === undefined) {
+    return "行き先（-S <socket> か -L <名>）の無い tmux kill-server（$TMUX が在ると TMUX_TMPDIR は効かず席自身のサーバに当たる・無ければ既定サーバに当たる）";
+  }
+
+  // ③ 行き先が席自身のサーバ／既定サーバか
+  const tmpdirOf = (e) => (e.TMUX_TMPDIR && e.TMUX_TMPDIR.length > 0 ? e.TMUX_TMPDIR : "/tmp");
+  let target;
+  if (r.socket !== undefined) {
+    const p = expand(r.socket, c.vars, c.env);
+    if (p === null || p === "") return "kill-server の -S の行き先が読めない（変数など）。使い捨ての socket は字で書け";
+    target = canonical(p, c.cwd, c.realpath);
+  } else {
+    const name = expand(/** @type {string} */ (r.label), c.vars, c.env);
+    if (name === null || name === "") return "kill-server の -L の名が読めない（変数など）。使い捨ての socket は -S と字で書け";
+    target = canonical(path.join(tmpdirOf(eff), `tmux-${c.uid}`, name), c.cwd, c.realpath);
+  }
+  /** @type {string[]} */
+  const protectedSockets = [];
+  const seat = (c.env.TMUX ?? "").split(",")[0];
+  if (seat) protectedSockets.push(canonical(seat, c.cwd, c.realpath));
+  protectedSockets.push(canonical(path.join(tmpdirOf(c.env), `tmux-${c.uid}`, "default"), c.cwd, c.realpath));
+  if (protectedSockets.includes(target)) {
+    return `kill-server の行き先（${target}）が席自身の tmux サーバ（艦隊）を指している`;
+  }
+  return null;
+}
+
+/** 拒否文。 */
+export function denyMessage(reason) {
+  return `⛔ tmux-guard（n=2320）: ${reason}。${GUIDE}`;
+}
+
+/**
+ * hook の本体。stdin の文字列を受けて終了コードを返す（0＝通す／2＝止める）。
+ * @param {string} raw
+ * @param {{ env?: Record<string, string | undefined>; uid?: number; realpath?: (p: string) => string; stderr?: (s: string) => void }} [ctx]
+ */
+export function runHook(raw, ctx = {}) {
+  let reason = null;
+  try {
+    const data = JSON.parse(raw);
+    if (!data || data.tool_name !== "Bash") return 0;
+    const command = data.tool_input?.command;
+    if (typeof command !== "string") return 0;
+    reason = verdict(command, {
+      env: ctx.env,
+      cwd: typeof data.cwd === "string" && data.cwd ? data.cwd : undefined,
+      uid: ctx.uid,
+      realpath: ctx.realpath,
+    });
+  } catch {
+    return 0; // 読めない入力で席を止めない
+  }
+  if (!reason) return 0;
+  (ctx.stderr ?? ((s) => process.stderr.write(s)))(denyMessage(reason) + "\n");
+  return 2;
+}
+
+function isMain() {
+  try {
+    return !!process.argv[1] && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+if (isMain()) {
+  let raw = "";
+  try {
+    raw = fs.readFileSync(0, "utf8");
+  } catch {
+    process.exit(0);
+  }
+  process.exit(runHook(raw));
+}