claude-dev-env 1.93.0 → 1.93.1

package/_shared/pr-loop/scripts/code_rules_gate.py

@@ -28,6 +28,7 @@ from pr_loop_shared_constants.code_rules_gate_constants import (  # noqa: E402
     BANNED_NOUN_VIOLATION_PATTERN,
     CODE_RULES_GATE_PYTHON_ENV_VAR,
     CODE_RULES_GATE_PYTHONPATH_ENV_VAR,
+    COMMAND_LINE_ARGUMENT_SEPARATOR_LENGTH,
     DUPLICATE_BODY_DEFINITION_LINE_GROUP_INDEX,
     DUPLICATE_BODY_SPAN_GROUP_INDEX,
     DUPLICATE_BODY_VIOLATION_PATTERN,
@@ -41,6 +42,7 @@ from pr_loop_shared_constants.code_rules_gate_constants import (  # noqa: E402
     ISOLATION_DEFINITION_LINE_GROUP_INDEX,
     ISOLATION_SPAN_GROUP_INDEX,
     ISOLATION_VIOLATION_PATTERN,
+    MAXIMUM_STAGED_PYTEST_COMMAND_LINE_CHARACTERS,
     MAX_VIOLATIONS_PER_CHECK,
     MINIMUM_STAGED_PYTEST_PYTHON_MAJOR,
     MINIMUM_STAGED_PYTEST_PYTHON_MINOR,
@@ -1710,11 +1712,114 @@ def _staged_pytest_environment() -> dict[str, str]:
     return environment
 
 
+def _relative_pytest_argument(test_path: Path, group_root: Path) -> str:
+    """Express *test_path* as a pytest argument relative to *group_root*.
+
+    *group_root* is already the pytest working directory, so the relative form
+    names the same file in far fewer characters.
+
+    Example::
+
+        group_root = C:/repo/package
+        ok:   C:/repo/package/tests/test_a.py -> "tests/test_a.py"
+        flag: C:/elsewhere/test_b.py         -> no relative form; passed absolute
+
+    Args:
+        test_path: The staged test file to express as a pytest argument.
+        group_root: The pytest working directory for the group.
+
+    Returns:
+        The path relative to *group_root* when *test_path* sits under it,
+        otherwise the absolute path unchanged.
+    """
+    try:
+        return str(test_path.relative_to(group_root))
+    except ValueError:
+        return str(test_path)
+
+
+def _batched_pytest_arguments(
+    all_pytest_arguments: list[str], character_budget: int
+) -> list[list[str]]:
+    """Split pytest path arguments into command-line-length-safe batches.
+
+    Windows rejects a command line past 32767 characters with WinError 206, so a
+    large staged set passed in one invocation crashes the gate and denies the
+    commit. Each batch takes arguments until the next one would push its joined
+    length past *character_budget*.
+
+    Example::
+
+        character_budget = 10
+        arguments        = ["aaaa", "bbbb", "cccc"]
+        ok:   [["aaaa", "bbbb"], ["cccc"]]  - every batch within budget
+        flag: [["aaaa", "bbbb", "cccc"]]    - 14 characters, over budget
+
+    Args:
+        all_pytest_arguments: The path arguments to distribute, in order.
+        character_budget: The joined length each batch must stay within. An
+            argument wider than the budget on its own still lands in a batch
+            by itself, so no argument is ever dropped.
+
+    Returns:
+        One argument list per pytest invocation, preserving input order.
+    """
+    all_batches: list[list[str]] = []
+    current_batch: list[str] = []
+    current_length = 0
+    for each_argument in all_pytest_arguments:
+        argument_length = len(each_argument) + COMMAND_LINE_ARGUMENT_SEPARATOR_LENGTH
+        if current_batch and current_length + argument_length > character_budget:
+            all_batches.append(current_batch)
+            current_batch = []
+            current_length = 0
+        current_batch.append(each_argument)
+        current_length += argument_length
+    if current_batch:
+        all_batches.append(current_batch)
+    return all_batches
+
+
+def _pytest_batch_exit_code(all_batch_command: list[str], group_root: Path) -> int:
+    """Run one pytest invocation and normalize its exit code.
+
+    Args:
+        all_batch_command: The full argv for this pytest invocation.
+        group_root: The owning test root used as the working directory.
+
+    Returns:
+        0 when the batch passes or collects no tests; pytest's non-zero exit
+        code otherwise.
+    """
+    pytest_process = subprocess.run(
+        all_batch_command,
+        cwd=str(group_root),
+        timeout=STAGED_PYTEST_TIMEOUT_SECONDS,
+        check=False,
+        env=_staged_pytest_environment(),
+    )
+    if pytest_process.returncode == PYTEST_NO_TESTS_COLLECTED_EXIT_CODE:
+        return 0
+    return pytest_process.returncode
+
+
 def _run_pytest_for_group(
     group_root: Path, all_group_test_paths: list[Path], repository_root: Path
 ) -> int:
     """Run pytest over one group's test files with the working directory at its root.
 
+    Paths are passed relative to *group_root* (the subprocess working directory)
+    and split into batches whose joined command line stays within
+    ``MAXIMUM_STAGED_PYTEST_COMMAND_LINE_CHARACTERS``, so a large staged set never
+    trips the Windows 32767-character limit. A staged set that fits the budget runs
+    as one invocation, exactly as an unbatched run did.
+
+    Example::
+
+        ok:   3 staged tests   -> 1 pytest invocation, argv well under the budget
+        flag: 800 staged tests -> 1 pytest invocation, argv over the Windows limit
+                                  (WinError 206); batching splits it across several
+
     Args:
         group_root: The owning test root used as the pytest working directory.
         all_group_test_paths: The staged test files that share *group_root*.
@@ -1722,23 +1827,32 @@ def _run_pytest_for_group(
             interpreter when ``CODE_RULES_GATE_PYTHON`` is not set.
 
     Returns:
-        0 when the group's tests pass or collect nothing; pytest's non-zero
-        exit code otherwise.
+        0 when every batch passes or collects nothing; the first failing batch's
+        non-zero pytest exit code otherwise.
     """
-    pytest_process = subprocess.run(
+    all_fixed_command = [
+        _resolve_gate_python_executable(repository_root),
+        *ALL_PYTEST_MODULE_INVOCATION,
+    ]
+    fixed_command_length = sum(
+        len(each_part) + COMMAND_LINE_ARGUMENT_SEPARATOR_LENGTH
+        for each_part in all_fixed_command
+    )
+    all_batches = _batched_pytest_arguments(
         [
-            _resolve_gate_python_executable(repository_root),
-            *ALL_PYTEST_MODULE_INVOCATION,
-            *[str(each_path) for each_path in all_group_test_paths],
+            _relative_pytest_argument(each_path, group_root)
+            for each_path in all_group_test_paths
         ],
-        cwd=str(group_root),
-        timeout=STAGED_PYTEST_TIMEOUT_SECONDS,
-        check=False,
-        env=_staged_pytest_environment(),
+        MAXIMUM_STAGED_PYTEST_COMMAND_LINE_CHARACTERS - fixed_command_length,
     )
-    if pytest_process.returncode == PYTEST_NO_TESTS_COLLECTED_EXIT_CODE:
-        return 0
-    return pytest_process.returncode
+    first_failing_exit_code = 0
+    for each_batch in all_batches:
+        batch_exit_code = _pytest_batch_exit_code(
+            [*all_fixed_command, *each_batch], group_root
+        )
+        if batch_exit_code != 0 and first_failing_exit_code == 0:
+            first_failing_exit_code = batch_exit_code
+    return first_failing_exit_code
 
 
 def run_staged_test_files(repository_root: Path) -> int:

package/_shared/pr-loop/scripts/pr_loop_shared_constants/code_rules_gate_constants.py

@@ -102,6 +102,10 @@ ALL_POSIX_VENV_PYTHON_RELATIVE_PATH_SEGMENTS: tuple[str, ...] = ("bin", "python"
 
 STAGED_PYTEST_TIMEOUT_SECONDS: int = 600
 
+MAXIMUM_STAGED_PYTEST_COMMAND_LINE_CHARACTERS: int = 24000
+
+COMMAND_LINE_ARGUMENT_SEPARATOR_LENGTH: int = 1
+
 STAGED_TEST_FAILURE_HEADER: str = (
     "code_rules_gate: staged test file(s) failed under pytest; commit blocked."
 )

package/_shared/pr-loop/scripts/tests/test_code_rules_gate.py

@@ -2722,3 +2722,149 @@ def test_staged_pytest_environment_prepends_configured_pythonpath(
     assert environment["PYTHONPATH"] == os.pathsep.join(
         ["/configured/site-packages", "/already/on/path"]
     )
+
+
+def _record_pytest_invocations(
+    monkeypatch: pytest.MonkeyPatch, *, all_exit_codes: list[int]
+) -> list[list[str]]:
+    """Patch subprocess.run to record each pytest argv and return staged exit codes."""
+    all_recorded_commands: list[list[str]] = []
+    all_remaining_exit_codes = list(all_exit_codes)
+
+    def _fake_subprocess_run(
+        all_command: list[str], **_keyword_arguments: object
+    ) -> subprocess.CompletedProcess[bytes]:
+        all_recorded_commands.append(list(all_command))
+        exit_code = all_remaining_exit_codes.pop(0) if all_remaining_exit_codes else 0
+        return subprocess.CompletedProcess(all_command, exit_code, b"", b"")
+
+    monkeypatch.setattr(gate_module.subprocess, "run", _fake_subprocess_run)
+    return all_recorded_commands
+
+
+def _staged_test_paths_under(group_root: Path, path_count: int) -> list[Path]:
+    return [
+        group_root
+        / "tests"
+        / "subpackage_with_a_realistically_long_directory_name"
+        / f"test_module_with_a_realistically_long_name_{each_index:04d}.py"
+        for each_index in range(path_count)
+    ]
+
+
+def _path_arguments_of(all_pytest_command: list[str]) -> list[str]:
+    fixed_prefix_length = len(gate_module.ALL_PYTEST_MODULE_INVOCATION) + 1
+    return all_pytest_command[fixed_prefix_length:]
+
+
+def test_run_pytest_for_group_batches_a_large_staged_set_under_the_budget(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """WinError 206: a staged set whose joined argv passes Windows' 32767-character
+    command-line limit crashed the gate and denied the commit. The paths must be
+    split across several pytest invocations, none of them over the budget.
+    """
+    all_recorded_commands = _record_pytest_invocations(monkeypatch, all_exit_codes=[])
+    all_test_paths = _staged_test_paths_under(tmp_path, 800)
+
+    exit_code = gate_module._run_pytest_for_group(tmp_path, all_test_paths, tmp_path)
+
+    assert exit_code == 0
+    assert len(all_recorded_commands) > 1, (
+        "a staged set wider than the command-line budget must be split across "
+        "several pytest invocations rather than passed in one oversized argv"
+    )
+    for each_command in all_recorded_commands:
+        assert (
+            len(" ".join(each_command))
+            <= gate_module.MAXIMUM_STAGED_PYTEST_COMMAND_LINE_CHARACTERS
+        )
+    all_batched_arguments = [
+        each_argument
+        for each_command in all_recorded_commands
+        for each_argument in _path_arguments_of(each_command)
+    ]
+    assert len(all_batched_arguments) == len(all_test_paths)
+
+
+def test_run_pytest_for_group_passes_paths_relative_to_the_group_root(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """group_root is already the subprocess cwd, so each path argument is passed
+    relative to it - the shortening that keeps a large staged set under the limit.
+    """
+    all_recorded_commands = _record_pytest_invocations(monkeypatch, all_exit_codes=[])
+    test_path = tmp_path / "tests" / "test_relative.py"
+
+    gate_module._run_pytest_for_group(tmp_path, [test_path], tmp_path)
+
+    assert _path_arguments_of(all_recorded_commands[0]) == [
+        str(Path("tests") / "test_relative.py")
+    ]
+
+
+def test_run_pytest_for_group_passes_an_outside_path_absolute(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded_commands = _record_pytest_invocations(monkeypatch, all_exit_codes=[])
+    group_root = tmp_path / "group"
+    outside_path = tmp_path / "elsewhere" / "test_outside.py"
+
+    gate_module._run_pytest_for_group(group_root, [outside_path], tmp_path)
+
+    assert _path_arguments_of(all_recorded_commands[0]) == [str(outside_path)]
+
+
+def test_run_pytest_for_group_runs_one_invocation_for_a_small_staged_set(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_recorded_commands = _record_pytest_invocations(monkeypatch, all_exit_codes=[])
+    all_test_paths = _staged_test_paths_under(tmp_path, 3)
+
+    exit_code = gate_module._run_pytest_for_group(tmp_path, all_test_paths, tmp_path)
+
+    assert exit_code == 0
+    assert len(all_recorded_commands) == 1, (
+        "a staged set that fits the budget must behave exactly as before: "
+        "one pytest invocation carrying every path"
+    )
+
+
+def test_run_pytest_for_group_surfaces_the_first_failing_batch_exit_code(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A failure in any batch must surface, and every batch must still run so the
+    operator sees the whole staged-test picture rather than the first failure alone.
+    """
+    all_recorded_commands = _record_pytest_invocations(
+        monkeypatch, all_exit_codes=[0, 1, 2]
+    )
+    all_test_paths = _staged_test_paths_under(tmp_path, 800)
+
+    exit_code = gate_module._run_pytest_for_group(tmp_path, all_test_paths, tmp_path)
+
+    assert exit_code == 1
+    assert len(all_recorded_commands) >= 3
+
+
+def test_run_pytest_for_group_treats_no_tests_collected_as_a_pass_per_batch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _record_pytest_invocations(
+        monkeypatch,
+        all_exit_codes=[gate_module.PYTEST_NO_TESTS_COLLECTED_EXIT_CODE, 0],
+    )
+    all_test_paths = _staged_test_paths_under(tmp_path, 800)
+
+    exit_code = gate_module._run_pytest_for_group(tmp_path, all_test_paths, tmp_path)
+
+    assert exit_code == 0, (
+        "a batch that collects no tests is not a failure; only a real pytest "
+        "failure exit code may block the commit"
+    )

package/hooks/blocking/pii_scanner.py

@@ -17,6 +17,7 @@ _hooks_directory = str(Path(__file__).resolve().parent.parent)
 if _hooks_directory not in sys.path:
     sys.path.insert(0, _hooks_directory)
 
+from hooks_constants.local_identity import nas_host  # noqa: E402
 from hooks_constants.pii_prevention_constants import (  # noqa: E402
     ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES,
     ALL_EXACT_LEGAL_NOTICE_BASENAMES,
@@ -273,9 +274,33 @@ def _find_home_paths(text: str) -> list[PiiFinding]:
     return all_findings
 
 
+def _all_allowlisted_private_ip_addresses() -> frozenset[str]:
+    """Return every private IPv4 address the scanner must leave unflagged.
+
+    ::
+
+        CLAUDE_NAS_HOST=10.20.30.40  ->  static set + {"10.20.30.40"}
+        CLAUDE_NAS_HOST=nas.local    ->  static set only (a name, not an address)
+        (env unset, no file)         ->  static set only
+
+    The committed set carries no real address. The maintainer's own NAS host
+    resolves at scan time from ``CLAUDE_NAS_HOST`` or
+    ``~/.claude/local-identity.json``, so their ssh traffic and git-ignored
+    local config stay unflagged while the repository stays publishable.
+
+    Returns:
+        The static allowlist, joined with the locally configured NAS host when
+        that host is itself a private IPv4 address.
+    """
+    configured_nas_host = nas_host()
+    if not _is_private_ipv4_address(configured_nas_host):
+        return ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES
+    return ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES | {configured_nas_host}
+
+
 def _find_private_ips(text: str) -> list[PiiFinding]:
     all_findings: list[PiiFinding] = []
-    allowlisted_addresses = ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES
+    allowlisted_addresses = _all_allowlisted_private_ip_addresses()
     for each_match in IPV4_PATTERN.finditer(text):
         address_text = each_match.group(1)
         if address_text in allowlisted_addresses:

package/hooks/blocking/test_code_rules_enforcer_dead_config_field.py

@@ -124,8 +124,8 @@ def test_flags_field_read_only_by_test_module(neutral_root: Path) -> None:
         "from os_update_workflow.config import ThemeUpdateConfig\n"
         "\n"
         "def test_debug_port_default() -> None:\n"
-        "    cfg = ThemeUpdateConfig(portal_url='x', debug_port=9222, timeout_seconds=30)\n"
-        "    assert cfg.debug_port == 9222\n"
+        "    cfg = ThemeUpdateConfig(portal_url='x', debug_port=8471, timeout_seconds=30)\n"
+        "    assert cfg.debug_port == 8471\n"
         "    assert cfg.portal_url == 'x'\n"
         "    assert cfg.timeout_seconds == 30\n"
     )

package/hooks/blocking/test_pii_scanner.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import sys
 from pathlib import Path
 
+import pytest
+
 _HOOK_DIR = Path(__file__).parent
 _HOOKS_DIR = _HOOK_DIR.parent
 if str(_HOOK_DIR) not in sys.path:
@@ -26,6 +28,10 @@ SYNTHETIC_HOME_PATH = r"C:\Users\fixture_real_user\notes.txt"
 SYNTHETIC_PLACEHOLDER_HOME = r"C:\Users\<you>\notes.txt"
 SYNTHETIC_PRIVATE_IP = "192.168.42.17"
 SYNTHETIC_PUBLIC_IP = "8.8.8.8"
+NAS_HOST_ENVIRONMENT_VARIABLE = "CLAUDE_NAS_HOST"
+SYNTHETIC_NAS_PRIVATE_IP = "10.20.30.40"
+SYNTHETIC_NAS_HOSTNAME = "nas.example.local"
+SYNTHETIC_NAS_SSH_COMMAND = f"ssh -p 2200 operator@{SYNTHETIC_NAS_PRIVATE_IP} uptime"
 
 
 def test_flags_real_email_and_allows_example_domain() -> None:
@@ -69,8 +75,27 @@ def test_allows_loopback_unspecified_and_link_local_addresses() -> None:
     assert scan_text_for_pii("peer 169.254.10.20") == []
 
 
-def test_allows_product_nas_private_ip() -> None:
-    assert scan_text_for_pii("ssh -p 9222 jon@192.168.1.100 uptime") == []
+def test_allows_the_nas_host_resolved_from_local_configuration(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv(NAS_HOST_ENVIRONMENT_VARIABLE, SYNTHETIC_NAS_PRIVATE_IP)
+    assert scan_text_for_pii(SYNTHETIC_NAS_SSH_COMMAND) == []
+
+
+def test_flags_private_ip_that_is_not_the_configured_nas_host(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv(NAS_HOST_ENVIRONMENT_VARIABLE, SYNTHETIC_NAS_PRIVATE_IP)
+    all_lan_hits = scan_text_for_pii(f"peer {SYNTHETIC_PRIVATE_IP}")
+    assert [each.matched_text for each in all_lan_hits] == [SYNTHETIC_PRIVATE_IP]
+
+
+def test_flags_private_ip_when_the_configured_nas_host_is_a_hostname(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv(NAS_HOST_ENVIRONMENT_VARIABLE, SYNTHETIC_NAS_HOSTNAME)
+    all_lan_hits = scan_text_for_pii(f"host {SYNTHETIC_PRIVATE_IP}")
+    assert any(each.category == "private-ip" for each in all_lan_hits)
 
 
 def test_flags_github_token_aws_key_and_pem_header() -> None:

package/hooks/hooks_constants/pii_prevention_constants.py

@@ -169,11 +169,7 @@ ALL_PLACEHOLDER_HOME_USERNAMES: frozenset[str] = frozenset(
     }
 )
 
-ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES: frozenset[str] = frozenset(
-    {
-        "192.168.1.100",
-    }
-)
+ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES: frozenset[str] = frozenset()
 
 MAXIMUM_FINDINGS_PER_SCAN: int = 12
 MAXIMUM_STAGED_FILE_BYTES: int = 1_000_000
@@ -269,9 +265,9 @@ CORRECTIVE_MESSAGE_HEADER: str = (
 CORRECTIVE_MESSAGE_FOOTER: str = (
     "Remediate: replace with placeholders (user@example.com, C:/Users/example/), "
     "move secrets to an env or secret store, and run the privacy-hygiene skill "
-    "for a full sweep. Add intentional LAN hosts to "
-    "ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES in hooks_constants when tooling must "
-    "keep a host such as a NAS."
+    "for a full sweep. Your own NAS host is allowlisted at scan time from "
+    "CLAUDE_NAS_HOST or ~/.claude/local-identity.json, so set it there rather "
+    "than committing the address."
 )
 
 FINDING_LINE_TEMPLATE: str = "  [{category}] {preview}"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "1.93.0",
+    "version": "1.93.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/skills/privacy-hygiene/SKILL.md

@@ -24,7 +24,7 @@ Find and remove personal data and high-confidence secrets before they land in gi
 |---|---|---|
 | Email | `person@company.io` | `user@example.com`, `user@example.org`, `user@example.net` |
 | Home path | `C:/Users/realname/...`, `/Users/realname/...`, `/home/realname/...` | `C:/Users/example/...`, `C:/Users/<you>/...`, `/Users/alice/...` |
-| LAN address | Unlisted `10.x` / `172.16–31.x` / `192.168.x` | Public addresses; product NAS `192.168.1.100`; other entries in `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` |
+| LAN address | Unlisted `10.x` / `172.16–31.x` / `192.168.x` | Public addresses; your NAS host from `CLAUDE_NAS_HOST` or `~/.claude/local-identity.json`; entries in `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` |
 | Secret | `ghp_…`, `github_pat_…`, `AKIA…`, PEM private-key headers | Public keys, redacted `***`, env var names without values |
 
 Surfaces:
@@ -71,7 +71,7 @@ Review each hit. Ignore:
 |---|---|
 | Real email | Replace with `user@example.com` or remove |
 | Home path | Use `Path.home()`, `~`, or `C:/Users/<you>/` |
-| LAN address | Remove, use a hostname, or add to `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` only when tooling requires it |
+| LAN address | Remove, use a hostname, or — for your own NAS — set the host in `CLAUDE_NAS_HOST` or `~/.claude/local-identity.json`, both of which stay out of git |
 | Credential material | Remove from the tree; rotate the credential; load from env/secret store |
 | Already committed | Rewrite is not enough if already pushed — rotate secrets; scrub history only with explicit user approval |
 
@@ -87,7 +87,7 @@ Review each hit. Ignore:
 - Intentional public maintainer identity published on purpose
 - Example domains reserved for documentation (`example.com` and siblings)
 - Placeholder home users (`example`, `user`, `alice`, `<you>`, `YOUR_USER`)
-- Product NAS host `192.168.1.100` (allowlisted for the NAS SSH rule/hook)
+- The NAS host you configure locally (allowlisted at scan time, never committed)
 - Public addresses and docs that name private ranges without a live host (still prefer hostnames)
 
 ## Enable on any machine / public repository
@@ -103,7 +103,7 @@ Hooks register via `hooks/hooks.json` into `~/.claude/settings.json`. Once insta
 
 ## Open knobs
 
-- **NAS / LAN allowlist:** Unlisted private IPs are blocked. `192.168.1.100` is allowlisted for the NAS SSH enforcer. Add further hosts to `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` only when tooling requires them.
+- **NAS / LAN allowlist:** Unlisted private IPs are blocked. The scanner resolves your NAS host from `CLAUDE_NAS_HOST`, then `~/.claude/local-identity.json` (`nas.host`), and allowlists it when it is a private address, so the committed tree holds no real host. `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` in `hooks_constants` holds the static allowlist for any host every machine must share.
 - **Public maintainer identity:** when a real email or name is intentional product surface, keep it and note that in the PR body so reviewers do not treat it as a leak.
 
 ## What this skill does not do