@tyhld/conductor 0.12.21 → 0.12.23

package/scripts/hooks/policy.py

@@ -29,6 +29,8 @@
 
 ★このモジュールは標準ライブラリだけで動き、製品固有の名前を持たない（切り出し可能）。
 """
+import fnmatch
+import glob
 import os
 import re
 import shlex
@@ -412,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:
@@ -1826,36 +1827,59 @@ def _real_segments(command: str):
 
 
 # ═════════════════════════════════════════════════════════════════════════════
-# 番人の設定への書き込み（DENY・便 2.5・えふさん確定 2026-09-18）
+# 番人の設定を弱める書き込み（DENY・便 2.5 → 便 2.6 で「手段を問わず」へ・えふさん確定 2026-09-18）
 #
-# 【なぜ要るか（便 ad6b5db9 の重大発見1(ア)）】書き込みの道具（Write）では止まるのに、Bash の
-#   リダイレクト・tee・cp・mv・sed -i・python3 で開いて書く形では止まらなかった（リダイレクトの
-#   行き先は秘密とシステム領域しか見ていなかった）。番人の設定を職人が書き換えられると、番人
-#   そのものが外れる。
-# 【守る場所】~/.claude/settings.json・~/.claude/settings.local.json（と、各現場の
-#   .claude/settings*.json＝Write と同じ判定 is_guard_settings_path）・~/.tyhld/hooks 配下・
-#   ~/.codex/hooks.json・~/.codex/config.toml・~/.config/systemd 配下。
-#   ★ホーム直下の隠しフォルダの hooks.json・config.toml は、道具の名前を持たない一般の形で守る
-#     （~/.codex の2つはこれに当たる）。番人の判定に道具名を持ち込まない決め（test/guard-for-codex・
-#     ADR-022）を守るため。ほかの道具の同じ形の登録ファイルも、同じく守る側に入る。
-# 【止めないもの】読むだけ（cat・grep・diff・jq・cp で外へ写す）。使い捨ての作業場（/tmp の下）に
-#   作った同じ名前（Write と同じ例外 is_throwaway_path）。
-# 【どう見るか】本物の区切り（引用符・ヒアドキュメントの本文の中は割らない）で割った各コマンドの
-#   「書き込む先」だけを見る。報告やコミットの説明に同じ場所の名前が書いてあるだけでは止めない。
+# 【目的】職人から、番人・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）。
+#   報告やコミットの説明に場所の名前が書いてあるだけ（引用符の中の `>` も書き込みと読まない）。
 # ═════════════════════════════════════════════════════════════════════════════
 
-#: ★~/.claude/settings*.json は Write と同じ名前の判定（is_guard_settings_path）で守る（一覧は持たない）。
-#: ホーム直下の隠しフォルダに置かれたときだけ、道具の番人の登録・設定と分かる名前。
-_AGENT_CONFIG_NAMES = frozenset({'hooks.json', 'config.toml'})
-#: ホームの下の、中身ぜんぶが番人の設定の置き場。
-_GUARD_HOME_DIRS = ('.tyhld/hooks', '.config/systemd')
-#: 番人の設定を中に持つ置き場（消す・動かす・フォルダごと写し込むと設定が変わる）。
-#: ★ほかに、ホーム直下の隠しフォルダで hooks.json・config.toml を持つものも同じ扱い。
-_GUARD_HOME_PARENTS = ('.claude', '.tyhld', '.config')
+#: ★守る場所の一覧（ここだけ）。(種類, 場所)
+#:   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・${HOME}・~・相対を解く）。"""
     q = normalize_redirect_target(path)
     for var in ('${HOME}', '$HOME'):
         if q == var or q.startswith(var + '/'):
@@ -1868,21 +1892,78 @@ def _expand_path(path: str, cwd=None) -> str:
     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):
     """絶対パスたちの、ホームからの相対（ホームの外は落とす）。字面のホームと実体のホームの両方。"""
-    homes = {os.path.expanduser('~').rstrip('/'), _home_dir().rstrip('/')}
     out = []
     for p in abs_paths:
-        for h in homes:
-            if h and p.startswith(h + '/'):
+        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
@@ -1892,59 +1973,120 @@ def guard_config_reason(path: str, cwd=None):
     except Exception:  # noqa: BLE001
         return None
     for p in (lit, real):
-        if is_guard_settings_path(p) and not is_throwaway_path(p):
-            return 'guard settings (.claude/settings*.json)'
-    for rel in _home_rels((lit, real)):
-        parts = rel.split('/')
-        if len(parts) == 2 and parts[0].startswith('.') and parts[1] in _AGENT_CONFIG_NAMES:
-            return f'agent hook settings (~/{rel})'
-        for d in _GUARD_HOME_DIRS:
-            if rel == d or rel.startswith(d + '/'):
-                return f'guard directory (~/{d})'
+        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_parent_reason(path: str, cwd=None):
-    """番人の設定を中に持つ置き場そのもの（~/.claude・~/.tyhld・~/.config・現場の .claude・
-    ホーム直下の隠しフォルダで hooks.json か config.toml を持つもの）。"""
+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):
-        if p.rstrip('/').split('/')[-1] == '.claude' and not is_throwaway_path(p):
-            return 'guard settings folder (.claude)'
-    for rel in _home_rels((lit, real)):
-        rel = rel.rstrip('/')
-        if rel in _GUARD_HOME_PARENTS or any(d.startswith(rel + '/') for d in _GUARD_HOME_DIRS):
-            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 _AGENT_CONFIG_NAMES):
-            return f'agent hook settings folder (~/{rel})'
+        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*(>>|>\||&>>|&>|>&|>|<<<|<<-?|<>|<)')
+_REDIRECT_TOKEN_RE = re.compile(r'^\d*(>>|>\||&>>|&>|>&|<>|>|<<<|<<-?|<)')
 #: 書き込む先が「最後の引数（か -t の値）」の道具。それより前は読むだけ。
-_COPY_VERBS = frozenset({'cp', 'install', 'ln', 'rsync', 'ditto'})
-#: 引数ぜんぶが書き換え・削除の対象になる道具。
+_COPY_VERBS = frozenset({'cp', 'install', 'ln', 'rsync', 'ditto', 'scp', 'gcp'})
+#: 引数ぜんぶが書き換え・削除・権限変更の対象になる道具（エディタで開いて保存する形も含む）。
 _TOUCH_ALL_VERBS = frozenset({
-    'tee', 'rm', 'rmdir', 'shred', 'truncate', 'touch', 'chmod', 'chown', 'chgrp', 'patch',
-    'sponge', 'unlink', 'mkdir',
+    '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',
 })
-#: その場で書き換える旗を持つ道具（sed -i・perl -i・yq -i など）。
-_INPLACE_VERBS = frozenset({'sed', 'perl', 'ruby', 'yq'})
+#: 置き場ごと消す・権限を変える道具（引数が一覧の場所の親でも止める）。
+_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
@@ -1973,11 +2115,11 @@ def _real_redirect_targets(segment: str):
         if j < n and head[j] in '>|':
             j += 1
         if j < n and head[j] in '&(':
-            i = j + 1  # `>&2` / `2>&1`（写し）・`>(…)`（プロセス置換）は書き込み先ではない
+            i = j + 1  # `>&2` / `2>&1`（写し）・`>(…)`（プロセス置換・中身は別に測る）は書き込み先ではない
             continue
         while j < n and head[j] in ' \t':
             j += 1
-        k, q = j, None
+        k, q, depth = j, None, 0
         while k < n:
             ch = head[k]
             if q:
@@ -1985,7 +2127,17 @@ def _real_redirect_targets(segment: str):
                     q = None
             elif ch in '"\'':
                 q = ch
-            elif ch in ' \t;|&<>()':
+            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("'", '')
@@ -2011,46 +2163,322 @@ def _plain_args(tokens, start):
     return out
 
 
-def _verb_pos(tokens):
-    """verb_of と同じ読み方で、動詞の位置を返す（無ければ len(tokens)）。"""
-    i = 0
+def _unwrap(tokens):
+    """包み・変数代入・予約語を剥がした、道具の位置と、通った包みの名前の集合。"""
+    i, seen = 0, set()
     while i < len(tokens):
         t = tokens[i]
-        if _ASSIGN_RE.match(t):
+        if t in _SHELL_KEYWORDS or _ASSIGN_RE.match(t):
             i += 1
             continue
         base = t.split('/')[-1]
-        if base in _WRAPPERS:
+        if base in _GUARD_WRAPPERS:
+            seen.add(base)
+            vals = _GUARD_WRAPPERS[base]
             i += 1
-            while i < len(tokens) and tokens[i].startswith('-'):
+            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 in ('timeout', 'nice', 'ionice') and i < len(tokens) \
-                    and not tokens[i].startswith('-'):
+            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
-    return len(tokens)
+        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 _guard_write_segment(segment: str, cwd=None):
-    """本物の1コマンドが番人の設定へ書くなら理由。"""
+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):
-        r = guard_config_reason(t, cwd)
-        if r:
-            return f'redirect into {r}'
+        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 = _verb_pos(tokens)
+    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 ('rm', 'rmdir', 'shred', 'unlink'):
+        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:
@@ -2060,64 +2488,180 @@ def _guard_write_segment(segment: str, cwd=None):
                 dest = args[k + 1]
             elif a.startswith('--target-directory='):
                 dest = a.split('=', 1)[1]
-        srcs = [p for p in paths if p != dest]
-        if dest is None and paths:
-            dest, srcs = paths[-1], paths[:-1]
-        if dest:
-            targets = [dest] + [os.path.join(_expand_path(dest, cwd), 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 == 'rsync':
-                parents = [dest]
+        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(verb if verb != 'yq' else 'sed', tokens[pos:])
-            or any(re.match(r'^-[a-zA-Z]*i', a) for a in args if not a.startswith('--'))):
-        targets = paths  # `perl -pi -e …` のように旗をまとめた形も
+            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:
-        r = guard_config_reason(p, cwd)
-        if r:
-            return f'{r} written by {verb}'
+        for v in _brace_variants(p):
+            r = guard_config_reason(v, cwd)
+            if r:
+                return f'{r} written by {verb}'
     for p in parents:
-        r = _guard_parent_reason(p, cwd)
-        if r:
-            return f'{r} changed by {verb}'
+        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):
-    """コマンド全体で、番人の設定への書き込みを探す（本物の区切り・`cd 場所` を追う）。
+def _guard_write_scan(command: str, cwd=None, depth: int = 0, env=None):
+    """コマンド全体で、番人の設定への書き込みを探す（本物の区切り・`cd`/`pushd` を追う）。
 
-    ★同じコマンドの中で先に決めた変数（`P=/tmp/x; … > $P/.claude/settings.json`）は解いてから測る。
-      解けない変数は、そのまま（＝使い捨ての作業場と確かめられない＝守る側）で測る。
+    ★同じコマンドの中で先に決めた変数（`P=~/.claude; … > $P/settings.json`・`export P=…`・
+      `for f in 場所 …; do … "$f"`）は解いてから測る。解けない変数は後ろの字面で照らす。
     """
-    here, env = cwd, {}
+    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)
-        if verb_of(toks) == 'cd':
-            here = _cd_dest(toks, here)
+        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)
+        hit = _guard_write_segment(seg, where, command, depth, env)
         if hit:
             return hit
-        for code in _code_payloads(seg, command):
-            hit = _code_guard_write(code, where)
-            if hit:
-                return hit
     return None
 
 
@@ -2129,40 +2673,28 @@ def _expand_vars(text: str, env) -> str:
                   lambda m: env.get(m.group(1), m.group(0)), text)
 
 
-def _code_payloads(segment: str, command: str):
-    """1コマンドがその場で走らせるプログラムの中身（python3 -c・node -e・python3 - <<EOF）。"""
-    head = segment.split('\n', 1)[0]
-    toks = tokens_of(head)
-    if verb_of(toks) not in _CODE_RUNNERS:
-        return []
-    out = [toks[k + 1] for k, t in enumerate(toks) if t in _CODE_FLAGS and k + 1 < len(toks)]
-    m = _HEREDOC_START_RE.search(head)
-    if m:
-        body = _HEREDOC_RE.search(command[command.find(m.group(0)):] if m.group(0) in command else '')
-        if body:
-            out.append(body.group(2))
-    return out
-
-
-# プログラム（python3 -c・node -e・python3 - <<EOF）の中の、番人の設定の場所の書き方。
+# プログラム（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['"]'''
-    r'''|['"]\.tyhld['"]\s*[,/+]\s*['"]hooks['"/]'''
+    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'''['"`]([^'"`\s*?\[\]]{1,300})['"`]''')
-# ホームを式で足した後ろの部分（homedir() + '/.codex/hooks.json'・`${os.homedir()}/.claude/…`）。
-_CODE_HOME_TAIL_RE = re.compile(r'^(?:\$\{[^}]*\})?(/\..+)$')
-# プログラムの中の「書く」書き方（開いて書く・写す・動かす・消す）。
+_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)'''
-    r'''|os\.(rename|replace|remove|unlink|symlink|rmdir)\s*\(|\.(unlink|rename|replace|symlink_to|touch)\s*\('''
-    r'''|writefile|appendfile|fs\.(write|copy|rename|rm|unlink|symlink|cp)\w*'''
-    r'''|file\.write|io\.write|['"]>>?['"]''', re.IGNORECASE)
+    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:
@@ -2170,16 +2702,21 @@ def _code_mentions_guard(stmt: str, cwd=None) -> bool:
         return True
     for m in _CODE_PATH_LITERAL_RE.finditer(stmt):
         lit = m.group(1)
-        if '/' in lit and guard_config_reason(lit, cwd):
+        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
-        tail = _CODE_HOME_TAIL_RE.match(lit)
-        if tail and guard_config_reason('~' + tail.group(1), cwd):
+        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）は止めない。
+    """プログラムの中で、一覧の場所を書き換えるなら理由。★読むだけ（json.load）は止めない。
 
     ★場所が【書く呼び出しと同じ文】に出てくるか、場所を入れた変数が書く文で使われるときだけ止める
       （別のファイルを書き換えるプログラムの文の中に、場所の名前が書いてあるだけでは止めない）。
@@ -2267,6 +2804,13 @@ def _gate_release(words, tokens):
         for w in words[1:]:
             if w in ('promote', 'alias', 'rollback'):
                 return f'vercel {w}'
+        # ★本番ドメインの変更（追加・削除・移管・購入）だけ関門。ls・inspect は読み取りなので自走
+        #   （便 6d6f2ff8・えふさん確定 #1: プレビューは自走・本番へ影響する操作は関門・強める向きのみ）。
+        if 'domains' in words[1:]:
+            after = [w for w in words[words.index('domains') + 1:] if not w.startswith('-')]
+            if after[:1] and after[0] in ('add', 'rm', 'remove', 'buy', 'move',
+                                          'transfer', 'transfer-in'):
+                return f'vercel domains {after[0]}'
     if v == 'wrangler' and '--dry-run' not in tokens and (
             words[1:2] in (['deploy'], ['publish'])
             or words[1:3] in (['versions', 'deploy'], ['pages', 'deploy'])):
@@ -2450,16 +2994,14 @@ 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)')
-    comps = [c for c in path.split('/') if c]
-    if '.tyhld' in comps:
-        return _r(DENY, 'danger: write to guard directory (.tyhld)')
-    # ★Bash と同じ場所の一覧で守る（ホーム直下の隠しフォルダの hooks.json・config.toml・
-    #   ~/.config/systemd・便 2.5）。
+    # ★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)')
     return _r(ALLOW, 'no gate, no danger')