@tyhld/conductor 0.12.20 → 0.12.22

package/scripts/hooks/policy.py

@@ -29,9 +29,12 @@
 
 ★このモジュールは標準ライブラリだけで動き、製品固有の名前を持たない（切り出し可能）。
 """
+import fnmatch
+import glob
 import os
 import re
 import shlex
+import urllib.parse
 
 # ═════════════════════════════════════════════════════════════════════════════
 # 判定の返り値
@@ -411,9 +414,8 @@ def _under(path: str, root: str) -> bool:
 
 
 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')
+    """字面が「.claude/settings…」の形か（名前だけの判定・単体では使わない）。★一覧 GUARD_PLACES から引く。"""
+    return _site_file_match(path)
 
 
 def is_guard_settings_path(path: str) -> bool:
@@ -488,7 +490,7 @@ def split_segments(command: str):
 _HEREDOC_START_RE = re.compile(r'<<(-?)[ \t]*([\'"]?)([A-Za-z_][A-Za-z0-9_]*)\2')
 
 
-def split_commands(command: str):
+def split_commands(command: str, bodies: bool = True):
     """★本物の区切りだけで割る（便 ad6b5db9・関門の判定に使う）。
 
     【なぜ要るか（便 df4accf8 の重大発見1・便 30879701）】split_segments は引用符や
@@ -500,6 +502,8 @@ def split_commands(command: str):
         （`cat <<EOF > f` なら cat に、`cat <<EOF | psql` なら流れ込む先の psql に付く）。
       ・# から行末までの注釈は捨てる（語の頭にあるときだけ）。
       ・2>&1 / &> / >& の & は区切りではない。
+      ・bodies=False のときは、ヒアドキュメントの本文を付けずに読み飛ばす（便 2.5・止める側の
+        読み直しに使う。本文の文字をコマンドの引数と取り違えないため）。
     """
     out, cur = [], []
     pending = []          # 本文を待っているヒアドキュメント [(区切りの語, 字下げを許すか)]
@@ -556,7 +560,8 @@ def split_commands(command: str):
                         if (line.lstrip('\t') if strip_tabs else line).strip() == delim:
                             break
                         body.append(line)
-                    cur.append('\n' + '\n'.join(body))
+                    if bodies:
+                        cur.append('\n' + '\n'.join(body))
                 pending = []
             flush()
             continue
@@ -568,6 +573,10 @@ def split_commands(command: str):
             cur.append(c)
             i += 1
             continue
+        if c == '|' and i > 0 and command[i - 1] == '>':
+            cur.append(c)  # `>|`（上書きのリダイレクト）は縦棒ではない（便 2.5）
+            i += 1
+            continue
         if c in ';|&':
             flush()
             i += 1
@@ -802,7 +811,10 @@ def _wrapper_danger(command: str, depth: int = 0, cwd=None):
         hit = _rm_danger(inner)
         if hit:
             return f'{hit} ({where})'
-        for seg in split_segments(inner):
+        hit = _guard_write_scan(inner, cwd)
+        if hit:
+            return f'{hit} ({where})'
+        for seg in _real_segments(inner):
             toks = tokens_of(seg)
             v = verb_of(toks)
             hit = (_secret_danger(seg, v, toks, cwd) or _bulk_copy_danger(v, toks, cwd)
@@ -1382,12 +1394,92 @@ _API_SECRET_RE = re.compile(
     r'|/environments/[^/]+/(secrets|variables)(/|$)')
 _API_REPO_RE = re.compile(r'^repos/[^/]+/[^/]+/?$')
 
+# ─────────────────────────────────────────────────────────────────────────────
+# API で main の先端を書き換える形（DENY・便 2.5・便 fc22bc34 の要判断1）
+#   ・git/refs/heads/<保護ブランチ> の PATCH・POST・PUT・DELETE（先端の差し替え・消去）
+#   ・git/refs の POST で ref に保護ブランチを書く形
+#   ・contents の PUT・DELETE で保護ブランチのファイルを直接書く形（branch を書かない＝既定の
+#     ブランチ＝main へ書くので DENY）
+#   ・GraphQL の createCommitOnBranch・updateRefs（保護ブランチ）・updateRef（先が確かめられない）
+#   ★git/commits・git/trees を作るだけでは main は変わらない。「作って先端を差し替える一連の形」は、
+#     先端を差し替える一手（refs の書き換え）で止まる。
+#   ★書き込む先のブランチが変数（$BR・{branch}）で確かめられないときは DENY に倒す（main 直 push と同じ）。
+#   ★作業ブランチへの書き込み（branch=feat/…）は通す。
+# ─────────────────────────────────────────────────────────────────────────────
+_API_REFS_RE = re.compile(r'(^|/)git/refs(/(?P<ref>.+))?/?$')
+_API_CONTENTS_RE = re.compile(r'(^|/)contents(/|$)')
+# 本文の中の「ブランチ名」の書き方（-f branch=… / "branch":"…" / branchName:"…" / ref=refs/heads/…）。
+_BODY_BRANCH_RE = re.compile(
+    r'''["']?\b(branch|branchname|qualifiedname|ref|name)["']?\s*[:=]\s*["']?([^\s"',{}\\)]+)''')
+
+
+def _branch_state(name: str) -> str:
+    """ブランチ名（refs/heads/ 付きも）が 'protected' / 'unknown' / 'ok' のどれか。"""
+    n = name.strip().strip('"\'')
+    for pre in ('refs/heads/', 'heads/'):
+        if n.startswith(pre):
+            n = n[len(pre):]
+            break
+    if not n or any(c in n for c in '$`{}'):
+        return 'unknown'
+    return 'protected' if n in PROTECTED_BRANCHES else 'ok'
+
+
+def _body_branches(body_low: str, keys):
+    return [m.group(2) for m in _BODY_BRANCH_RE.finditer(body_low or '') if m.group(1) in keys]
+
+
+def _main_tip_write(ep: str, method: str, body_low: str):
+    """API で保護ブランチの先端を書き換える形なら理由。"""
+    m = _API_REFS_RE.search(ep)
+    if m:
+        ref = m.group('ref')
+        if ref:
+            if ref.startswith('heads/') or '$' in ref or '{' in ref:
+                st = _branch_state(ref)
+                if st == 'protected':
+                    return f'API で保護ブランチの先端を書き換える ({method} git/refs/{ref})'
+                if st == 'unknown':
+                    return f'API で先端を書き換える (git/refs/{ref}・書き込む先を確かめられない)'
+            return None
+        if method == 'POST':
+            refs = _body_branches(body_low, ('ref',))
+            states = {_branch_state(r) for r in refs if r.startswith(('refs/heads/', '$', '{'))}
+            if not refs or 'protected' in states or 'unknown' in states:
+                return 'API で保護ブランチの ref を作る (POST git/refs・書き込む先が保護か確かめられない)'
+        return None
+    if _API_CONTENTS_RE.search(ep) and method in ('PUT', 'DELETE'):
+        branches = _body_branches(body_low, ('branch',))
+        if not branches:
+            return f'API でファイルを既定のブランチへ直接書く ({method} contents・branch の指定なし)'
+        states = {_branch_state(b) for b in branches}
+        if 'protected' in states:
+            return f'API で保護ブランチのファイルを直接書く ({method} contents)'
+        if 'unknown' in states:
+            return f'API でファイルを直接書く ({method} contents・書き込む先を確かめられない)'
+        return None
+    if ep.rstrip('/') == 'graphql':
+        if 'updateref(' in re.sub(r'\s', '', body_low):
+            return 'GraphQL の updateRef (先端の書き換え・書き込む先を確かめられない)'
+        for mut, keys in (('createcommitonbranch', ('branchname', 'qualifiedname', 'branch')),
+                          ('updaterefs', ('name', 'branchname', 'qualifiedname'))):
+            if mut in body_low:
+                names = _body_branches(body_low, keys)
+                states = {_branch_state(b) for b in names}
+                if not names or 'protected' in states or 'unknown' in states:
+                    return f'GraphQL の {mut} (保護ブランチの先端の書き換え・または確かめられない)'
+    return None
+
 
 def _github_api_write(endpoint: str, method: str, body_low: str):
     """GitHub の API への書き込み1件が抜け道なら理由を返す（読み取りは通す）。"""
     ep = re.sub(r'^https?://api\.github\.com/', '', endpoint.strip()).lstrip('/').split('?')[0]
+    ep = urllib.parse.unquote(ep)
     if method in ('GET', 'HEAD'):
         return None
+    hit = _main_tip_write(ep, method, body_low)
+    if hit:
+        return hit
     if _API_MERGE_RE.search(ep) and method in ('PUT', 'POST'):
         return 'API での合流 (pulls/N/merge・保護を迂回する合流)'
     if ep.rstrip('/') == 'graphql' and 'mergepullrequest' in body_low:
@@ -1530,26 +1622,35 @@ def _bypass_segment_danger(seg, tokens, cwd, command):
     return None
 
 
+def _cd_dest(toks, here):
+    """`cd 場所` の後の作業場所。変数・`cd -`・分からないときは _UNKNOWN_DIR。"""
+    after = toks[toks.index('cd') + 1:] if 'cd' in toks else []
+    dest = next((t for t in after if t != '--'), '~')
+    p = os.path.expanduser(dest)
+    if dest == '-' or any(c in dest for c in '$`*?') or here is _UNKNOWN_DIR:
+        return _UNKNOWN_DIR
+    if os.path.isabs(p):
+        return p
+    return os.path.join(here or os.getcwd(), p)
+
+
 def _bypass_scan(command: str, cwd=None):
-    """コマンド全体の抜け道を探す。★`cd 場所` を追って、後ろの push の作業場所に使う。"""
-    here = cwd
-    for seg in split_segments(command):
-        toks = tokens_of(seg)
-        v = verb_of(toks)
-        if v == 'cd':
-            after = toks[toks.index('cd') + 1:] if 'cd' in toks else []
-            dest = next((t for t in after if t != '--'), '~')
-            p = os.path.expanduser(dest)
-            if dest == '-' or any(c in dest for c in '$`*?') or here is _UNKNOWN_DIR:
-                here = _UNKNOWN_DIR
-            elif os.path.isabs(p):
-                here = p
-            else:
-                here = os.path.join(here or os.getcwd(), p)
-            continue
-        hit = _bypass_segment_danger(seg, toks, here, command) or _main_push_danger(toks, here)
-        if hit:
-            return hit
+    """コマンド全体の抜け道を探す。★`cd 場所` を追って、後ろの push の作業場所に使う。
+
+    ★機械的な区切りで1回、本物の区切り（本文なし）でもう1回測る（便 2.5）。複数行の引用符の
+      中に書いた GraphQL の本文などを、ひとかたまりのまま読むため。止める側は減らない。
+    """
+    for segs in (split_segments(command), split_commands(command, bodies=False)):
+        here = cwd
+        for seg in segs:
+            toks = tokens_of(seg)
+            v = verb_of(toks)
+            if v == 'cd':
+                here = _cd_dest(toks, here)
+                continue
+            hit = _bypass_segment_danger(seg, toks, here, command) or _main_push_danger(toks, here)
+            if hit:
+                return hit
     return None
 
 
@@ -1689,7 +1790,9 @@ def _secret_danger(segment: str, verb: str, tokens, cwd=None):
             #   コミットメッセージや説明文に .env と書いただけで止まる（実際に止まった）。
             #   その代わり、未知の道具に秘密を渡す形（`mytool .env`）は素通りする＝
             #   限界として README に明記してある。
-            if verb in READ_VERBS or verb in WRITE_VERBS or verb in EXFIL_VERBS:
+            # ★探す道具（rg・ag・ack・ugrep …）も中身を画面に出す＝読む（便 2.5・`rg "a|b" .env`）。
+            if verb in READ_VERBS or verb in WRITE_VERBS or verb in EXFIL_VERBS \
+                    or verb in _PATTERN_FIRST_VERBS:
                 return f'{sr} touched by {verb}'
         if verb in WRITE_VERBS or is_inplace_edit(verb, tokens):
             syr = system_write_reason(a)
@@ -1707,6 +1810,936 @@ def _secret_danger(segment: str, verb: str, tokens, cwd=None):
     return None
 
 
+def _real_segments(command: str):
+    """止める側の読み直しに使う区切り（便 2.5）。機械的な区切りに、本物の区切りを【足す】。
+
+    ★機械的な区切り（split_segments）は1件も外さない＝止める側は減らない。
+    ★本物の区切り（split_commands・本文なし）を足すと、引用符の中の `|` `;` で動詞が千切れた
+      コマンド（`grep -n "x|y" .env` → `y" .env` という切れ端）も、正しい動詞で測り直せる。
+    """
+    segs = split_segments(command)
+    seen = set(segs)
+    for s in split_commands(command, bodies=False):
+        if s not in seen:
+            seen.add(s)
+            segs.append(s)
+    return segs
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# 番人の設定を弱める書き込み（DENY・便 2.5 → 便 2.6 で「手段を問わず」へ・えふさん確定 2026-09-18）
+#
+# 【目的】職人から、番人・guard・hook・管理設定そのものを弱める変更をできないようにする。
+#   「見つかった1構文を禁止」ではなく、別の書き込み手段・別のシェルの書き方に置き換えても
+#   同じことができないところまで塞ぐ（便 2.6）。
+# 【守る場所】GUARD_PLACES の一覧だけ（★場所を2か所に書かない）。Bash・Write・プログラムの中・
+#   置き場ごとの操作は、どれもこの一覧から引いた判定（guard_config_reason / guard_ancestor_reason）を通る。
+# 【どう見るか】道具の名前ではなく「書き込む行為」でそろえる。1コマンドごとに
+#   ① 包み（env・sudo・nohup・time・xargs・exec・timeout …・サブシェルの括弧・if/for/do）を剥がし、
+#   ② 書き込む先（リダイレクト・道具ごとの書き込み先・展開の行き先・ダウンロードの行き先 …）を集め、
+#   ③ 先に決めた変数・~・$HOME・${HOME}・相対の道・波括弧・* を解いてから、一覧と照らす。
+#   ④ 中身を走らせる形（bash -c・eval・<<<・ヒアドキュメント・$(…)・`…`・find -exec）は中身を測り直す。
+# 【止めないもの】読むだけ（cat・less・grep・rg・diff・jq・ls・stat・git status・外へ写す cp）。
+#   使い捨ての作業場（/tmp の下）に作った同じ名前（Write と同じ例外 is_throwaway_path）。
+#   報告やコミットの説明に場所の名前が書いてあるだけ（引用符の中の `>` も書き込みと読まない）。
+# ═════════════════════════════════════════════════════════════════════════════
+
+#: ★守る場所の一覧（ここだけ）。(種類, 場所)
+#:   site-file  … どの .claude フォルダでも、この名前で始まるファイル（ホームと各現場の settings.json・
+#:                settings.local.json。Write が前から守っていた settings* の広さのまま）
+#:   home-tree  … ホームからの置き場（中身ぜんぶ）
+#:   home-agent … ホーム直下の隠しフォルダに置かれた、この名前のファイル。道具の番人の登録と設定。
+#:                ★道具の名前を持たない一般の形（番人の判定に道具名を持ち込まない決め・ADR-022）。
+#:   abs-tree   … 絶対パスの置き場（管理設定＝managed settings）
+GUARD_PLACES = (
+    ('site-file', '.claude/settings'),
+    ('home-tree', '.claude/skills'),
+    ('home-tree', '.tyhld/hooks'),
+    ('home-tree', '.tyhld/bin'),
+    ('home-tree', '.config/systemd'),
+    ('home-agent', 'hooks.json'),
+    ('home-agent', 'config.toml'),
+    ('abs-tree', '/etc/claude-code'),
+    ('abs-tree', '/Library/Application Support/ClaudeCode'),
+)
+
+
+def _places(kind):
+    return tuple(p for k, p in GUARD_PLACES if k == kind)
+
+
+def _site_file_match(path: str) -> bool:
+    """字面が「<どこか>/.claude/settings…」の形か（一覧の site-file から引く・名前だけの判定）。"""
+    comps = [c for c in path.replace('\\', '/').split('/') if c]
+    for p in _places('site-file'):
+        d, name = p.split('/')
+        if len(comps) >= 2 and comps[-2] == d and comps[-1].startswith(name):
+            return True
+    return False
+
+
+def _expand_path(path: str, cwd=None) -> str:
+    """字面のパスを、近道を解かずに絶対パスへ（$HOME・${HOME}・~・相対を解く）。"""
+    q = normalize_redirect_target(path)
+    for var in ('${HOME}', '$HOME'):
+        if q == var or q.startswith(var + '/'):
+            q = os.path.expanduser('~') + q[len(var):]
+            break
+    q = os.path.expanduser(q)
+    if not os.path.isabs(q):
+        base = cwd if (isinstance(cwd, str) and os.path.isabs(cwd)) else os.getcwd()
+        q = os.path.join(base, q)
+    return os.path.normpath(q)
+
+
+def _homes():
+    return {h for h in (os.path.expanduser('~').rstrip('/'), _home_dir().rstrip('/')) if h}
+
+
+def _home_rels(abs_paths):
+    """絶対パスたちの、ホームからの相対（ホームの外は落とす）。字面のホームと実体のホームの両方。"""
+    out = []
+    for p in abs_paths:
+        for h in _homes():
+            if p.startswith(h + '/'):
+                out.append(p[len(h) + 1:])
+    return out
+
+
+def _place_reason_abs(p: str):
+    """絶対パス1つ（解いた後）が一覧の場所か。"""
+    if _site_file_match(p) and not is_throwaway_path(p):
+        return 'guard settings (.claude/settings*.json)'
+    for root in _places('abs-tree'):
+        if p == root or p.startswith(root + '/'):
+            return f'managed settings ({root})'
+    for rel in _home_rels((p,)):
+        for d in _places('home-tree'):
+            if rel == d or rel.startswith(d + '/'):
+                return f'guard directory (~/{d})'
+        parts = rel.split('/')
+        if len(parts) == 2 and parts[0].startswith('.') and parts[1] in _places('home-agent'):
+            return f'agent hook settings (~/{rel})'
+    return None
+
+
+# 解けない変数・コマンド置換（$X・${X}・$(…)・`…`）。この後ろの字面だけで一覧と照らす。
+_UNRESOLVED_RE = re.compile(r'\$\{[^}]*\}|\$\([^)]*\)|`[^`]*`|\$[A-Za-z_][A-Za-z0-9_]*')
+_GLOB_CHARS_RE = re.compile(r'[*?\[]')
+
+
+def _tail_reason(tail: str):
+    """解けない部分の後ろの字面（例 `/.tyhld/hooks/p.py`）が、一覧のどこかの形か。"""
+    if _site_file_match(tail):
+        return 'guard settings (.claude/settings*.json)'
+    for d in _places('home-tree'):
+        if ('/' + d + '/') in tail or tail.endswith('/' + d) or tail.startswith(d + '/'):
+            return f'guard directory (~/{d})'
+    for root in _places('abs-tree'):
+        if tail.startswith(root):
+            return f'managed settings ({root})'
+    m = re.search(r'/\.[^/]+/([^/]+)$', tail)
+    if m and m.group(1) in _places('home-agent'):
+        return f'agent hook settings ({m.group(0)})'
+    return None
+
+
+def _concrete_places(cwd=None):
+    """一覧から作る、実際の場所の例（* を含む書き方と照らすため）。"""
+    out = []
+    for h in _homes():
+        out += [os.path.join(h, '.claude', 'settings.json'), os.path.join(h, '.claude', 'settings.local.json')]
+        out += [os.path.join(h, d) for d in _places('home-tree')]
+        for name in _places('home-agent'):
+            out += glob.glob(os.path.join(h, '.*', name))
+    base = cwd if (isinstance(cwd, str) and os.path.isabs(cwd)) else os.getcwd()
+    out += [os.path.join(base, '.claude', 'settings.json'), os.path.join(base, '.claude', 'settings.local.json')]
+    out += list(_places('abs-tree'))
+    return out
+
+
+def guard_config_reason(path: str, cwd=None):
+    """書き込むと番人の設定が変わる場所なら理由、そうでなければ None（★読むだけには使わない）。
+
+    ★字面と、近道(symlink)を解いた実体の両方を見る（別名から本物へ書くのを塞ぐ）。
+    ★解けない変数（$D/.tyhld/hooks/…）は後ろの字面で照らす。* を含む書き方は、実在の一致と、
+      一覧の場所の例との一致の両方で照らす（確かめられないものは守る側）。
+    """
+    if not path or not path.strip():
+        return None
+    try:
+        lit = _expand_path(path, cwd)
+        real = resolved_path(lit)
+    except Exception:  # noqa: BLE001
+        return None
+    for p in (lit, real):
+        r = _place_reason_abs(p)
+        if r:
+            return r
+    if _UNRESOLVED_RE.search(lit):
+        r = _tail_reason(_UNRESOLVED_RE.split(lit)[-1])
+        if r:
+            return r
+    if _GLOB_CHARS_RE.search(lit):
+        try:
+            hits = glob.glob(lit)
+        except Exception:  # noqa: BLE001
+            hits = []
+        for h in hits[:200]:
+            r = _place_reason_abs(os.path.normpath(h))
+            if r:
+                return r
+        pc = lit.split('/')
+        for c in _concrete_places(cwd):
+            cc = c.split('/')
+            is_tree = _place_reason_abs(c + '/x') is not None and not _site_file_match(c)
+            if len(pc) == len(cc) or (is_tree and len(pc) > len(cc)):
+                if fnmatch.fnmatchcase(c, '/'.join(pc[:len(cc)])):
+                    r = _place_reason_abs(c) or _place_reason_abs(c + '/x')
+                    if r:
+                        return r
+    return None
+
+
+def guard_ancestor_reason(path: str, cwd=None):
+    """一覧の場所を【中に持つ】置き場（消す・動かす・フォルダごと写し込む・展開すると設定が変わる）。
+
+    ホームそのもの・~/.claude・~/.tyhld・~/.config・各現場の .claude・管理設定の親・
+    ホーム直下の隠しフォルダで一覧の名前のファイルを持つもの。
+    """
+    try:
+        lit = _expand_path(path, cwd)
+        real = resolved_path(lit)
+    except Exception:  # noqa: BLE001
+        return None
+    for p in (lit, real):
+        p = p.rstrip('/') or '/'
+        if p in _homes():
+            return 'guard settings folder (~)'
+        site_dirs = {sf.split('/')[0] for sf in _places('site-file')}
+        if p.split('/')[-1] in site_dirs and not is_throwaway_path(p):
+            return f'guard settings folder ({p.split("/")[-1]})'
+        for root in _places('abs-tree'):
+            if root.startswith(p + '/') or p == '/':
+                return f'managed settings folder ({root})'
+        for rel in _home_rels((p,)):
+            if any(d.startswith(rel + '/') for d in _places('home-tree')):
+                return f'guard settings folder (~/{rel})'
+            if '/' not in rel and rel.startswith('.') and any(
+                    os.path.exists(os.path.join(os.path.expanduser('~'), rel, n))
+                    for n in _places('home-agent')):
+                return f'agent hook settings folder (~/{rel})'
+    return None
+
+
+def _contains_guard(path: str, cwd=None):
+    """展開先として危ない置き場か（一覧の場所そのもの・親・中に .claude フォルダを持つ場所）。"""
+    r = guard_config_reason(path, cwd) or guard_ancestor_reason(path, cwd)
+    if r:
+        return r
+    try:
+        lit = _expand_path(path, cwd)
+    except Exception:  # noqa: BLE001
+        return None
+    for sf in _places('site-file'):
+        if os.path.isdir(os.path.join(lit, sf.split('/')[0])):
+            return f'folder holding {sf.split("/")[0]} settings'
+    return None
+
+
+# リダイレクトの記号（語の頭に付いたもの）。`2>&1` `>&2` のような写しは書き込みではない。
+_REDIRECT_TOKEN_RE = re.compile(r'^\d*(>>|>\||&>>|&>|>&|<>|>|<<<|<<-?|<)')
+#: 書き込む先が「最後の引数（か -t の値）」の道具。それより前は読むだけ。
+_COPY_VERBS = frozenset({'cp', 'install', 'ln', 'rsync', 'ditto', 'scp', 'gcp'})
+#: 引数ぜんぶが書き換え・削除・権限変更の対象になる道具（エディタで開いて保存する形も含む）。
+_TOUCH_ALL_VERBS = frozenset({
+    'tee', 'rm', 'rmdir', 'shred', 'truncate', 'touch', 'chmod', 'chown', 'chgrp', 'chattr',
+    'setfacl', 'patch', 'sponge', 'unlink', 'mkdir', 'ed', 'ex', 'vi', 'vim', 'nvim', 'nano',
+    'pico', 'emacs', 'mcedit', 'micro',
+})
+#: 置き場ごと消す・権限を変える道具（引数が一覧の場所の親でも止める）。
+_PARENT_VERBS = frozenset({'rm', 'rmdir', 'shred', 'unlink', 'chmod', 'chown', 'chgrp', 'chattr', 'setfacl'})
+#: その場で書き換える旗を持つ道具（sed -i・perl -i・ruby -i・yq -i・awk -i inplace）。
+_INPLACE_VERBS = frozenset({'sed', 'gsed', 'perl', 'ruby', 'yq', 'awk', 'gawk'})
+_AWK_VERBS = frozenset({'awk', 'gawk', 'mawk', 'nawk'})
+#: 圧縮を解いて、同じ場所に元の名前で書き出す道具。
+_DECOMPRESS_VERBS = {'gunzip': '.gz', 'unpigz': '.gz', 'bunzip2': '.bz2', 'unxz': '.xz', 'unzstd': '.zst',
+                     'unlzma': '.lzma'}
+#: systemctl --user の、~/.config/systemd の中を書き換える操作。
+_SYSTEMCTL_WRITE = frozenset({
+    'enable', 'disable', 'reenable', 'edit', 'link', 'mask', 'unmask', 'revert', 'preset',
+    'set-property', 'add-wants', 'add-requires',
+})
+#: 包み（前置き）と、その値を1つ取る旗。剥がして中の道具を見る。
+_GUARD_WRAPPERS = {
+    'env': {'-u', '--unset', '-C', '--chdir'}, 'sudo': {'-u', '-g', '-C', '-D', '-h', '-p', '-r', '-t', '-U', '-T'},
+    'doas': {'-u', '-C'}, 'nohup': set(), 'time': {'-f', '-o'}, 'command': set(), 'builtin': set(),
+    'exec': {'-a'}, 'stdbuf': {'-i', '-o', '-e'}, 'setsid': set(), 'timeout': {'-s', '-k', '--signal', '--kill-after'},
+    'nice': {'-n', '--adjustment'}, 'ionice': {'-c', '-n', '-p'}, 'chronic': set(), 'unbuffer': set(),
+    'xargs': {'-I', '-i', '-n', '-P', '-d', '-a', '-E', '-L', '-s', '--max-args', '--max-procs', '--delimiter',
+              '--arg-file', '--replace', '--max-lines', '--max-chars'},
+    'flock': {'-w', '-E', '--timeout', '--conflict-exit-code'},
+    'busybox': set(), 'toybox': set(),  # 多機能の道具（`busybox sed -i …` の中の道具を見る）
+}
+# 文の頭に付く予約語（if/then/do …）とサブシェルの括弧。
+_SHELL_KEYWORDS = frozenset({'if', 'then', 'else', 'elif', 'do', 'while', 'until', '!', '{', '(', 'time'})
+
+
+def _real_redirect_targets(segment: str):
+    """引用符の外にある本物のリダイレクトの書き込み先（`>` `>>` `>|` `&>` `<>`）。"""
+    out = []
+    head = segment.split('\n', 1)[0] if '<<' in segment else segment
+    quote = None
+    i, n = 0, len(head)
+    while i < n:
+        c = head[i]
+        if quote:
+            if c == '\\' and quote == '"':
+                i += 2
+                continue
+            if c == quote:
+                quote = None
+            i += 1
+            continue
+        if c == '\\':
+            i += 2
+            continue
+        if c in '"\'`':
+            quote = c
+            i += 1
+            continue
+        if c != '>':
+            i += 1
+            continue
+        j = i + 1
+        if j < n and head[j] in '>|':
+            j += 1
+        if j < n and head[j] in '&(':
+            i = j + 1  # `>&2` / `2>&1`（写し）・`>(…)`（プロセス置換・中身は別に測る）は書き込み先ではない
+            continue
+        while j < n and head[j] in ' \t':
+            j += 1
+        k, q, depth = j, None, 0
+        while k < n:
+            ch = head[k]
+            if q:
+                if ch == q:
+                    q = None
+            elif ch in '"\'':
+                q = ch
+            elif ch == '`':
+                nb = head.find('`', k + 1)  # `…` はひとかたまり
+                k = nb if nb > k else n
+            elif ch == '$' and k + 1 < n and head[k + 1] == '(':
+                depth += 1
+                k += 1
+            elif ch == '(' and depth:
+                depth += 1
+            elif ch == ')' and depth:
+                depth -= 1
+            elif depth == 0 and ch in ' \t;|&<>()':
+                break
+            k += 1
+        word = head[j:k].replace('"', '').replace("'", '')
+        if word:
+            out.append(word)
+        i = k
+    return out
+
+
+def _plain_args(tokens, start):
+    """動詞より後ろの、リダイレクトを除いた引数。"""
+    out, skip = [], False
+    for t in tokens[start:]:
+        if skip:
+            skip = False
+            continue
+        m = _REDIRECT_TOKEN_RE.match(t)
+        if m:
+            if m.end() == len(t):
+                skip = True
+            continue
+        out.append(t)
+    return out
+
+
+def _unwrap(tokens):
+    """包み・変数代入・予約語を剥がした、道具の位置と、通った包みの名前の集合。"""
+    i, seen = 0, set()
+    while i < len(tokens):
+        t = tokens[i]
+        if t in _SHELL_KEYWORDS or _ASSIGN_RE.match(t):
+            i += 1
+            continue
+        base = t.split('/')[-1]
+        if base in _GUARD_WRAPPERS:
+            seen.add(base)
+            vals = _GUARD_WRAPPERS[base]
+            i += 1
+            while i < len(tokens) and tokens[i].startswith('-') and tokens[i] != '--':
+                i += 2 if tokens[i] in vals else 1
+            if i < len(tokens) and tokens[i] == '--':
+                i += 1
+            if base == 'env':
+                while i < len(tokens) and _ASSIGN_RE.match(tokens[i]):
+                    i += 1
+            if base in ('timeout', 'flock') and i < len(tokens):
+                i += 1  # 時間・鍵のファイル
+            if base in ('nice', 'ionice') and i < len(tokens) and tokens[i].lstrip('-').isdigit():
+                i += 1
+            continue
+        return i, seen
+    return len(tokens), seen
+
+
+def _brace_variants(word: str, limit: int = 64):
+    """`a/{b,c}.json` → [a/b.json, a/c.json]（入れ子なし・数に上限）。"""
+    out = [word]
+    for _ in range(4):
+        nxt = []
+        changed = False
+        for w in out:
+            m = re.search(r'\{([^{}]*,[^{}]*)\}', w)
+            if not m:
+                nxt.append(w)
+                continue
+            changed = True
+            for part in m.group(1).split(','):
+                nxt.append(w[:m.start()] + part + w[m.end():])
+        out = nxt[:limit]
+        if not changed:
+            break
+    return out
+
+
+def _normalize_segment(seg: str) -> str:
+    """サブシェルの括弧・波括弧の組・行頭の予約語を剥がす（`(cd ~/.claude && rm x)` の形）。"""
+    s = seg.strip()
+    while s[:1] in ('(', '{') and (len(s) == 1 or s[1] in ' \t(' or s[0] == '('):
+        s = s[1:].lstrip()
+    if s.endswith(')') and s.count(')') > s.count('('):
+        s = s[:-1].rstrip()
+    if s.endswith('}') and (s.endswith(' }') or s.endswith(';}')):
+        s = s[:-1].rstrip()
+    return s
+
+
+def _subst_payloads(text: str):
+    """コマンド置換・プロセス置換の中身（`$(…)`・`` `…` ``・`<(…)`・`>(…)`）。単引用符の中は除く。"""
+    out = []
+    i, n, quote = 0, len(text), None
+    while i < n:
+        c = text[i]
+        if quote == "'":
+            if c == "'":
+                quote = None
+            i += 1
+            continue
+        if c == "'" and quote is None:
+            quote = "'"
+            i += 1
+            continue
+        if c == '"':
+            quote = None if quote == '"' else '"'
+            i += 1
+            continue
+        if c == '`':
+            j = text.find('`', i + 1)
+            if j > i:
+                out.append(text[i + 1:j])
+                i = j + 1
+                continue
+        if c in '$<>' and i + 1 < n and text[i + 1] == '(' and not text.startswith('$((', i):
+            depth, j = 0, i + 1
+            while j < n:
+                if text[j] == '(':
+                    depth += 1
+                elif text[j] == ')':
+                    depth -= 1
+                    if depth == 0:
+                        break
+                j += 1
+            out.append(text[i + 2:j])
+            i = j + 1
+            continue
+        i += 1
+    return out
+
+
+def _heredoc_body(head: str, command: str):
+    """このコマンドの頭に書かれたヒアドキュメントの本文（無ければ None）。"""
+    m = _HEREDOC_START_RE.search(head)
+    if not m or m.group(0) not in command:
+        return None
+    body = _HEREDOC_RE.search(command[command.find(m.group(0)):])
+    return body.group(2) if body else None
+
+
+def _here_string(tokens):
+    for k, t in enumerate(tokens):
+        if t == '<<<' and k + 1 < len(tokens):
+            return tokens[k + 1]
+        if t.startswith('<<<') and len(t) > 3:
+            return t[3:]
+    return None
+
+
+def _archive_members(verb, archive, cwd=None):
+    """展開する物の中の名前（読めないときは None＝確かめられない）。★名前だけを読む（中身は開かない）。"""
+    if not archive or archive == '-':
+        return None
+    try:
+        import tarfile
+        import zipfile
+        p = _expand_path(archive, cwd)
+        if verb == 'unzip' or zipfile.is_zipfile(p):
+            with zipfile.ZipFile(p) as z:
+                return z.namelist()[:5000]
+        with tarfile.open(p) as t:
+            return t.getnames()[:5000]
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _patch_targets(tokens, args, head, command, cwd):
+    """patch・git apply が書き換えるファイル（差分の `+++ ` 行・名指しのファイル）。"""
+    strip = 0
+    for k, a in enumerate(args):
+        m = re.match(r'^-p(\d+)$', a) or (re.match(r'^--strip=(\d+)$', a))
+        if m:
+            strip = int(m.group(1))
+        elif a == '-p' and k + 1 < len(args) and args[k + 1].isdigit():
+            strip = int(args[k + 1])
+    text = _heredoc_body(head, command) or ''
+    src = None
+    for k, t in enumerate(tokens):
+        if t == '<' and k + 1 < len(tokens):
+            src = tokens[k + 1]
+        elif t in ('-i', '--input') and k + 1 < len(tokens):
+            src = tokens[k + 1]
+    if src:
+        try:
+            with open(_expand_path(src, cwd), encoding='utf-8', errors='replace') as fh:
+                text += '\n' + fh.read(400000)
+        except Exception:  # noqa: BLE001
+            pass
+    out = []
+    for line in text.splitlines():
+        if line.startswith('+++ ') or line.startswith('--- '):
+            name = line[4:].split('\t')[0].strip()
+            if name == '/dev/null':
+                continue
+            parts = name.split('/')
+            out.append('/'.join(parts[strip:]) if strip else name)
+    return out
+
+
+def _find_danger(args, cwd):
+    """find の探す場所に一覧の場所が入り、消す・書き換える・書き出す形なら理由。"""
+    roots = []
+    for a in args:
+        if a.startswith('-') or a in ('(', ')', '!'):
+            break
+        roots.append(a)
+    roots = roots or ['.']
+    acts = set(a for a in args if a in ('-delete', '-exec', '-execdir', '-ok', '-okdir', '-fprint', '-fprintf',
+                                         '-fls', '-fprint0'))
+    if not acts:
+        return None
+    for k, a in enumerate(args):
+        if a in ('-fprint', '-fprintf', '-fls', '-fprint0') and k + 1 < len(args):
+            r = guard_config_reason(args[k + 1], cwd)
+            if r:
+                return f'{r} written by find {a}'
+    writes = '-delete' in acts
+    for k, a in enumerate(args):
+        if a in ('-exec', '-execdir', '-ok', '-okdir') and k + 1 < len(args):
+            inner = []
+            for t in args[k + 1:]:
+                if t in (';', '+', '\\;'):
+                    break
+                inner.append(t)
+            pos, _ = _unwrap(inner)
+            v = inner[pos].split('/')[-1] if pos < len(inner) else ''
+            if v in _TOUCH_ALL_VERBS or v in _COPY_VERBS or v == 'mv' or v in _INPLACE_VERBS or v in _SHELL_RUNNERS:
+                writes = True
+    if not writes:
+        return None
+    names = [args[k + 1] for k, a in enumerate(args) if a in ('-name', '-iname', '-path', '-ipath', '-wholename')
+             and k + 1 < len(args)]
+    for root in roots:
+        places = []
+        if guard_config_reason(root, cwd):
+            return f'{guard_config_reason(root, cwd)} changed by find'
+        if guard_ancestor_reason(root, cwd) or _contains_guard(root, cwd):
+            base = _expand_path(root, cwd)
+            places = [c for c in _concrete_places(base) if c.startswith(base.rstrip('/') + '/')]
+        for c in places:
+            if not names or any(fnmatch.fnmatchcase(os.path.basename(c), n) or fnmatch.fnmatchcase(c, '*' + n)
+                                for n in names):
+                return f'{_place_reason_abs(c) or "guard settings"} changed by find'
+    return None
+
+
+def _git_write_targets(args, cwd):
+    """git の、作業場所のファイルを上書きする形の書き込み先（checkout/restore の道・clone/worktree の行き先）。"""
+    where, rest = cwd, list(args)
+    while rest and rest[0].startswith('-'):
+        f = rest.pop(0)
+        if f == '-C' and rest:
+            p = rest.pop(0)
+            where = _expand_path(p, where)
+        elif f in ('-c', '--git-dir', '--work-tree') and rest:
+            rest.pop(0)
+    if not rest:
+        return where, []
+    sub, sargs = rest[0], rest[1:]
+    if sub in ('checkout', 'restore'):
+        if '--' in sargs:
+            paths = sargs[sargs.index('--') + 1:]
+        else:
+            vals = {'-s', '--source', '-b', '-B', '--orphan', '--conflict'}
+            paths, skip = [], False
+            for t in sargs:
+                if skip:
+                    skip = False
+                    continue
+                if t in vals:
+                    skip = True
+                    continue
+                if not t.startswith('-'):
+                    paths.append(t)
+        return where, paths
+    if sub in ('apply', 'am'):
+        return where, ['__patch__']
+    if sub == 'clone':
+        pos = [t for t in sargs if not t.startswith('-')]
+        return where, pos[1:2]
+    if sub == 'worktree' and sargs[:1] == ['add']:
+        pos = [t for t in sargs[1:] if not t.startswith('-')]
+        return where, pos[:1]
+    return where, []
+
+
+def _guard_write_segment(segment: str, cwd=None, command='', depth=0, env=None):
+    """本物の1コマンドが番人の設定を書き換えるなら理由。"""
+    segment = _normalize_segment(segment)
+    for t in _real_redirect_targets(segment):
+        for v in _brace_variants(t):
+            r = guard_config_reason(v, cwd)
+            if r:
+                return f'redirect into {r}'
+    head = segment.split('\n', 1)[0] if '<<' in segment else segment
+    # ★コマンド置換・プロセス置換の中身も、1つのコマンドとして測り直す。
+    if depth < _UNWRAP_MAX_DEPTH + 1:
+        for inner in _subst_payloads(head):
+            hit = _guard_write_scan(inner, cwd, depth + 1, env)
+            if hit:
+                return f'{hit} (inside $(…))'
+    tokens = tokens_of(head)
+    pos, wrappers = _unwrap(tokens)
+    if pos >= len(tokens):
+        return None
+    verb = tokens[pos].split('/')[-1]
+    args = _plain_args(tokens, pos + 1)
+    paths = [a for a in args if not a.startswith('-')]
+    targets, parents = [], []
+
+    # ── 中身を走らせる形（シェル・eval・<<<・ヒアドキュメント・プログラム） ──
+    if verb in _SHELL_RUNNERS or verb in ('eval', 'source', '.'):
+        if depth <= _UNWRAP_MAX_DEPTH:
+            payloads = []
+            if verb == 'eval':
+                payloads.append(' '.join(args))
+            payloads += [tokens[k + 1] for k, t in enumerate(tokens) if t in _CODE_FLAGS and k + 1 < len(tokens)]
+            for extra in (_here_string(tokens), _heredoc_body(head, command)):
+                if extra:
+                    payloads.append(extra)
+            for p in payloads:
+                hit = _guard_write_scan(p, cwd, depth + 1)
+                if hit:
+                    return f'{hit} (inside {verb})'
+        return None
+    if verb in _CODE_RUNNERS:
+        codes = [tokens[k + 1] for k, t in enumerate(tokens) if t in _CODE_FLAGS and k + 1 < len(tokens)]
+        for extra in (_here_string(tokens), _heredoc_body(head, command)):
+            if extra:
+                codes.append(extra)
+        for code in codes:
+            hit = _code_guard_write(code, cwd)
+            if hit:
+                return f'{hit} (inside {verb})'
+        if not (verb in ('perl', 'ruby') and any(re.match(r'^-[a-zA-Z]*i', a) for a in args)):
+            return None
+
+    # ── 書き込む先を集める（道具ごと） ──
+    if verb in _TOUCH_ALL_VERBS:
+        targets = paths
+        if verb in _PARENT_VERBS:
+            parents = paths
+        if verb == 'patch':
+            targets = targets + _patch_targets(tokens, args, head, command, cwd)
+    elif verb == 'mv':
+        targets = parents = paths  # 動かす元も、動かした先も変わる
+    elif verb in _COPY_VERBS:
+        dest = None
+        for k, a in enumerate(args):
+            if a in ('-t', '--target-directory') and k + 1 < len(args):
+                dest = args[k + 1]
+            elif a.startswith('--target-directory='):
+                dest = a.split('=', 1)[1]
+        if verb == 'install' and '-d' in args:
+            targets = paths
+        else:
+            srcs = [p for p in paths if p != dest]
+            if dest is None and paths:
+                dest, srcs = paths[-1], paths[:-1]
+            if dest and ':' in dest.split('/')[0] and verb in ('scp', 'rsync'):
+                dest = None  # 別の機械への書き込み（ここは見ない）
+            if dest:
+                base = _expand_path(dest, cwd)
+                targets = [dest] + [os.path.join(base, os.path.basename(s.rstrip('/'))) for s in srcs if s.rstrip('/')]
+                recursive = any(a in ('-r', '-R', '--recursive', '-a', '--archive')
+                                or (re.match(r'^-[A-Za-z]+$', a) and ('r' in a or 'R' in a or 'a' in a))
+                                for a in args)
+                if recursive or verb in ('rsync', 'ln', 'ditto'):
+                    parents = [dest]
+    elif verb == 'dd':
+        targets = [a[3:] for a in args if a.startswith('of=')]
+    elif verb in _INPLACE_VERBS and (
+            is_inplace_edit('sed' if verb in ('gsed', 'yq') else verb, tokens[pos:])
+            or any(re.match(r'^-[a-zA-Z]*i', a) for a in args if not a.startswith('--'))
+            or (verb in _AWK_VERBS and 'inplace' in args)):
+        targets = paths  # `perl -pi -e …`・`awk -i inplace …` のように旗をまとめた形も
+    elif verb in _DECOMPRESS_VERBS or (verb in ('gzip', 'bzip2', 'xz', 'zstd', 'pigz') and ('-d' in args or '--decompress' in args)):
+        if '-c' not in args and '--stdout' not in args:
+            for p in paths:
+                ext = _DECOMPRESS_VERBS.get(verb) or os.path.splitext(p)[1]
+                targets.append(p[:-len(ext)] if ext and p.endswith(ext) else p)
+    elif verb in ('curl', 'wget'):
+        for k, a in enumerate(args):
+            if a in ('-o', '--output', '-O', '--output-document') and k + 1 < len(args) and not (verb == 'curl' and a == '-O'):
+                targets.append(args[k + 1])
+            elif a.startswith('--output=') or a.startswith('--output-document='):
+                targets.append(a.split('=', 1)[1])
+            elif verb == 'wget' and a in ('-P', '--directory-prefix') and k + 1 < len(args):
+                parents.append(args[k + 1])
+                targets.append(args[k + 1] + '/x')
+    elif verb in ('tar', 'bsdtar', 'gtar', 'unzip', '7z', '7za', 'cpio', 'ar'):
+        extract = (verb == 'unzip' or (verb in ('7z', '7za') and paths[:1] in (['x'], ['e']))
+                   or (verb == 'cpio' and any(a in ('-i', '--extract') or re.match(r'^-[a-zA-Z]*i', a) for a in args))
+                   or (verb == 'ar' and paths[:1] and 'x' in paths[0])
+                   or (verb in ('tar', 'bsdtar', 'gtar') and (
+                       any(a in ('--extract', '--get') or re.match(r'^-[a-zA-Z]*x[a-zA-Z]*$', a) for a in args)
+                       or (args and not args[0].startswith('-') and 'x' in args[0]))))
+        if extract:
+            dest, archive = None, None
+            for k, a in enumerate(args):
+                if a in ('-C', '--directory', '-d') and k + 1 < len(args):
+                    dest = args[k + 1]
+                elif a.startswith('--directory='):
+                    dest = a.split('=', 1)[1]
+                elif a.startswith('-o') and verb in ('7z', '7za') and len(a) > 2:
+                    dest = a[2:]
+                elif a in ('-f', '--file') and k + 1 < len(args):
+                    archive = args[k + 1]
+                elif a.startswith('--file='):
+                    archive = a.split('=', 1)[1]
+            if verb in ('tar', 'bsdtar', 'gtar') and archive is None:
+                for k, a in enumerate(args):
+                    if k + 1 < len(args) and (re.match(r'^-[a-zA-Z]*f$', a)
+                                              or (k == 0 and not a.startswith('-') and a.endswith('f'))):
+                        archive = args[k + 1]
+                        break
+            if verb == 'unzip':
+                archive = next((p for p in paths if p != dest), None)
+            base = dest or '.'
+            members = _archive_members(verb, archive, cwd)
+            if members is None:
+                r = _contains_guard(base, cwd)
+                if r:
+                    return f'{r} (unpacked by {verb}・中身を確かめられない)'
+            else:
+                root = _expand_path(base, cwd)
+                targets = [os.path.join(root, m.lstrip('/')) for m in members]
+                parents = [base] if guard_config_reason(base, cwd) else []
+    elif verb == 'git':
+        where, gpaths = _git_write_targets(args, cwd)
+        if gpaths == ['__patch__']:
+            gpaths = _patch_targets(tokens, args, head, command, where)
+        for p in gpaths:
+            r = guard_config_reason(p, where) or guard_ancestor_reason(p, where)
+            if r:
+                return f'{r} overwritten by git'
+        return None
+    elif verb == 'find':
+        return _find_danger(args, cwd)
+    elif verb == 'systemctl' and '--user' in args:
+        if any(a in _SYSTEMCTL_WRITE for a in paths):
+            return 'guard directory (~/.config/systemd) changed by systemctl --user'
+        return None
+    elif verb in ('mount', 'umount'):
+        # ★一覧の場所（や親）へ mount で覆う＝設定を丸ごと差し替える。
+        for p in paths:
+            r = guard_config_reason(p, cwd) or guard_ancestor_reason(p, cwd)
+            if r:
+                return f'{r} shadowed by {verb}'
+        return None
+    elif verb in ('claude', 'claude-code') and paths[:1] == ['config'] and paths[1:2] and \
+            paths[1] in ('set', 'add', 'remove', 'rm', 'reset'):
+        return 'guard settings changed by claude config'
+    elif verb in _AWK_VERBS:
+        script = next((a for a in args if not a.startswith('-')), '')
+        for m in re.finditer(r'>>?\s*"([^"]+)"', script):
+            targets.append(m.group(1))
+        for m in re.finditer(r'system\s*\(\s*"([^"]+)"', script):
+            hit = _guard_write_scan(m.group(1), cwd, depth + 1)
+            if hit:
+                return f'{hit} (inside awk system)'
+
+    # ★xargs の後ろの書き込みは、書き込み先が標準入力から来る＝コマンド全体に出てくる場所で照らす。
+    if 'xargs' in wrappers and (verb in _TOUCH_ALL_VERBS or verb in _COPY_VERBS or verb == 'mv'
+                                or verb in _INPLACE_VERBS):
+        for seg in split_commands(command or segment, bodies=False):
+            for t in tokens_of(_normalize_segment(seg)):
+                if t.startswith('-'):
+                    continue
+                r = guard_config_reason(t, cwd) or (guard_ancestor_reason(t, cwd) if verb in _PARENT_VERBS
+                                                    or verb == 'mv' else None)
+                if r:
+                    return f'{r} changed by xargs {verb}'
+
+    for p in targets:
+        for v in _brace_variants(p):
+            r = guard_config_reason(v, cwd)
+            if r:
+                return f'{r} written by {verb}'
+    for p in parents:
+        for v in _brace_variants(p):
+            r = guard_ancestor_reason(v, cwd)
+            if r:
+                return f'{r} changed by {verb}'
+    return None
+
+
+def _guard_write_scan(command: str, cwd=None, depth: int = 0, env=None):
+    """コマンド全体で、番人の設定への書き込みを探す（本物の区切り・`cd`/`pushd` を追う）。
+
+    ★同じコマンドの中で先に決めた変数（`P=~/.claude; … > $P/settings.json`・`export P=…`・
+      `for f in 場所 …; do … "$f"`）は解いてから測る。解けない変数は後ろの字面で照らす。
+    """
+    if depth > _UNWRAP_MAX_DEPTH + 1 or not command:
+        return None
+    here, env = cwd, dict(env or {})
+    for seg in split_commands(command, bodies=False):
+        seg = _normalize_segment(seg)
+        toks = tokens_of(seg)
+        if toks and toks[0] == 'export':
+            toks = toks[1:]
+        if toks and all(_ASSIGN_RE.match(t) for t in toks):
+            for t in toks:
+                k, _, v = t.partition('=')
+                if v.startswith('$(') or v.startswith('`'):
+                    hit = _guard_write_scan(v.strip('$()`'), here if here is not _UNKNOWN_DIR else None,
+                                            depth + 1, env)
+                    if hit:
+                        return hit
+                env[k] = _expand_vars(v, env)
+            continue
+        if len(toks) >= 3 and toks[0] == 'for' and toks[2] == 'in':
+            words = [_expand_vars(w, env) for w in toks[3:]]
+            pick = next((w for w in words if guard_config_reason(w, cwd) or guard_ancestor_reason(w, cwd)), None)
+            env[toks[1]] = pick or (words[0] if words else '')
+            continue
+        seg = _expand_vars(seg, env)
+        toks = tokens_of(seg)
+        pos, _ = _unwrap(toks)
+        v = toks[pos].split('/')[-1] if pos < len(toks) else ''
+        if v in ('cd', 'pushd'):
+            here = _cd_dest(toks[pos:] if v == 'cd' else ['cd'] + toks[pos + 1:], here)
+            continue
+        where = None if here is _UNKNOWN_DIR else here
+        hit = _guard_write_segment(seg, where, command, depth, env)
+        if hit:
+            return hit
+    return None
+
+
+def _expand_vars(text: str, env) -> str:
+    """同じコマンドの中で決めた変数だけを解く（$HOME などほかの変数は触らない）。"""
+    if not env:
+        return text
+    return re.sub(r'\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?',
+                  lambda m: env.get(m.group(1), m.group(0)), text)
+
+
+# プログラム（python3 -c・node -e・ruby -e・perl -e・<<EOF・<<<）の中の、一覧の場所の書き方。
+#   ① 文字列そのものが場所（'~/.claude/settings.json'）→ guard_config_reason で測る
+#   ② 部品で組み立てた形（Path.home() / '.claude' / 'settings.json'・join(h, '.<隠しフォルダ>', 'hooks.json')）
+#   ③ ホームを式で足した後ろの部分（homedir() + '/.tyhld/hooks/…'・"$ENV{HOME}/.claude/…"）
+#   ★報告の文の中に場所の名前が出てくるだけ（空白を含む文字列）は場所と読まない。
+_CODE_GUARD_JOIN_RE = re.compile(
+    r'''['"]\.claude['"]\s*[,/+]\s*['"](settings[\w.]*\.json|skills)['"/]'''
+    r'''|['"]\.tyhld['"]\s*[,/+]\s*['"](hooks|bin)['"/]'''
+    r'''|['"]\.[\w-]+['"]\s*[,/+]\s*['"](hooks\.json|config\.toml)['"]'''
+    r'''|['"]\.config['"]\s*[,/+]\s*['"]systemd['"/]''')
+_CODE_PATH_LITERAL_RE = re.compile(r'''['"`]>{0,2}([^'"`\s*?\[\]]{1,300})['"`]''')
+# ホームを式で足した後ろの部分。
+_CODE_HOME_TAIL_RE = re.compile(r'(/\.[^/\s]+/.*)$')
+# プログラムの中の「書く」書き方（開いて書く・写す・動かす・消す・権限を変える・展開する・外の道具を呼ぶ）。
+_CODE_WRITE_RE = re.compile(
+    r'''open\s*\([^)]*['"](?:[wax]|r\+)[bt+]*['"]|mode\s*=\s*['"](?:[wax]|r\+)'''
+    r'''|\.write(_text|_bytes)?\s*\(|json\.dump\s*\(|shutil\.(copy\w*|move|rmtree|unpack_archive|chown)'''
+    r'''|os\.(rename|replace|remove|unlink|symlink|rmdir|chmod|chown|truncate|system|popen)\s*\('''
+    r'''|\.(unlink|rename|replace|symlink_to|touch|chmod|extractall|extract)\s*\('''
+    r'''|writefile|appendfile|writetextfile|createwritestream|fs\.(write|copy|rename|rm|unlink|symlink|cp|chmod|truncate)\w*'''
+    r'''|file\.write|io\.write|bun\.write|fileutils\.|subprocess\.|child_process|execsync|spawnsync|\bsystem\s*\('''
+    r'''|['"]>>?['"]|['"]>>?\s*[$\w/~.]''', re.IGNORECASE)
+
+
+def _code_mentions_guard(stmt: str, cwd=None) -> bool:
+    if _CODE_GUARD_JOIN_RE.search(stmt):
+        return True
+    for m in _CODE_PATH_LITERAL_RE.finditer(stmt):
+        lit = m.group(1)
+        if '/' not in lit:
+            continue
+        if guard_config_reason(lit, cwd):
+            return True
+        tail = _CODE_HOME_TAIL_RE.search(lit)
+        if tail and lit[:tail.start()] and re.search(r'[$}{)]', lit[:tail.start()]) \
+                and (guard_config_reason('~' + tail.group(1), cwd) or _tail_reason(tail.group(1))):
+            return True
+        if tail and not lit[:tail.start()] and guard_config_reason('~' + tail.group(1), cwd):
+            return True
+    return False
+
+
+def _code_guard_write(text: str, cwd=None):
+    """プログラムの中で、一覧の場所を書き換えるなら理由。★読むだけ（json.load）は止めない。
+
+    ★場所が【書く呼び出しと同じ文】に出てくるか、場所を入れた変数が書く文で使われるときだけ止める
+      （別のファイルを書き換えるプログラムの文の中に、場所の名前が書いてあるだけでは止めない）。
+    """
+    if not text or not _CODE_WRITE_RE.search(text):
+        return None
+    names = set()
+    for stmt in re.split(r'[\n;]', text):
+        if not stmt.strip():
+            continue
+        if _code_mentions_guard(stmt, cwd):
+            if _CODE_WRITE_RE.search(stmt):
+                return 'guard settings written by a program'
+            m = re.match(r'\s*(?:const |let |var |my )?\$?([A-Za-z_][A-Za-z0-9_]*)\s*=[^=]', stmt)
+            if m:
+                names.add(m.group(1))
+            continue
+        if names and _CODE_WRITE_RE.search(stmt) and any(
+                re.search(rf'(?<![\w.]){re.escape(n)}\b', stmt) for n in names):
+            return 'guard settings written by a program'
+    return None
+
+
 # ═════════════════════════════════════════════════════════════════════════════
 # 2) 3関門（gate）
 # ═════════════════════════════════════════════════════════════════════════════
@@ -1871,7 +2904,8 @@ def decide_bash(command: str, cwd=None):
     if hit:
         return _r(DENY, f'danger: {hit}')
 
-    segments = split_segments(command)
+    # ★機械的な区切りに、本物の区切りを足して測る（便 2.5・`grep -n "x|y" .env` の動詞を取り戻す）。
+    segments = _real_segments(command)
 
     # ---- 1) 危険（セグメントごと・対象と作用） ----
     for seg in segments:
@@ -1895,6 +2929,11 @@ def decide_bash(command: str, cwd=None):
     if hit:
         return _r(DENY, f'danger: {hit}')
 
+    # ---- 1c') 番人の設定への書き込み（便 2.5・リダイレクト・tee・cp・mv・sed -i ほか） ----
+    hit = _guard_write_scan(command, cwd)
+    if hit:
+        return _r(DENY, f'danger: {hit}')
+
     # ---- 1d) 抜け道（便 fc22bc34・main 直 push・保護の迂回と変更・秘密の値・検査の省略） ----
     hit = _bypass_scan(command, cwd)
     if hit:
@@ -1948,8 +2987,11 @@ def decide_write(file_path: str, cwd=None):
     #   既定は守る側＝使い捨てだと確実に言えるときだけ通す（本物の場所は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)')
+    # ★Bash と同じ場所の一覧（GUARD_PLACES）だけで守る（便 2.6・場所を2か所に書かない）。
+    gr = guard_config_reason(path)
+    if gr:
+        return _r(DENY, f'danger: write to {gr}')
+    # ★前からの広い守り（~/.tyhld のどこでも）は、弱めないためにそのまま残す。
     comps = [c for c in path.split('/') if c]
     if '.tyhld' in comps:
         return _r(DENY, 'danger: write to guard directory (.tyhld)')