claude-dev-env 2.31.0 → 2.32.0

package/bin/install.test.mjs

@@ -925,9 +925,17 @@ function isPreToolUseDispatcherCommand(command) {
     return /(?:^|[/\\])pre_tool_use_dispatcher\.py(?![A-Za-z0-9_])/.test(command);
 }
 
+function matcherCoversWriteAndEdit(matcher) {
+    const allToolNames = String(matcher || '').split('|');
+    return allToolNames.includes('Write') && allToolNames.includes('Edit');
+}
+
 function countManagedRunAllValidatorsHooks(settings) {
-    const writeEditGroups = (settings.hooks.PreToolUse || []).filter(
-        group => group.matcher === 'Write|Edit'
+    // The runner is registered inline on the write path. Which mutation tools
+    // that path lists is the gate's business, so this counts any matcher
+    // carrying Write and Edit rather than one exact tool list.
+    const writeEditGroups = (settings.hooks.PreToolUse || []).filter(group =>
+        matcherCoversWriteAndEdit(group.matcher)
     );
     let runAllValidatorsCount = 0;
     for (const group of writeEditGroups) {
@@ -1382,7 +1390,7 @@ test('shipped hooks.json matches the dispatcher design: dispatchers registered,
     assert.equal(
         countManagedRunAllValidatorsHooks(shippedHooksConfig),
         1,
-        'shipped hooks.json must retain the inline run_all_validators runner in Write|Edit',
+        'shipped hooks.json must retain the inline run_all_validators runner on the write path',
     );
 
     const allPostToolUseGroups = shippedHooksConfig.hooks.PostToolUse || [];

package/docs/CODE_RULES.md

@@ -126,7 +126,8 @@ Scope assigns the lane. A check that reads a file other than the target runs on
 
 Hook-infrastructure targets run three checks in the edit lane — `check_same_file_inline_duplicate_body`, `check_zero_payload_function_alias`, `check_unanchored_command_dispatch` — and the whole roster on the full gate. `ALL_HOOK_INFRASTRUCTURE_EDIT_LANE_CHECK_NAMES` holds that set.
 
-Two surfaces report on the roster, and each reports a specific thing:
+Three surfaces report on the roster, and each reports a specific thing:
 
 - `hooks/validators/hook_timing_harness.py` builds a `Write` payload against a target that already holds content. `_contents_for_validation` returns `None` for that payload, so the harness times interpreter start and hook dispatch. Time an `Edit` payload against a real file to measure the checks.
 - `~/.claude/logs/hook-blocks.log` records the denials raised by fixtures in `test_code_rules_enforcer_*.py` and by the timing harness's default target.
+- `hooks/validators/run_all_validators.py` stages the target under a temporary root and rebuilds the shortest path tail that carries every exemption signal. The walk starts at the target's own project root and skips a directory pytest generated for its own scratch tree, so the staged path reads the same wherever `--basetemp` places that tree.

package/hooks/blocking/bash_post_call_dispatcher.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""PostToolUse dispatcher that hosts the Bash hook chain running after a call.
+
+Named ``bash_post_call_dispatcher`` rather than the more obvious
+``bash_post_tool_use_dispatcher``: ``bin/install.test.mjs`` counts every
+PostToolUse command whose text contains the literal substring
+``post_tool_use_dispatcher.py`` and asserts exactly one match, against the
+unrelated Write/Edit dispatcher in ``validation/post_tool_use_dispatcher.py``.
+That check carries no basename anchor (its PreToolUse sibling does), so a
+correctly-named Bash-side sibling here would read as a second match of an
+unrelated dispatcher. This name carries the same meaning without the
+collision, and needs no change to that shared, out-of-scope test file.
+
+Reads the tool payload from stdin once, selects the hosted hooks applicable to
+the payload's tool name, and runs each one in-process via the shared
+hosted-hook runner. A hosted PostToolUse hook here carries no permission
+decision -- it is a side-effecting observer, not a gate -- so this dispatcher
+runs the whole roster unconditionally and emits nothing itself, matching every
+hosted hook's own empty-stdout contract.
+
+A single hosted hook crash fails open: ``run_hook_capturing_output`` isolates
+it, so it contributes nothing and does not stop the remaining hosted hooks.
+
+One interpreter start here serves the whole roster: every hosted hook's
+imports load once into this process rather than once per hook.
+"""
+
+from __future__ import annotations
+
+
+import _path_setup  # noqa: F401
+
+from hooks_constants.bash_post_call_dispatcher_constants import (
+    ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES,
+)
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import BashHostedHookEntry
+from hooks_constants.hosted_hook_runner import (
+    run_hook_capturing_output,
+    resolved_hook_script_path,
+    run_dispatcher_main,
+)
+
+
+def select_applicable_entries(tool_name: str) -> list[BashHostedHookEntry]:
+    """Return the ordered hosted-hook entries that apply to tool_name."""
+    return [
+        each_entry
+        for each_entry in ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES
+        if tool_name in each_entry.applicable_tool_names
+    ]
+
+
+def dispatch(payload_text: str, tool_name: str) -> None:
+    """Run every hosted hook applicable to tool_name, in registration order.
+
+    Each hosted hook's crash is isolated by ``run_hook_capturing_output``, so
+    one hook failing never stops a later one in the same roster.
+    """
+    for each_entry in select_applicable_entries(tool_name):
+        script_path = resolved_hook_script_path(each_entry.script_relative_path)
+        run_hook_capturing_output(script_path, payload_text)
+
+
+def main() -> None:
+    """Read stdin once and dispatch the Bash PostToolUse hosted-hook roster."""
+    run_dispatcher_main(dispatch)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/blocking/bash_pre_tool_use_dispatcher.py

@@ -22,7 +22,6 @@ from __future__ import annotations
 import json
 import sys
 from dataclasses import dataclass, field
-from pathlib import Path
 
 import _path_setup  # noqa: F401
 
@@ -36,8 +35,12 @@ from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
     REASON_JOIN_SEPARATOR,
     BashHostedHookEntry,
 )
-from hooks_constants.hosted_hook_runner import HostedHookRun, run_hook_capturing_output
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+from hooks_constants.hosted_hook_runner import (
+    run_dispatcher_main,
+    run_hook_capturing_output,
+    HostedHookRun,
+    resolved_hook_script_path,
+)
 
 _PERMISSION_DECISION_KEY = "permissionDecision"
 _PERMISSION_REASON_KEY = "permissionDecisionReason"
@@ -203,12 +206,6 @@ def aggregate_bash_hook_results(
     )
 
 
-def _resolve_hook_script_path(relative_path: str) -> str:
-    """Resolve a hooks/-relative path to an absolute script path."""
-    hooks_root = Path(__file__).resolve().parent.parent
-    return str(hooks_root / relative_path)
-
-
 def _emit_decision(decision: BashDispatcherDecision) -> None:
     """Write one PreToolUse permission payload to stdout when an outcome exists."""
     if not decision.decision:
@@ -251,7 +248,7 @@ def dispatch(payload_text: str, tool_name: str) -> None:
     applicable_entries = select_applicable_entries(tool_name)
     all_runs: list[HostedHookRun] = []
     for each_entry in applicable_entries:
-        script_path = _resolve_hook_script_path(each_entry.script_relative_path)
+        script_path = resolved_hook_script_path(each_entry.script_relative_path)
         hook_run = run_hook_capturing_output(script_path, payload_text)
         all_runs.append(hook_run)
         if _run_is_deny(hook_run):
@@ -264,17 +261,7 @@ def dispatch(payload_text: str, tool_name: str) -> None:
 
 def main() -> None:
     """Read stdin once and dispatch the Bash/PowerShell hosted-hook chain."""
-    payload_dictionary = read_hook_input_dictionary_from_stdin()
-    if payload_dictionary is None:
-        sys.exit(0)
-
-    payload_text = json.dumps(payload_dictionary)
-    tool_name = payload_dictionary.get("tool_name", "")
-    if not isinstance(tool_name, str) or not tool_name:
-        sys.exit(0)
-
-    dispatch(payload_text, tool_name)
-    sys.exit(0)
+    run_dispatcher_main(dispatch)
 
 
 if __name__ == "__main__":

package/hooks/blocking/code_rules_duplicate_body.py

@@ -54,6 +54,7 @@ import ast
 import copy
 import sys
 from pathlib import Path
+from typing import NamedTuple
 
 _blocking_directory = str(Path(__file__).resolve().parent)
 _hooks_directory = str(Path(__file__).resolve().parent.parent)
@@ -84,6 +85,21 @@ from hooks_constants.duplicate_function_body_constants import (  # noqa: E402
 )
 
 
+_ModuleScopeFunction = ast.FunctionDef | ast.AsyncFunctionDef
+
+
+class _FunctionScanProfile(NamedTuple):
+    """The three readings of one module-scope function the inline scan compares.
+
+    Every reading is a property of that function alone, so each is taken once per
+    file and read by each pairing the scan weighs.
+    """
+
+    reachable_statement_count: int
+    all_sorted_body_dumps: list[str]
+    all_block_dumps: list[list[str]]
+
+
 def _body_statements_without_docstring(
     function_node: ast.FunctionDef | ast.AsyncFunctionDef,
 ) -> list[ast.stmt]:
@@ -384,6 +400,37 @@ def _normalized_statement_dump(statement: ast.stmt) -> str:
     return ast.dump(canonical_statement, annotate_fields=False)
 
 
+def _memoized_statement_dump(
+    statement: ast.stmt,
+    dump_by_statement: dict[ast.stmt, str],
+) -> str:
+    """Return the normalized dump of one statement, computing it at most once.
+
+    The inline scan reads the same statement's dump many times over: once for its
+    enclosing function's block window, once for that function's twin-test
+    multiset, and again for every helper the function is weighed against. Dumping
+    deep-copies the statement subtree before canonicalizing string constants, so
+    this memo serves the repeat reads.
+
+    An ``ast`` node defines no ``__eq__``, so the key is the node's identity and
+    the dict holds a strong reference to it: a key cannot be freed and a later
+    node cannot reuse its slot. The caller owns one memo per scanned file and
+    drops it when the scan returns, so no entry outlives its parse tree.
+
+    Args:
+        statement: The statement node to fingerprint.
+        dump_by_statement: The file's statement-to-dump memo, mutated in place.
+
+    Returns:
+        The value ``_normalized_statement_dump`` returns for this statement.
+    """
+    memoized_dump = dump_by_statement.get(statement)
+    if memoized_dump is None:
+        memoized_dump = _normalized_statement_dump(statement)
+        dump_by_statement[statement] = memoized_dump
+    return memoized_dump
+
+
 def _statement_blocks_in_function(
     function_node: ast.FunctionDef | ast.AsyncFunctionDef,
 ) -> list[list[ast.stmt]]:
@@ -443,78 +490,9 @@ def _total_reachable_statement_count(
     return total_statement_count
 
 
-def _normalized_body_dump_multiset(
-    function_node: ast.FunctionDef | ast.AsyncFunctionDef,
-) -> list[str]:
-    """Return the function's docstring-stripped statement dumps, sorted.
-
-    Used to test whether two functions are structural twins — same statements in
-    any arrangement under string normalization. Sorting makes the comparison
-    order-independent, so two peer helpers that read different inputs but share
-    the same statement shapes compare equal and are left to the cross-file check.
-
-    Args:
-        function_node: The function whose body to fingerprint.
-
-    Returns:
-        The sorted per-statement normalized dumps of the docstring-stripped body.
-    """
-    body_statements = _body_statements_without_docstring(function_node)
-    return sorted(_normalized_statement_dump(each) for each in body_statements)
-
-
-def _function_inlines_window(
-    helper_node: ast.FunctionDef | ast.AsyncFunctionDef,
-    enclosing_node: ast.FunctionDef | ast.AsyncFunctionDef,
-    all_helper_window_dumps: list[str],
-) -> bool:
-    """Return whether a function inlines a helper window inside a larger body.
-
-    Slides a window the length of ``all_helper_window_dumps`` over each reachable
-    statement block in the enclosing function; a window whose per-statement dumps
-    match the helper's, in order, is the inlined copy. Two guards keep the report
-    to the genuine "helper inlined inside a larger function" shape:
-
-    - The enclosing function carries more total reachable statements than the
-      window, so a copy that fills a whole peer function is not reported here. The
-      count spans every nested block, so a window wrapped inside one top-level
-      compound — a ``try``/``finally`` cleanup, an ``except`` handler, or a single
-      ``if`` guard — still clears the guard and is scanned.
-    - The two functions are not structural twins — their docstring-stripped
-      statement multisets differ — so two peer helpers that share a statement
-      shape but read different inputs are left to the cross-file whole-function
-      check ``check_duplicate_function_body_across_files`` rather than reported as
-      an inline duplicate.
-
-    Args:
-        helper_node: The candidate helper whose window is sought.
-        enclosing_node: The candidate enclosing function to scan.
-        all_helper_window_dumps: The helper's substantive-block per-statement dumps.
-
-    Returns:
-        True when some block in the enclosing function contains the helper window
-        verbatim as a contiguous run inside a strictly larger, non-twin body.
-    """
-    window_length = len(all_helper_window_dumps)
-    if _total_reachable_statement_count(enclosing_node) <= window_length:
-        return False
-    if _normalized_body_dump_multiset(helper_node) == _normalized_body_dump_multiset(
-        enclosing_node
-    ):
-        return False
-    for each_block in _statement_blocks_in_function(enclosing_node):
-        if len(each_block) < window_length:
-            continue
-        block_dumps = [_normalized_statement_dump(each) for each in each_block]
-        for each_start_index in range(len(block_dumps) - window_length + 1):
-            window = block_dumps[each_start_index : each_start_index + window_length]
-            if window == all_helper_window_dumps:
-                return True
-    return False
-
-
 def _helper_match_window_dumps(
     function_node: ast.FunctionDef | ast.AsyncFunctionDef,
+    dump_by_statement: dict[ast.stmt, str],
 ) -> list[str] | None:
     """Return the helper's substantive block as per-statement dumps, or None.
 
@@ -564,7 +542,10 @@ def _helper_match_window_dumps(
     )
     if not has_substantial_compound:
         return None
-    return [_normalized_statement_dump(each) for each in match_window]
+    return [
+        _memoized_statement_dump(each_statement, dump_by_statement)
+        for each_statement in match_window
+    ]
 
 
 def check_same_file_inline_duplicate_body(
@@ -616,43 +597,240 @@ def check_same_file_inline_duplicate_body(
         for each_node in tree.body
         if isinstance(each_node, ast.FunctionDef | ast.AsyncFunctionDef)
     ]
-    all_violations_in_walk_order: list[tuple[frozenset[int], str]] = []
-    for each_helper in all_top_level_functions:
-        helper_window_dumps = _helper_match_window_dumps(each_helper)
-        if helper_window_dumps is None:
-            continue
-        for each_enclosing in all_top_level_functions:
-            if each_enclosing is each_helper:
-                continue
-            if not _function_inlines_window(
-                each_helper, each_enclosing, helper_window_dumps
-            ):
-                continue
-            helper_span = _function_definition_span(each_helper)
-            enclosing_span = _function_definition_span(each_enclosing)
-            in_scope_lines = frozenset(helper_span) | frozenset(enclosing_span)
-            span_suffix = SAME_FILE_INLINE_DUPLICATE_SPAN_SUFFIX_TEMPLATE.format(
-                helper_start=helper_span.start,
-                helper_length=len(helper_span),
-                enclosing_start=enclosing_span.start,
-                enclosing_length=len(enclosing_span),
-            )
-            message = (
-                f"Function {each_helper.name!r} duplicates an inline block in "
-                f"{each_enclosing.name!r} — {SAME_FILE_INLINE_DUPLICATE_GUIDANCE} "
-                f"{span_suffix}"
-            )
-            all_violations_in_walk_order.append((in_scope_lines, message))
-            break
-        if len(all_violations_in_walk_order) >= MAX_DUPLICATE_BODY_ISSUES:
-            break
     return _scope_violations_to_changed_lines(
-        all_violations_in_walk_order,
+        _inline_duplicate_violations(all_top_level_functions, MAX_DUPLICATE_BODY_ISSUES),
         all_changed_lines,
         defer_scope_to_caller,
     )
 
 
+def _block_dumps_in_function(
+    function_node: _ModuleScopeFunction,
+    dump_by_statement: dict[ast.stmt, str],
+) -> list[list[str]]:
+    """Return the per-statement dumps of each reachable block in a function.
+
+    Args:
+        function_node: The module-scope function to read.
+        dump_by_statement: The file's statement-to-dump memo, mutated in place.
+
+    Returns:
+        One dump list per reachable block, in block-collection order.
+    """
+    return [
+        [
+            _memoized_statement_dump(each_statement, dump_by_statement)
+            for each_statement in each_block
+        ]
+        for each_block in _statement_blocks_in_function(function_node)
+    ]
+
+
+def _function_scan_profile(
+    function_node: _ModuleScopeFunction,
+    dump_by_statement: dict[ast.stmt, str],
+) -> _FunctionScanProfile:
+    """Take the three readings the inline scan needs from one function.
+
+    The sorted body dumps carry the docstring-stripped statement multiset that
+    tests whether two functions are structural twins. Sorting makes that
+    comparison order-independent, so two peer helpers that read different inputs
+    but share the same statement shapes compare equal and are left to the
+    cross-file check.
+
+    Args:
+        function_node: The module-scope function to read.
+        dump_by_statement: The file's statement-to-dump memo, mutated in place.
+
+    Returns:
+        The function's reachable statement count, sorted body dumps, and
+        per-block statement dumps.
+    """
+    return _FunctionScanProfile(
+        reachable_statement_count=_total_reachable_statement_count(function_node),
+        all_sorted_body_dumps=sorted(
+            _memoized_statement_dump(each_statement, dump_by_statement)
+            for each_statement in _body_statements_without_docstring(function_node)
+        ),
+        all_block_dumps=_block_dumps_in_function(function_node, dump_by_statement),
+    )
+
+
+def _block_dumps_contain_window(
+    all_block_dumps: list[str],
+    all_window_dumps: list[str],
+) -> bool:
+    """Return whether one block carries the window as a contiguous run.
+
+    A block shorter than the window holds no run and answers False.
+
+    Args:
+        all_block_dumps: One reachable block's per-statement dumps.
+        all_window_dumps: The helper's window dumps to seek.
+
+    Returns:
+        True when the window appears in the block as a contiguous run.
+    """
+    window_length = len(all_window_dumps)
+    last_start_index = len(all_block_dumps) - window_length
+    for each_start_index in range(last_start_index + 1):
+        window_end = each_start_index + window_length
+        if all_block_dumps[each_start_index:window_end] == all_window_dumps:
+            return True
+    return False
+
+
+def _profile_inlines_window(
+    helper_profile: _FunctionScanProfile,
+    enclosing_profile: _FunctionScanProfile,
+    all_helper_window_dumps: list[str],
+) -> bool:
+    """Return whether a function inlines a helper window inside a larger body.
+
+    A run inside one of the enclosing function's reachable blocks whose dumps
+    match the helper's, in order, is the inlined copy. Two guards hold the report
+    to a genuine inlining: the enclosing function carries more reachable
+    statements than the window, and the two functions are not structural twins,
+    so peer helpers sharing a statement shape are left to the cross-file check.
+
+    Args:
+        helper_profile: The candidate helper's readings, for the twin guard.
+        enclosing_profile: The candidate enclosing function's readings.
+        all_helper_window_dumps: The helper's substantive-block statement dumps.
+
+    Returns:
+        True when a block carries the window inside a larger, non-twin body.
+    """
+    if enclosing_profile.reachable_statement_count <= len(all_helper_window_dumps):
+        return False
+    if helper_profile.all_sorted_body_dumps == enclosing_profile.all_sorted_body_dumps:
+        return False
+    return any(
+        _block_dumps_contain_window(each_block_dumps, all_helper_window_dumps)
+        for each_block_dumps in enclosing_profile.all_block_dumps
+    )
+
+
+def _first_enclosing_inliner(
+    helper_node: _ModuleScopeFunction,
+    all_helper_window_dumps: list[str],
+    profile_by_function: dict[_ModuleScopeFunction, _FunctionScanProfile],
+) -> _ModuleScopeFunction | None:
+    """Return the first other module-scope function that inlines this window.
+
+    Args:
+        helper_node: The candidate helper whose window is sought.
+        all_helper_window_dumps: The helper's substantive-block statement dumps.
+        profile_by_function: Each function's readings, keyed in source order.
+
+    Returns:
+        The first function in source order that carries the window, or None.
+    """
+    helper_profile = profile_by_function[helper_node]
+    for each_enclosing, each_profile in profile_by_function.items():
+        if each_enclosing is helper_node:
+            continue
+        if _profile_inlines_window(
+            helper_profile, each_profile, all_helper_window_dumps
+        ):
+            return each_enclosing
+    return None
+
+
+def _inline_duplicate_violation(
+    helper_node: _ModuleScopeFunction,
+    enclosing_node: _ModuleScopeFunction,
+) -> tuple[frozenset[int], str]:
+    """Return the scoped lines and report text for one inlined-helper finding.
+
+    Args:
+        helper_node: The helper whose body appears inline elsewhere.
+        enclosing_node: The function carrying the inlined copy.
+
+    Returns:
+        The union of both function spans, and the message naming both.
+    """
+    helper_span = _function_definition_span(helper_node)
+    enclosing_span = _function_definition_span(enclosing_node)
+    span_suffix = SAME_FILE_INLINE_DUPLICATE_SPAN_SUFFIX_TEMPLATE.format(
+        helper_start=helper_span.start,
+        helper_length=len(helper_span),
+        enclosing_start=enclosing_span.start,
+        enclosing_length=len(enclosing_span),
+    )
+    message = (
+        f"Function {helper_node.name!r} duplicates an inline block in "
+        f"{enclosing_node.name!r} — {SAME_FILE_INLINE_DUPLICATE_GUIDANCE} "
+        f"{span_suffix}"
+    )
+    return (frozenset(helper_span) | frozenset(enclosing_span), message)
+
+
+def _violations_for_qualifying_helpers(
+    window_by_function: dict[_ModuleScopeFunction, list[str]],
+    profile_by_function: dict[_ModuleScopeFunction, _FunctionScanProfile],
+    maximum_issue_count: int,
+) -> list[tuple[frozenset[int], str]]:
+    """Walk the helpers in source order and report the first inliner of each.
+
+    Args:
+        window_by_function: Each qualifying function's helper match window.
+        profile_by_function: Each function's readings, keyed in source order.
+        maximum_issue_count: The report ceiling the walk stops at.
+
+    Returns:
+        The in-scope lines and message of each report, in walk order.
+    """
+    all_violations_in_walk_order: list[tuple[frozenset[int], str]] = []
+    for each_helper, each_window_dumps in window_by_function.items():
+        each_enclosing = _first_enclosing_inliner(
+            each_helper, each_window_dumps, profile_by_function
+        )
+        if each_enclosing is not None:
+            all_violations_in_walk_order.append(
+                _inline_duplicate_violation(each_helper, each_enclosing)
+            )
+        if len(all_violations_in_walk_order) >= maximum_issue_count:
+            break
+    return all_violations_in_walk_order
+
+
+def _inline_duplicate_violations(
+    all_top_level_functions: list[_ModuleScopeFunction],
+    maximum_issue_count: int,
+) -> list[tuple[frozenset[int], str]]:
+    """Report every module-scope helper whose body is inlined in another function.
+
+    The dump memo and the per-function readings live for this one call and are
+    dropped when it returns, so no reading outlives the parse tree it describes.
+
+    Args:
+        all_top_level_functions: The module-scope functions in source order.
+        maximum_issue_count: The report ceiling the walk stops at.
+
+    Returns:
+        The in-scope lines and message of each report, in walk order.
+    """
+    dump_by_statement: dict[ast.stmt, str] = {}
+    window_by_function = {
+        each_function: each_window
+        for each_function in all_top_level_functions
+        if (
+            each_window := _helper_match_window_dumps(each_function, dump_by_statement)
+        )
+        is not None
+    }
+    if not window_by_function:
+        return []
+    profile_by_function = {
+        each_function: _function_scan_profile(each_function, dump_by_statement)
+        for each_function in all_top_level_functions
+    }
+    return _violations_for_qualifying_helpers(
+        window_by_function, profile_by_function, maximum_issue_count
+    )
+
+
 def _skill_scripts_root(file_path: str) -> Path | None:
     """Return the ``skills/<name>/scripts`` root the written file sits under.