@tyhld/conductor 0.3.0 → 0.7.0

package/scripts/hooks/policy.py

@@ -0,0 +1,759 @@
+#!/usr/bin/env python3
+"""policy.py — 番人の判定そのもの（純粋関数だけ・段2の作り直し）。
+
+【なぜ作り直したか（棚卸し 26d6fe68 の根治）】
+  旧番人は「安全な動詞を列挙し、載っていないものは全部確認」だった。運用方針は逆で
+  「人間の関門は3つだけ、他は自走してよい」＝【止める側が有限集合】。向きが逆だったため、
+  新しいコマンド（docker / make / go / cargo / gh workflow / git worktree / journalctl …）が
+  出るたびに自動的に【間違った側＝確認】へ落ち、人が許可リストへ1行ずつ足して埋めていた
+  （実測 200行超）。その許可リストが逆に番人の境界を迂回する、という悪循環になっていた。
+
+【この版の判定（上から順に1つだけ当たる）】
+  1. 危険     → deny   … 本番破壊・force push・データ消失・認証情報の露出/持ち出し
+  2. 3関門    → gate   … main直変更 / 本番確認 / DB実行（人が必ず判断する）
+  3. それ以外 → allow  … 自走してよい。★新しいコマンドは必ずここへ落ちる
+
+★PRのマージ（`gh pr merge`）は関門ではない（決定・案B完全自動化）。詳しくは _gate_merge の説明。
+
+【危険は「動詞」ではなく「対象と作用」で見る】
+  旧番人は動詞を白に入れた瞬間に対象を見なくなり、`curl -d @.env`・`cp .env /tmp`・
+  `sed -i` で任意パス書換、が全部素通りしていた（実測）。ここでは
+    ・秘密（.env / 鍵 / 認証情報 / 秘密ディレクトリ）に触れるなら、動詞が何であれ deny
+    ・システム領域へ「書く」作用があるなら deny
+  とし、Bash でもファイル編集ツールでも同じ語彙で判定する＝経路による強度差を無くす。
+
+★このモジュールは標準ライブラリだけで動き、製品固有の名前を持たない（切り出し可能）。
+"""
+import os
+import re
+import shlex
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 判定の返り値
+#   'deny'  … 実行させない
+#   'gate'  … 人間の関門（呼び出し側が人へ渡す）
+#   'allow' … 自走してよい
+# ═════════════════════════════════════════════════════════════════════════════
+DENY, GATE, ALLOW = 'deny', 'gate', 'allow'
+
+# 関門の種類（表示・集計用）。
+# ★GATE_MERGE の中身は「PRのマージ」から「main への直接 push」へ縮んだ（_gate_merge 参照）。
+#   種別の字面 'merge' は管制の表示・集計が使っているので変えない。
+GATE_MERGE = 'merge'      # 関門1 本番ブランチの直接変更
+GATE_RELEASE = 'release'  # 関門2 本番確認
+GATE_DB = 'db'            # 関門3 DB実行
+
+
+def _r(decision, reason, gate=None):
+    return {'decision': decision, 'reason': reason, 'gate': gate}
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 秘密・システム領域の語彙（decide_write と Bash で共用する＝経路差を無くす本体）
+# ═════════════════════════════════════════════════════════════════════════════
+
+# 常に触らせないファイル名（読み取りも含む＝「露出」を止める）。
+_SECRET_FILE_RE = re.compile(
+    r'^(id_(rsa|dsa|ecdsa|ed25519).*|authorized_keys|known_hosts|.*\.pem|.*\.key|'
+    r'\.netrc|\.npmrc|\.pypirc|credentials)$'
+)
+
+# 雛形（テンプレート）の接尾辞。この2つで終わる名前は秘密ファイル判定から外す。
+# 例: .env.example / .env.local.example / config.sample。値の入っていない見本のため。
+_TEMPLATE_SUFFIX_RE = re.compile(r'\.(example|sample)$', re.IGNORECASE)
+
+# 常に触らせないディレクトリ名（階層のどこかに出てきたら該当）。
+_SECRET_DIRS = frozenset({'.ssh', '.gnupg', '.aws', '.gcloud'})
+
+# 書き込みを常に禁じるシステム領域（絶対パスの先頭成分）。
+_SYSTEM_TOPS = frozenset({
+    'etc', 'usr', 'bin', 'sbin', 'boot', 'lib', 'lib64', 'dev', 'proc', 'sys', 'root', 'var',
+})
+
+# 秘密を含む環境変数の名前（この字面が出てきたら露出とみなす）。
+_SECRET_ENV_RE = re.compile(
+    r'\$\{?(DATABASE_URL|DIRECT_URL|[A-Z0-9_]*(SECRET|TOKEN|PASSWORD|APIKEY|API_KEY|PRIVATE_KEY))\}?'
+)
+
+
+def is_secret_name(name: str) -> bool:
+    """ファイル名が「秘密そのもの」か（.env / .env.* / 鍵 / 認証情報）。
+
+    ★雛形（.example / .sample）は除外する。`.env.example` は「どの項目を書くか」を示す
+      見本で、値は空＝秘密を含まない。それでも `.env.` で始まるため秘密扱いになり、
+      職人が雛形の記述を直すだけの作業まで止まっていた（実地で2回発生）。
+      除外はこの2つの接尾辞だけ。`.env` 本体・`.env.local`・`.env.production` などの
+      保護は一切緩めない。
+    """
+    if _TEMPLATE_SUFFIX_RE.search(name):
+        return False
+    if name == '.env' or name.startswith('.env.'):
+        return True
+    return bool(_SECRET_FILE_RE.match(name))
+
+
+def secret_reason(path: str):
+    """パスが秘密に触れるなら理由、そうでなければ None。読み書きを問わない。"""
+    comps = [c for c in path.replace('\\', '/').split('/') if c]
+    if not comps:
+        return None
+    name = comps[-1]
+    if is_secret_name(name):
+        return f'secret file ({name})'
+    for c in comps[:-1]:
+        if c in _SECRET_DIRS:
+            return f'secret directory ({c})'
+    if name in _SECRET_DIRS:
+        return f'secret directory ({name})'
+    return None
+
+
+# システム領域だが書いても無害な特殊ファイル（捨て先・標準出力など）。
+# ★ここを除外しないと `... > /dev/null` という日常操作が止まる（実際に止まった）。
+_HARMLESS_DEVICES = frozenset({
+    '/dev/null', '/dev/stdout', '/dev/stderr', '/dev/tty', '/dev/zero', '/dev/urandom',
+    '/dev/random', '/dev/fd',
+})
+
+# 使い捨ての作業場（OSの一時領域）の根。★ここ【だけ】が .claude 保護の例外になる。
+# 実機 2026-09-02 12:07: 職人が検証のために作った
+#   /tmp/claude-.../scratchpad/b/home/projects/s/.claude
+# が「.claude という名前」だけで本物の設定と同じ扱いになり、ターミナルが止まった。
+# 名前だけで決めず、場所も見る（ADR-014）。
+_THROWAWAY_TOPS = ('/tmp', '/var/tmp', '/dev/shm', '/private/tmp', '/private/var/tmp')
+
+
+def _throwaway_roots():
+    """使い捨ての作業場の根の一覧。$TMPDIR が別の場所を指す機体にも合わせる。"""
+    roots = list(_THROWAWAY_TOPS)
+    tmpdir = os.environ.get('TMPDIR') or ''
+    tmpdir = tmpdir.rstrip('/')
+    if tmpdir.startswith('/'):
+        roots.append(os.path.normpath(tmpdir))
+    return roots
+
+
+def _under(path: str, root: str) -> bool:
+    """path が root の中にあるか（root 自身は含めない・成分単位で比べる）。"""
+    return path.startswith(root.rstrip('/') + '/')
+
+
+def _named_guard_settings(path: str) -> bool:
+    """字面が「.claude/settings…」の形か（名前だけの判定・単体では使わない）。"""
+    comps = [c for c in path.replace('\\', '/').split('/') if c]
+    return len(comps) >= 2 and comps[-2] == '.claude' and comps[-1].startswith('settings')
+
+
+def is_guard_settings_path(path: str) -> bool:
+    """番人自身の設定ファイルを指すか。字面と、近道(symlink)を解いた実体の両方を見る。
+
+    ★別名の近道（例 /tmp/shortcut → ~/.claude）から本物へ書くのを塞ぐため、
+      実体側の形も見る。★ここは「該当するか」だけを答え、守るか通すかは
+      is_throwaway_path（場所の条件）と組で決める。
+    """
+    if _named_guard_settings(path):
+        return True
+    try:
+        return _named_guard_settings(os.path.realpath(path))
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def is_throwaway_path(path: str) -> bool:
+    """絶対パスが「使い捨ての作業場の下」か。
+
+    ★安全の要（ここを間違えると番人が効かなくなる）:
+      ・既定は False（＝守る側）。使い捨てだと【確実に言える】ときだけ True。
+      ・字面のパスと、シンボリックリンクを解いた実体の【両方】が一時領域の中にある
+        ことを求める。`/tmp/x -> ~/.claude` のような近道で本物へ書くのを塞ぐ。
+      ・ホームの ~/.claude 配下は、たとえ HOME が一時領域にあっても常に守る。
+    """
+    if not path.startswith('/'):
+        return False
+    home_claude = os.path.join(os.path.expanduser('~'), '.claude')
+    if path == home_claude or _under(path, home_claude):
+        return False
+    roots = _throwaway_roots()
+    if not any(_under(path, r) for r in roots):
+        return False
+    try:
+        real = os.path.realpath(path)
+    except Exception:  # noqa: BLE001
+        return False
+    return any(_under(real, r) for r in roots)
+
+
+def system_write_reason(path: str):
+    """絶対パスがシステム領域なら理由、そうでなければ None（書き込み作用のときだけ使う）。"""
+    if not path.startswith('/'):
+        return None
+    if path in _HARMLESS_DEVICES or path.startswith('/dev/fd/'):
+        return None
+    comps = [c for c in path.split('/') if c]
+    if comps and comps[0] in _SYSTEM_TOPS:
+        return f'system path (/{comps[0]})'
+    return None
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Bash コマンドの分解
+# ═════════════════════════════════════════════════════════════════════════════
+
+# 制御演算子（複合コマンドの分割）。
+_SPLIT_RE = re.compile(r'&&|\|\||[;|&\n]')
+
+
+def split_segments(command: str):
+    """複合コマンドを単純コマンドへ割る（判定は各セグメントに対して行う）。"""
+    return [s.strip() for s in _SPLIT_RE.split(command) if s.strip()]
+
+
+def tokens_of(segment: str):
+    """1セグメントを語に割る。クォートが壊れていても落ちない（安全側で素朴分割へ）。"""
+    try:
+        return shlex.split(segment, comments=False, posix=True)
+    except ValueError:
+        return segment.split()
+
+
+# 先頭に付く環境設定・ラッパ（実体の動詞まで読み進める）。
+_WRAPPERS = frozenset({
+    'env', 'nohup', 'time', 'stdbuf', 'setsid', 'timeout', 'nice', 'ionice',
+    'command', 'builtin', 'sudo', 'xargs',
+})
+_ASSIGN_RE = re.compile(r'^[A-Za-z_][A-Za-z0-9_]*=')
+
+
+def verb_of(tokens):
+    """セグメントの実行動詞（ラッパ・変数代入を飛ばした先頭語）。無ければ ''。"""
+    i = 0
+    while i < len(tokens):
+        t = tokens[i]
+        if _ASSIGN_RE.match(t):
+            i += 1
+            continue
+        base = t.split('/')[-1]
+        if base in _WRAPPERS:
+            i += 1
+            # ラッパのオプションを飛ばす（timeout 600 のような値も1つ飛ばす）。
+            while i < len(tokens) and tokens[i].startswith('-'):
+                i += 1
+            if base in ('timeout', 'nice', 'ionice') and i < len(tokens) \
+                    and not tokens[i].startswith('-'):
+                i += 1
+            continue
+        return base
+    return ''
+
+
+# 「書き込む」作用を持つ動詞（対象パスに書く／消す／複製する）。
+WRITE_VERBS = frozenset({
+    'tee', 'dd', 'install', 'truncate', 'chmod', 'chown', 'chgrp', 'ln',
+    'cp', 'mv', 'rm', 'touch', 'mkdir', 'rmdir', 'shred', 'patch',
+})
+
+# 「外へ送る／持ち出す」作用を持つ動詞。
+EXFIL_VERBS = frozenset({
+    'curl', 'wget', 'scp', 'rsync', 'sftp', 'ftp', 'nc', 'ncat', 'netcat',
+    'ssh', 'mail', 'sendmail', 'tar', 'zip', 'gzip', 'base64', 'openssl', 'gpg',
+})
+
+# 「中身を読み出す」動詞（秘密に対して使われたら露出）。
+READ_VERBS = frozenset({
+    'cat', 'head', 'tail', 'less', 'more', 'strings', 'xxd', 'od', 'grep', 'awk', 'sed',
+    'cp', 'mv', 'tar', 'zip', 'base64', 'curl', 'wget', 'scp', 'rsync',
+})
+
+
+# リダイレクト先の字面から剥がす記号。
+#   ★シェルの飾りであって【パスの一部ではない】ものだけを並べる。
+#     ( )    … コマンド置換 `$( … )` の閉じ括弧・プロセス置換
+#     ` ' "  … クォート・バッククォート
+#   これを剥がさないと、コマンド置換の中の `2>/dev/null` が `/dev/null)` として
+#   取り出され、捨て先の例外（_HARMLESS_DEVICES）に当たらず「/dev への書き込み」で
+#   止まっていた（実機 2026-09-03 再現。`true 2>/dev/null` は通るのに
+#   `p=$(command -v node 2>/dev/null)` だけ止まる、という取りこぼし）。
+_REDIRECT_TRIM = '()`\'"'
+
+
+def normalize_redirect_target(raw: str) -> str:
+    """リダイレクト先の字面から、シェルの飾りだけを剥がして素のパスにする。
+
+    ★判定を1か所へ寄せるための関門。ここを通した文字列だけを secret_reason /
+      system_write_reason に渡すので、★コマンド置換の中でも外でも同じ判定になる。
+    ★剥がすのは飾りだけ。パスそのものは1文字も変えない（緩める方向の変更はしない）。
+      むしろ `>"/etc/hosts"` のようにクォート付きで書かれた書き込みも、これで素の
+      `/etc/hosts` として判定に載る＝今までより厳しくなる。
+    """
+    return raw.strip().strip(_REDIRECT_TRIM)
+
+
+def redirect_targets(segment: str):
+    """`> path` / `>> path` の書き込み先を拾う（飾りを剥がした素のパスで返す）。
+
+    ★`2>&1` のようなファイル記述子の複製は拾わない（& を除いてあるので該当しない）。
+    ★飾りを剥がした結果が空になったものは落とす（`>(cmd)` のプロセス置換など、
+      パスを指していない形）。
+    """
+    raw = re.findall(r'>>?\s*([^\s;|&]+)', segment)
+    return [t for t in (normalize_redirect_target(r) for r in raw) if t]
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# ラッパの中身（bash -c "…" / python3 -c "…" / ヒアドキュメント）
+#   ★包むだけで秘密が読めていた穴を塞ぐ。`cat .env` は止まるのに
+#     `bash -c "cat .env"` は素通りしていた（調査 d7a1c150 で実測）。
+#     中身を取り出して【同じ物差し】を当て直す。検知を足すだけで、緩める変更は無い。
+# ═════════════════════════════════════════════════════════════════════════════
+
+# 「-c の中身がシェルコマンド」の道具。中身はもう一度コマンドとして測る。
+_SHELL_RUNNERS = frozenset({'bash', 'sh', 'zsh', 'dash', 'ksh'})
+
+# 「-c / -e の中身がプログラム」の道具。中身は文字列として秘密の名前を探す。
+_CODE_RUNNERS = frozenset({
+    'python', 'python2', 'python3', 'node', 'nodejs', 'perl', 'ruby', 'php', 'deno', 'bun',
+})
+
+# 中身を渡すための旗。
+_CODE_FLAGS = frozenset({'-c', '-e', '--eval', '--command'})
+
+# ヒアドキュメント（<<EOF … EOF / <<'PY' … PY）の本体を取り出す。
+_HEREDOC_RE = re.compile(
+    r'<<-?\s*[\'"]?([A-Za-z_][A-Za-z0-9_]*)[\'"]?[^\n]*\n(.*?)\n\s*\1\s*(?:\n|$)',
+    re.DOTALL,
+)
+
+# プログラムの中の文字列リテラル（open('.env') の '.env' を拾う）。
+_QUOTED_RE = re.compile(r'''['"]([^'"\n]{1,300})['"]''')
+
+# 入れ子の上限。`bash -c "bash -c ..."` の2段まで見れば実用上足りる（無限再帰の防止）。
+_UNWRAP_MAX_DEPTH = 2
+
+
+def _code_secret_reason(text: str):
+    """プログラム文字列の中に秘密ファイルの名前が出てくるなら理由を返す。
+
+    ★完全な構文解析はしない。`open('.env')` のように名前が文字列として現れることを
+      見れば足りる。雛形（.example / .sample）は secret_reason 側の除外がそのまま効く。
+    """
+    for m in _QUOTED_RE.finditer(text or ''):
+        cand = m.group(1).strip()
+        if not cand:
+            continue
+        sr = secret_reason(cand)
+        if sr:
+            return sr
+    return None
+
+
+def _inner_payloads(command: str):
+    """ラッパが抱えている「中身」を (種別, 呼び出した道具, 中身) の一覧で返す。
+
+    種別は 'shell'（もう一度コマンドとして測る）か 'code'（文字列として名前を探す）。
+    """
+    out = []
+
+    # ① `<runner> -c "…"` / `<runner> -e "…"` の形。
+    #    ★全文と各セグメントの両方を見る。中身に ; や | があるとセグメント分割で
+    #      千切れるため、全文からの取り出しが要る。
+    for text in [command] + split_segments(command):
+        toks = tokens_of(text)
+        for i, t in enumerate(toks):
+            if t not in _CODE_FLAGS or i + 1 >= len(toks):
+                continue
+            runner = verb_of(toks[:i]) if i else ''
+            if runner in _SHELL_RUNNERS:
+                out.append(('shell', runner, toks[i + 1]))
+            elif runner in _CODE_RUNNERS:
+                out.append(('code', runner, toks[i + 1]))
+
+    # ② ヒアドキュメント（`python3 - <<EOF … EOF` / `bash <<'SH' … SH`）。
+    for m in _HEREDOC_RE.finditer(command or ''):
+        head = command[:m.start()].rsplit('\n', 1)[-1]
+        runner = verb_of(tokens_of(head))
+        kind = 'shell' if runner in _SHELL_RUNNERS else 'code'
+        out.append((kind, runner or 'heredoc', m.group(2)))
+
+    return out
+
+
+def _wrapper_danger(command: str, depth: int = 0):
+    """ラッパの中身に同じ判定を当てる。危険なら理由を返す。"""
+    if depth >= _UNWRAP_MAX_DEPTH:
+        return None
+    for kind, runner, inner in _inner_payloads(command):
+        if not inner or not inner.strip():
+            continue
+        where = f'inside {runner}' if runner else 'inside wrapper'
+        if kind == 'code':
+            sr = _code_secret_reason(inner)
+            if sr:
+                return f'{sr} referenced {where}'
+            continue
+        # shell: 中身をコマンドとして測り直す（秘密・システム領域・危険な rm）。
+        hit = _rm_danger(inner)
+        if hit:
+            return f'{hit} ({where})'
+        for seg in split_segments(inner):
+            toks = tokens_of(seg)
+            hit = _secret_danger(seg, verb_of(toks), toks)
+            if hit:
+                return f'{hit} ({where})'
+        hit = _wrapper_danger(inner, depth + 1)
+        if hit:
+            return hit
+    return None
+
+
+def is_inplace_edit(verb: str, tokens) -> bool:
+    """sed -i / perl -i のような「その場書き換え」か。"""
+    if verb in ('sed', 'perl', 'ruby'):
+        return any(t == '-i' or t.startswith('-i') or t.startswith('--in-place') for t in tokens[1:])
+    return False
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 1) 危険（deny）
+# ═════════════════════════════════════════════════════════════════════════════
+
+def _danger_patterns(low: str):
+    """全文（小文字）に対する無条件の危険。変数へ直書きされたものも文字列として拾う。"""
+    if re.search(r'git\s+push\b[^;&|\n]*?(--force(-with-lease)?\b|(?:^|\s)-f(?:\s|$)|\s\+\S)', low):
+        return 'force push'
+    if re.search(r'git\s+reset\b[^;&|\n]*--hard\b', low):
+        return 'git reset --hard'
+    for m in re.finditer(r'git\s+clean\b([^;&|\n]*)', low):
+        fl = ''.join(re.findall(r'-([a-z]+)', m.group(1)))
+        if 'f' in fl and 'd' in fl:
+            return 'git clean -fd'
+    if re.search(r'\bdrop\s+table\b', low):
+        return 'drop table'
+    if re.search(r'\bdrop\s+database\b', low):
+        return 'drop database'
+    if re.search(r'\bsupabase\s+db\s+reset\b', low):
+        return 'supabase db reset'
+    if re.search(r'\bgh\s+secret\b', low):
+        return 'gh secret'
+    if re.search(r'\bsudo\s+rm\b', low):
+        return 'sudo rm'
+    if re.search(r'\bprintenv\b', low):
+        return 'printenv (環境変数の一括露出)'
+    return None
+
+
+# 危険でない作業フォルダの絶対パス先頭成分（/tmp/xxx は限定削除として通す）。
+_SAFE_ABS_TOP = frozenset({'tmp'})
+
+
+def rm_path_risk(path: str) -> str:
+    """rm の対象パスの危険度: 'dangerous' / 'safe' / 'unknown'。"""
+    p = path.strip().strip('"').strip("'")
+    if p == '':
+        return 'unknown'
+    if p in ('$HOME', '${HOME}', '$HOME/', '${HOME}/'):
+        return 'dangerous'
+    if p.startswith('$HOME/') or p.startswith('${HOME}/'):
+        rest = p.split('/', 1)[1] if '/' in p else ''
+        return 'safe' if rest.strip() else 'dangerous'
+    if any(c in p for c in ('$', '`', '*', '?', '{', '[')):
+        return 'unknown'
+    if p in ('/', '~', '~/'):
+        return 'dangerous'
+    if p.startswith('~'):
+        return 'dangerous' if p[1:].lstrip('/') == '' else 'safe'
+    if p.startswith('/'):
+        comps = [c for c in p.split('/') if c]
+        if not comps:
+            return 'dangerous'
+        if comps[0] in _SAFE_ABS_TOP and len(comps) >= 2:
+            return 'safe'
+        return 'dangerous'
+    return 'safe'
+
+
+def _rm_danger(command: str):
+    """再帰的 rm の対象パスを全部見て、危険なものがあれば理由を返す。"""
+    for m in re.finditer(r'\brm\b', command):
+        seg = _SPLIT_RE.split(command[m.end():], maxsplit=1)[0]
+        toks = seg.split()
+        flags = [t for t in toks if t.startswith('-')]
+        recursive = any(('r' in f.lstrip('-').lower()) or f in ('--recursive',) for f in flags)
+        paths = [t for t in toks if not t.startswith('-')]
+        for p in paths:
+            risk = rm_path_risk(p)
+            if risk == 'dangerous':
+                return f'rm on dangerous path ({p})'
+            if risk == 'unknown' and recursive:
+                return f'recursive rm with variable/glob path ({p})'
+    return None
+
+
+def _secret_danger(segment: str, verb: str, tokens):
+    """このセグメントが秘密に触れる／システム領域へ書くなら理由を返す。
+
+    ★ここが「対象と作用」判定の本体。動詞が何であれ、対象が秘密なら止める。
+    """
+    # 秘密を含む環境変数の露出（echo $DATABASE_URL、curl -d "$TOKEN" など）。
+    if _SECRET_ENV_RE.search(segment):
+        return 'secret environment variable exposure'
+
+    args = tokens[1:] if tokens else []
+    for raw in args:
+        # 値の書き方は色々ある: `.env` / `@.env`（curl -d @file）/ `--post-file=.env`。
+        # オプション名に埋まった値まで見ないと、持ち出しを1つ取りこぼす。
+        candidates = [raw.lstrip('@')]
+        if raw.startswith('-') and '=' in raw:
+            candidates.append(raw.split('=', 1)[1].lstrip('@'))
+        a = next((c for c in candidates if c and not c.startswith('-')), '')
+        if not a:
+            continue
+        sr = secret_reason(a)
+        if sr:
+            # 秘密に触れる動詞なら止める（読み・書き・持ち出しのいずれでも露出になる）。
+            #
+            # ★動詞を限定するのが要点。「引数に .env という字面があれば止める」にすると、
+            #   コミットメッセージや説明文に .env と書いただけで止まる（実際に止まった）。
+            #   その代わり、未知の道具に秘密を渡す形（`mytool .env`）は素通りする＝
+            #   限界として README に明記してある。
+            if verb in READ_VERBS or verb in WRITE_VERBS or verb in EXFIL_VERBS:
+                return f'{sr} touched by {verb}'
+        if verb in WRITE_VERBS or is_inplace_edit(verb, tokens):
+            syr = system_write_reason(a)
+            if syr:
+                return f'write to {syr}'
+
+    # リダイレクト先（> / >>）も「書き込む作用」。
+    for t in redirect_targets(segment):
+        sr = secret_reason(t)
+        if sr:
+            return f'redirect into {sr}'
+        syr = system_write_reason(t)
+        if syr:
+            return f'redirect into {syr}'
+    return None
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 2) 3関門（gate）
+# ═════════════════════════════════════════════════════════════════════════════
+
+# 本番として扱うブランチ名（ここへ直接 push するのはマージと同じ重み）。
+PROTECTED_BRANCHES = frozenset({'main', 'master', 'production', 'prod', 'release'})
+
+# DDL / 権限 / RLS を含む SQL の字面（DB実行の関門）。
+_SQL_GATE_RE = re.compile(
+    r'\b(create|alter|drop)\s+(table|index|policy|database|schema|role|function|trigger|view)\b'
+    r'|\bgrant\b|\brevoke\b|\brow\s+level\s+security\b|\btruncate\b',
+    re.IGNORECASE,
+)
+
+# 「引数にSQLらしい字面があっても、実際にはSQLを実行しない」動詞。
+#   ★SQL文字列だけを根拠にした関門は、これらの動詞では出さない（＝誤検知を消す）。
+#     棚卸し前は `grep "alter table" f` / `git commit -m "grant …"` / `echo "create table"` /
+#     `truncate -s 0 build.log`（シェルの truncate はファイル操作でSQLではない）まで
+#     関門に落ちて、えふさんを何度も呼び止めていた（報告 09c70615・調査 29fb9909）。
+#   ★安全側は崩さない: 本物のDB実行（psql / mysql / supabase / prisma / drizzle-kit 等）は
+#     この集合に入れない＝従来どおり別ルートで確実に関門へ落ちる。破壊的な drop table /
+#     drop database は、そもそも gate ではなく deny（_danger_patterns）で止まる。
+_SQL_TEXT_ONLY_VERBS = frozenset({
+    'echo', 'printf', 'cat', 'head', 'tail', 'less', 'more', 'strings',
+    'grep', 'egrep', 'fgrep', 'rg', 'ag', 'ack', 'sed', 'awk', 'cut', 'tr',
+    'sort', 'uniq', 'wc', 'comm', 'diff', 'tee', 'jq', 'yq', 'xargs',
+    'git', 'gh', 'ls', 'find', 'readlink', 'realpath', 'basename', 'dirname',
+    'test', 'true', 'false', 'printenv', 'export', 'cd', 'pwd',
+    'truncate',  # シェルの truncate は「ファイルを縮める」道具。SQLの TRUNCATE ではない。
+})
+
+
+def _gate_merge(low: str, verb: str, tokens):
+    """関門1: 本番ブランチ（main 等）を【PRを通さずに】直接書き換える操作。
+
+    ★PRのマージ（`gh pr merge` / `gh api …/pulls/N/merge`）は関門から外した（案B完全自動化）。
+      理由: マージを関門にすると、職人は最後の1手で必ず人を待つことになり、
+      「指示を出したら終わりまで進む」が成立しなかった。マージはPRという記録が残り、
+      レビューとCIの結果が付いた上での操作なので、人が毎回押す価値より止まる損の方が大きい。
+      ★外したのはマージだけ。main への【直接 push】は関門のまま残す。こちらはPRもレビューも
+        CIも通らずに本番の元が変わるため、性質がまったく違う（外すと歯止めが無くなる）。
+    """
+    if verb == 'git' and len(tokens) >= 2 and tokens[1] == 'push':
+        for t in tokens[2:]:
+            if t.startswith('-'):
+                continue
+            ref = t.split(':')[-1].strip()
+            if ref in PROTECTED_BRANCHES:
+                return f'git push to protected branch ({ref})'
+    return None
+
+
+def _gate_release(low: str, verb: str, tokens):
+    if verb == 'vercel' or (verb == 'npx' and 'vercel' in tokens[:3]):
+        if '--prod' in tokens or '--production' in tokens:
+            return 'vercel --prod'
+        for t in tokens:
+            if t in ('promote', 'alias', 'rollback'):
+                return f'vercel {t}'
+    if verb in ('npm', 'pnpm', 'yarn') and 'publish' in tokens[1:3]:
+        return f'{verb} publish'
+    if re.search(r'\bsupabase\s+functions\s+deploy\b', low):
+        return 'supabase functions deploy'
+    # 「deploy っぽい語」＋「本番の指定」の組み合わせ（新しい道具にも効く一般形）。
+    if re.search(r'\bdeploy\b', low) and re.search(r'--prod(uction)?\b', low):
+        return 'deploy --prod'
+    return None
+
+
+def _gate_db(low: str, verb: str, tokens, segment: str):
+    if verb in ('psql', 'mysql', 'mongosh', 'dropdb', 'createdb', 'pg_restore', 'pg_dump'):
+        return f'database client ({verb})'
+    if re.search(r'\bprisma\s+(migrate|db)\b', low):
+        return 'prisma migrate/db'
+    if re.search(r'\bsupabase\s+(db\s+(push|reset|query|execute)|migration\s+up)\b', low):
+        return 'supabase db/migration'
+    if re.search(r'\bdrizzle-kit\s+(push|migrate)\b', low):
+        return 'drizzle-kit push/migrate'
+    # SQL 文字列（DDL / GRANT / RLS）を根拠にした関門。
+    #   ★「実際にSQLを実行しうる入口」に限る。文字列を扱うだけの動詞（echo / grep / git …）は
+    #     引数にSQLの字面があっても実行しないので関門にしない（＝誤検知を消す・緩める変更）。
+    #     一方、psql/mysql への `| psql` は分割後に psql セグメントが別途上で関門に当たり、
+    #     run-sql / apply のような未知のSQL実行入口は safe 集合に無いのでここで関門に落ちる。
+    if verb not in _SQL_TEXT_ONLY_VERBS and _SQL_GATE_RE.search(segment):
+        return 'SQL DDL/GRANT/RLS'
+    return None
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 入口: Bash
+# ═════════════════════════════════════════════════════════════════════════════
+
+def decide_bash(command: str):
+    """Bash コマンド1件の判定。既定は allow。"""
+    if not command or not command.strip():
+        return _r(ALLOW, 'empty command')
+    low = command.lower()
+
+    # ---- 1) 危険（全文） ----
+    hit = _danger_patterns(low)
+    if hit:
+        return _r(DENY, f'danger: {hit}')
+    hit = _rm_danger(command)
+    if hit:
+        return _r(DENY, f'danger: {hit}')
+
+    segments = split_segments(command)
+
+    # ---- 1) 危険（セグメントごと・対象と作用） ----
+    for seg in segments:
+        toks = tokens_of(seg)
+        v = verb_of(toks)
+        hit = _secret_danger(seg, v, toks)
+        if hit:
+            return _r(DENY, f'danger: {hit}')
+
+    # ---- 1c) 危険（ラッパの中身にも同じ物差しを当てる） ----
+    #      `bash -c "cat .env"` / `python3 -c "open('.env')"` / ヒアドキュメント経由。
+    hit = _wrapper_danger(command)
+    if hit:
+        return _r(DENY, f'danger: {hit}')
+
+    # ---- 2) 3関門 ----
+    for seg in segments:
+        toks = tokens_of(seg)
+        v = verb_of(toks)
+        seg_low = seg.lower()
+        hit = _gate_merge(seg_low, v, toks)
+        if hit:
+            return _r(GATE, f'gate(merge): {hit}', GATE_MERGE)
+        hit = _gate_release(seg_low, v, toks)
+        if hit:
+            return _r(GATE, f'gate(release): {hit}', GATE_RELEASE)
+        hit = _gate_db(seg_low, v, toks, seg)
+        if hit:
+            return _r(GATE, f'gate(db): {hit}', GATE_DB)
+
+    # ---- 3) それ以外は自走 ----
+    return _r(ALLOW, 'no gate, no danger')
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 入口: ファイル編集ツール（Write / Edit / MultiEdit / NotebookEdit）
+#   ★Bash と同じ語彙で判定する＝経路による強度差を無くす。
+# ═════════════════════════════════════════════════════════════════════════════
+
+def norm_path(file_path: str, cwd=None) -> str:
+    p = os.path.expanduser(file_path.strip())
+    if not os.path.isabs(p):
+        base = cwd if (cwd and os.path.isabs(cwd)) else os.getcwd()
+        p = os.path.join(base, p)
+    return os.path.normpath(p)
+
+
+def decide_write(file_path: str, cwd=None):
+    if not file_path or not isinstance(file_path, str) or not file_path.strip():
+        return _r(ALLOW, 'empty file_path')
+    try:
+        path = norm_path(file_path, cwd)
+    except Exception:  # noqa: BLE001
+        return _r(DENY, 'danger: unnormalizable path')
+
+    sr = secret_reason(path)
+    if sr:
+        return _r(DENY, f'danger: write to {sr}')
+    syr = system_write_reason(path)
+    if syr:
+        return _r(DENY, f'danger: write to {syr}')
+    # 番人自身の設定は書かせない（安全境界の自己書き換えを防ぐ）。
+    # ★名前だけで決めない（ADR-014）。守るのは本物の場所（~/.claude と 各現場の .claude）で、
+    #   使い捨ての作業場（/tmp などの下）に職人が作った同じ名前は止めない。
+    #   既定は守る側＝使い捨てだと確実に言えるときだけ通す（本物の場所は1つも漏れない）。
+    # ★字面だけでなく、近道(symlink)を解いた実体も見る。別名の近道
+    #   （例 /tmp/shortcut → ~/.claude）から本物へ書き込むのを塞ぐ。
+    if is_guard_settings_path(path) and not is_throwaway_path(path):
+        return _r(DENY, 'danger: write to guard settings (.claude/settings*.json)')
+    comps = [c for c in path.split('/') if c]
+    if '.tyhld' in comps:
+        return _r(DENY, 'danger: write to guard directory (.tyhld)')
+    return _r(ALLOW, 'no gate, no danger')
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 入口: ネットワーク（WebFetch）
+#   ★既定 allow。取得そのものは自走してよい。止めるのは秘密の持ち出しだが、
+#     WebFetch は URL しか持たないので、URL に秘密が載っている場合だけ deny。
+# ═════════════════════════════════════════════════════════════════════════════
+
+def decide_network(url: str):
+    if not url or not isinstance(url, str) or not url.strip():
+        return _r(ALLOW, 'empty url')
+    if _SECRET_ENV_RE.search(url):
+        return _r(DENY, 'danger: secret in url')
+    if re.search(r'[?&](token|secret|password|api_?key)=', url, re.IGNORECASE):
+        return _r(DENY, 'danger: credential in url query')
+    return _r(ALLOW, 'no gate, no danger')
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# ツール種別のディスパッチ
+# ═════════════════════════════════════════════════════════════════════════════
+WRITE_TOOLS = frozenset({'Write', 'Edit', 'MultiEdit', 'NotebookEdit'})
+
+
+def decide_event(data):
+    """PreToolUse の入力(dict) 1件を判定する。判断材料が無いものは allow（既定）。"""
+    if not isinstance(data, dict):
+        return _r(ALLOW, 'malformed hook input')
+    tool = data.get('tool_name')
+    tin = data.get('tool_input')
+    if not isinstance(tin, dict):
+        tin = {}
+
+    if tool == 'Bash':
+        return decide_bash(tin.get('command', ''))
+    if tool == 'WebFetch':
+        return decide_network(tin.get('url', ''))
+    if tool in WRITE_TOOLS:
+        fp = tin.get('file_path', '')
+        if not fp:
+            return _r(ALLOW, 'no file_path')
+        return decide_write(fp, data.get('cwd'))
+    # WebSearch / MCP / その他 … 調査や道具の呼び出しは自走してよい（既定 allow）。
+    return _r(ALLOW, 'no gate, no danger')