claude-dev-env 7.7.0 → 8.0.0

package/docs/subagent-model-routing.md

@@ -32,8 +32,11 @@ example, change the `terra` and `medium` entry in `replacements` to:
 
 The next routing call reads the file again. The resolver source stays unchanged.
 
-To keep a pair out of selector panels, add it to `selectorExclusions`. This
-does not block the shared resolver or the spawn hook. For example:
+Selector exclusions keep a pair out of panels. They do not change direct route
+decisions. The shipped policy keeps Sol Medium out of panels and routes direct
+requests for Sol Medium to Luna Max through `replacements`. Sol Medium is absent
+from `approvedPairs`. The selector drops the requested pair before routing it,
+so its Luna replacement does not enter the panel through that preference.
 
 ```json
 "selectorExclusions": [
@@ -41,9 +44,25 @@ does not block the shared resolver or the spawn hook. For example:
 ]
 ```
 
+The matching replacement is:
+
+```json
+{
+  "requested": {"model": "sol", "effort": "medium"},
+  "selected": {"model": "luna", "effort": "max"}
+}
+```
+
 Unknown values, invalid policy data, and unavailable replacement models stop the
 spawn with a short diagnostic. Parent inheritance stays unchanged.
 
+The direct spawn hook and advisor bridge use the same shared resolver. A Sol
+Medium remap changes only the model and effort fields in the hook's tool input.
+The hook returns an allow decision with the updated input and emits no remap
+notice. Luna High, Xhigh, and Max and Astra Low and Medium keep their routes.
+Trusted advisors also keep Astra High. A worker request for Sol without an
+effort stops because Sol has no approved pair to supply a default effort.
+
 The hook blocks advisor role claims because the current Codex hook input has no
 host-provided role binding. The Python advisor bridge passes trusted session
 metadata to the shared resolver. The native advisor hook path stays pending

package/hooks/HOOK_SPECS_PROMPT_WORKFLOW.md

@@ -49,6 +49,4 @@ Generated prompt-workflow outputs must declare, in their audit frontmatter:
 - `base_minimal_instruction_layer: true`
 - `on_demand_skill_loading: true`
 
-The Stop guard blocks responses that omit either signal. These signals are
-the machine-checkable counterpart to the policy text in
-`rules/prompt-workflow-context-controls.md`.
+The Stop guard blocks responses that omit either signal.

package/hooks/blocking/code_rules_constants_config.py

@@ -1,4 +1,4 @@
-"""Constants-outside-config checks and the file-global constant use-count check.
+"""Constants-outside-config checks.
 
 Also carries check_config_duplicate_path_anchor, which flags a config module
 that rebuilds a directory a sibling module in the same package already
@@ -22,7 +22,6 @@ from code_rules_path_utils import (  # noqa: E402
     is_config_file,
 )
 from code_rules_shared import (  # noqa: E402
-    _build_parent_map,
     docstring_line_numbers,
     get_file_extension,
     is_migration_file,
@@ -35,7 +34,6 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
 )
 from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
     ALL_PYTHON_EXTENSIONS,
-    FILE_GLOBAL_UPPER_SNAKE_PATTERN,
 )
 
 
@@ -164,111 +162,6 @@ def check_constants_outside_config_advisory(content: str, file_path: str) -> Non
         sys.stderr.write(f"[CODE_RULES advisory] {file_path}: {each_issue}\n")
 
 
-def _is_upper_snake_constant_name(name: str) -> bool:
-    """Return True for UPPER_SNAKE identifiers including those with a leading underscore."""
-    return bool(FILE_GLOBAL_UPPER_SNAKE_PATTERN.match(name))
-
-
-def _collect_module_level_upper_snake_constants(
-    module_tree: ast.Module,
-) -> dict[str, int]:
-    """Return mapping of module-level UPPER_SNAKE constant name to its line number."""
-    constants_by_name: dict[str, int] = {}
-    for each_node in module_tree.body:
-        if isinstance(each_node, ast.Assign):
-            for each_target in each_node.targets:
-                if isinstance(each_target, ast.Name) and _is_upper_snake_constant_name(each_target.id):
-                    constants_by_name.setdefault(each_target.id, each_node.lineno)
-        elif isinstance(each_node, ast.AnnAssign):
-            if isinstance(each_node.target, ast.Name) and _is_upper_snake_constant_name(each_node.target.id):
-                constants_by_name.setdefault(each_node.target.id, each_node.lineno)
-    return constants_by_name
-
-
-def _resolve_enclosing_function_qname(
-    load_node: ast.Name,
-    parent_by_child_id: dict[int, ast.AST],
-) -> Optional[str]:
-    """Return 'ClassName.function_name' or 'function_name' for the enclosing function.
-
-    Returns None when the reference is at module scope (no enclosing function).
-    Decorator expressions on a function/method count as belonging to that function.
-    """
-    enclosing_function_name: Optional[str] = None
-    enclosing_class_name: Optional[str] = None
-    current_ancestor = parent_by_child_id.get(id(load_node))
-    while current_ancestor is not None:
-        if isinstance(current_ancestor, (ast.FunctionDef, ast.AsyncFunctionDef)) and enclosing_function_name is None:
-            enclosing_function_name = current_ancestor.name
-        elif isinstance(current_ancestor, ast.ClassDef):
-            enclosing_class_name = current_ancestor.name
-            break
-        current_ancestor = parent_by_child_id.get(id(current_ancestor))
-    if enclosing_function_name is None:
-        if enclosing_class_name is not None:
-            return f"<class:{enclosing_class_name}>"
-        return None
-    if enclosing_class_name is not None:
-        return f"{enclosing_class_name}.{enclosing_function_name}"
-    return enclosing_function_name
-
-
-def check_file_global_constants_use_count(content: str, file_path: str) -> list[str]:
-    """Flag module-level UPPER_SNAKE constants referenced by only one function/method.
-
-    Enforces the file-global-constants use-count rule: a constant used by just
-    one caller belongs in that caller's scope. Test files, config files,
-    workflow-registry files, and non-Python files are exempt. Constants with
-    zero references are out of scope. The enforcer entry module
-    (``hooks/blocking/code_rules_enforcer.py``) is exempt to avoid
-    self-blocking.
-    """
-    if is_test_file(file_path):
-        return []
-    if is_config_file(file_path):
-        return []
-    if is_workflow_registry_file(file_path):
-        return []
-    if get_file_extension(file_path) not in ALL_PYTHON_EXTENSIONS:
-        return []
-    if file_path.replace("\\", "/").endswith("hooks/blocking/code_rules_enforcer.py"):
-        return []
-
-    try:
-        module_tree = ast.parse(content)
-    except SyntaxError:
-        return []
-
-    constants_by_name = _collect_module_level_upper_snake_constants(module_tree)
-    if not constants_by_name:
-        return []
-
-    parent_by_child_id = _build_parent_map(module_tree)
-    callers_by_constant: dict[str, set[str]] = {name: set() for name in constants_by_name}
-    for each_node in ast.walk(module_tree):
-        if not isinstance(each_node, ast.Name):
-            continue
-        if not isinstance(each_node.ctx, ast.Load):
-            continue
-        if each_node.id not in callers_by_constant:
-            continue
-        enclosing_qname = _resolve_enclosing_function_qname(each_node, parent_by_child_id)
-        if enclosing_qname is None:
-            callers_by_constant[each_node.id].add("<module-scope>")
-        else:
-            callers_by_constant[each_node.id].add(enclosing_qname)
-
-    issues: list[str] = []
-    for each_constant_name, each_line_number in sorted(constants_by_name.items(), key=lambda pair: pair[1]):
-        caller_count = len(callers_by_constant[each_constant_name])
-        if caller_count == 1:
-            issues.append(
-                f"Line {each_line_number}: File-global constant {each_constant_name} used by only 1 function/method - move to method scope or add a second caller"
-            )
-
-    return issues
-
-
 def _references_dunder_file(node: ast.AST) -> bool:
     """Return True when the expression tree reads ``__file__``."""
     return any(

package/hooks/blocking/code_rules_enforcer.py

@@ -60,7 +60,6 @@ from code_rules_constants_config import (  # noqa: E402
     check_config_duplicate_path_anchor,
     check_constants_outside_config,
     check_constants_outside_config_advisory,
-    check_file_global_constants_use_count,
 )
 from code_rules_docstrings import (  # noqa: E402
     check_class_docstring_names_public_methods,
@@ -358,7 +357,6 @@ def _python_magic_value_and_constant_issues(context: _ValidationContext) -> list
     all_issues.extend(check_fstring_structural_literals(content, file_path))
     all_issues.extend(check_constants_outside_config(content, file_path))
     check_constants_outside_config_advisory(content, file_path)
-    all_issues.extend(check_file_global_constants_use_count(content, file_path))
     return all_issues
 
 
@@ -1240,7 +1238,9 @@ def _deny_reason_for_issues(
     Returns:
         The complete ``permissionDecisionReason`` text.
     """
-    issue_list = "; ".join(all_blocking_issues[:DENY_REASON_ISSUE_PREVIEW_COUNT])
+    issue_list = VIOLATION_SEPARATOR.join(
+        all_blocking_issues[:DENY_REASON_ISSUE_PREVIEW_COUNT]
+    )
     deny_reason = (
         f"BLOCKED: [CODE_RULES] {len(all_blocking_issues)} violation(s): {issue_list}"
     )
@@ -1257,7 +1257,9 @@ def _deny_reason_for_issues(
             all_blocking_issues=all_blocking_issues,
         )
         if forecast_issues:
-            forecast_list = "; ".join(forecast_issues[:DENY_REASON_ISSUE_PREVIEW_COUNT])
+            forecast_list = VIOLATION_SEPARATOR.join(
+                forecast_issues[:DENY_REASON_ISSUE_PREVIEW_COUNT]
+            )
             deny_reason += (
                 f"; FULL-FILE FORECAST — {len(forecast_issues)} additional "
                 "violation(s) elsewhere in this file will block future edits "
@@ -1362,7 +1364,9 @@ def _report_hook_blocking_issues(
     )
     if not all_blocking_issues:
         return
-    issue_list = "; ".join(all_blocking_issues[:DENY_REASON_ISSUE_PREVIEW_COUNT])
+    issue_list = VIOLATION_SEPARATOR.join(
+        all_blocking_issues[:DENY_REASON_ISSUE_PREVIEW_COUNT]
+    )
     deny_reason = (
         f"BLOCKED: [CODE_RULES] {len(all_blocking_issues)} violation(s): {issue_list}"
         + _precheck_hint()

package/hooks/blocking/code_rules_test_layout.py

@@ -10,8 +10,8 @@ test functions, which exports nothing, so a single-file scan proves a constant
 no other line reads is dead. A ``conftest.py``, a shared helper module reached
 only through the ``tests/`` directory gate, and a dedicated constants or
 ``config/`` module all export their constants to importer modules, so the
-audit lane governs their constants cross-module (see
-rules/file-global-constants.md) and this write-time check leaves them alone.
+audit lane governs their constants cross-module and this write-time check
+leaves them alone.
 """
 
 import ast
@@ -54,7 +54,7 @@ def _is_dead_constant_scan_target(file_path: str) -> bool:
     constant no other line reads is dead. A ``conftest.py``, a shared helper
     module reached only through the ``tests/`` directory gate, and a dedicated
     constants or ``config/`` module all export to importer modules, where the
-    cross-module audit lane governs their constants (see rules/file-global-constants.md).
+    cross-module audit lane governs their constants.
 
     Args:
         file_path: The destination path of the write.
@@ -77,8 +77,8 @@ def _is_private_constant_name(name: str) -> bool:
         EXPECTED_TOTAL           ->  public constant, left alone
 
     Only a leading-underscore name qualifies. A public module constant exports
-    to importer modules, so the cross-module audit lane governs it (see
-    rules/file-global-constants.md) and this single-file scan leaves it alone.
+    to importer modules, so the cross-module audit lane governs it and this
+    single-file scan leaves it alone.
     """
     if not name.startswith(PRIVATE_NAME_PREFIX):
         return False
@@ -163,8 +163,7 @@ def check_dead_test_module_constant(content: str, file_path: str) -> list[str]:
     dead scaffolding an edit stranded. A public constant, a ``conftest.py``, a
     shared helper module under ``tests/``, and a dedicated constants or
     ``config/`` module all export to importer modules, so the cross-module
-    audit lane judges those (see rules/file-global-constants.md) and this
-    check skips them.
+    audit lane judges those and this check skips them.
 
     Args:
         content: The post-edit file content under validation.

package/hooks/blocking/test_code_rules_constants_config.py

@@ -24,3 +24,16 @@ def test_module_source_carries_no_docstring_magic_value() -> None:
         "bare-number token that the magic-value check flags as a literal, "
         f"got: {magic_value_issues}"
     )
+
+
+ARCHIVED_USE_COUNT_CHECK_NAME = "check_file_global_constants_use_count"
+
+
+def test_module_defines_no_check_for_an_archived_rule() -> None:
+    module_path = Path(__file__).resolve().parent / "code_rules_constants_config.py"
+    module_source = module_path.read_text(encoding="utf-8")
+    assert ARCHIVED_USE_COUNT_CHECK_NAME not in module_source, (
+        "The file-global constant use-count rule moved to rules-archived, so this "
+        "module must define no check that enforces it. Code left behind keeps "
+        "enforcing a rule the package no longer documents."
+    )

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -71,7 +71,6 @@ KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
         "check_constant_equality_tests",
         "check_constants_outside_config",
         "check_existence_check_tests",
-        "check_file_global_constants_use_count",
         "check_imports_at_top",
         "check_inline_literal_collections",
         "check_join_separator_string_magic",

package/hooks/blocking/test_code_rules_enforcer_dispatch_wiring.py

@@ -173,3 +173,18 @@ def test_known_undispatched_set_lists_only_existing_checks() -> None:
         f"KNOWN_UNDISPATCHED_CHECKS lists functions that no longer exist: "
         f"{sorted(stale_names)}. Restore the function or remove it from the set."
     )
+
+
+ARCHIVED_USE_COUNT_CHECK_NAME = "check_file_global_constants_use_count"
+
+
+def test_enforcer_dispatches_no_check_for_an_archived_rule() -> None:
+    enforcer_source = (_HOOK_DIRECTORY / "code_rules_enforcer.py").read_text(
+        encoding="utf-8"
+    )
+    assert ARCHIVED_USE_COUNT_CHECK_NAME not in enforcer_source, (
+        "The file-global constant use-count rule moved to rules-archived, so the "
+        "enforcer must import and dispatch no check that enforces it. A check "
+        "left wired here blocks a write against a rule the package no longer "
+        "documents."
+    )

package/hooks/blocking/test_code_rules_enforcer_split_constants_config.py

@@ -20,7 +20,6 @@ from code_rules_constants_config import (  # noqa: E402
     _scan_function_body_constants,
     check_constants_outside_config,
     check_constants_outside_config_advisory,
-    check_file_global_constants_use_count,
 )
 
 code_rules_enforcer = SimpleNamespace(
@@ -28,7 +27,6 @@ code_rules_enforcer = SimpleNamespace(
     _scan_function_body_constants=_scan_function_body_constants,
     check_constants_outside_config=check_constants_outside_config,
     check_constants_outside_config_advisory=check_constants_outside_config_advisory,
-    check_file_global_constants_use_count=check_file_global_constants_use_count,
 )
 
 
@@ -37,37 +35,6 @@ CONSTANTS_OUTSIDE_CONFIG_PRODUCTION_FILE_PATH = "packages/app/services/encoding.
 PRODUCTION_FILE_PATH = "packages/claude-dev-env/hooks/blocking/example_production.py"
 
 
-def test_should_flag_constant_used_only_in_class_level_decorator() -> None:
-    source = (
-        "TIMEOUT = 5\n"
-        "\n"
-        "def register(value):\n"
-        "    def wrap(cls):\n"
-        "        return cls\n"
-        "    return wrap\n"
-        "\n"
-        "@register(TIMEOUT)\n"
-        "class Foo:\n"
-        "    pass\n"
-    )
-    issues = code_rules_enforcer.check_file_global_constants_use_count(
-        source, PRODUCTION_FILE_PATH
-    )
-    assert any(
-        "TIMEOUT" in issue and "only 1 function/method" in issue for issue in issues
-    ), f"Expected class-decorator usage to register as a caller, got: {issues}"
-
-
-def test_should_flag_constant_used_once_at_module_scope_and_once_in_function() -> None:
-    source = "UPPER = 1\nSHADOW = UPPER\n\ndef lonely_caller():\n    return UPPER\n"
-    issues = code_rules_enforcer.check_file_global_constants_use_count(
-        source, PRODUCTION_FILE_PATH
-    )
-    assert issues == [], (
-        f"Expected module-scope + function usage to count as 2 distinct callers, got: {issues}"
-    )
-
-
 def test_is_exempt_for_advisory_scan_returns_true_for_config_file() -> None:
     assert code_rules_enforcer._is_exempt_for_advisory_scan("project/config/constants.py") is True
 
@@ -241,30 +208,3 @@ def test_check_constants_outside_config_reports_more_than_three_constants() -> N
     )
 
 
-_SINGLE_CALLER_CONSTANT_SOURCE = (
-    "TIMEOUT = 5\n"
-    "\n"
-    "def lonely_caller() -> int:\n"
-    "    return TIMEOUT\n"
-)
-
-_ENFORCER_ENTRY_FILE_PATH = "packages/claude-dev-env/hooks/blocking/code_rules_enforcer.py"
-
-
-def test_use_count_flags_single_caller_constant_for_ordinary_production_path() -> None:
-    issues = code_rules_enforcer.check_file_global_constants_use_count(
-        _SINGLE_CALLER_CONSTANT_SOURCE, PRODUCTION_FILE_PATH
-    )
-    assert any(
-        "TIMEOUT" in issue and "only 1 function/method" in issue for issue in issues
-    ), f"Expected single-caller constant flagged on an ordinary production path, got: {issues}"
-
-
-def test_use_count_exempts_enforcer_entry_module_path() -> None:
-    issues = code_rules_enforcer.check_file_global_constants_use_count(
-        _SINGLE_CALLER_CONSTANT_SOURCE, _ENFORCER_ENTRY_FILE_PATH
-    )
-    assert issues == [], (
-        "The enforcer entry module must be exempt to avoid self-blocking, "
-        f"got: {issues}"
-    )

package/hooks/blocking/test_context_control_policy_files.py

@@ -4,20 +4,9 @@ from pathlib import Path
 
 
 ROOT = Path(__file__).resolve().parents[2]
-RULE_PATH = ROOT / "rules" / "prompt-workflow-context-controls.md"
 HOOK_SPEC_PATH = ROOT / "hooks" / "HOOK_SPECS_PROMPT_WORKFLOW.md"
 
 
-def test_context_control_rule_exists_with_required_sections() -> None:
-    text = RULE_PATH.read_text(encoding="utf-8")
-    assert "Base Minimal Instruction Layer" in text
-    assert "On-Demand Skill Loading" in text
-    assert "Compaction and Caching Strategy" in text
-    assert "Runtime Enforcement Signals" in text
-    assert "base_minimal_instruction_layer: true" in text
-    assert "on_demand_skill_loading: true" in text
-
-
 def test_hook_spec_exists_with_required_gates() -> None:
     text = HOOK_SPEC_PATH.read_text(encoding="utf-8")
     assert "PreToolUse Task/Agent (removed)" in text

package/hooks/hooks_constants/blocking_check_limits.py

@@ -2,7 +2,7 @@
 
 Each constant is consumed by exactly one check function in the enforcer. They
 live here (not at module scope of the enforcer) so the enforcer file stays
-under the file-global-constants use-count rule (CODE_RULES §file-global-constants).
+because each has more than one consumer in this package.
 """
 
 from __future__ import annotations

package/hooks/hooks_constants/code_rules_enforcer_constants.py

@@ -185,7 +185,6 @@ DEAD_SPLIT_BRANCH_MESSAGE_SUFFIX: str = (
 )
 DUPLICATED_FORMAT_MINIMUM_REPETITION_COUNT = 3
 DUPLICATED_FORMAT_MINIMUM_LITERAL_CHARACTER_COUNT = 5
-FILE_GLOBAL_UPPER_SNAKE_PATTERN = re.compile(r"^_?[A-Z][A-Z0-9_]*$")
 
 ALL_COLLECTION_TYPE_NAMES: frozenset[str] = frozenset({
     "list", "tuple", "set", "frozenset",

package/hooks/hooks_constants/setup_project_paths_constants.py

@@ -1,8 +1,7 @@
 """Configuration constants for the setup_project_paths bootstrap script.
 
 Shared constants consumed by two or more modules across the hook subsystem.
-Single-use values are inlined into their consuming functions per the
-file-global-constants use-count rule.
+Single-use values are inlined into their consuming functions.
 """
 
 from __future__ import annotations

package/hooks/routing/subagent_model_routing.test.mjs

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { test } from 'node:test';
 import { fileURLToPath } from 'node:url';
 
@@ -11,22 +11,22 @@ function buildHookPayload(toolInput, metadata = {}) {
     return { tool_name: targetToolName, tool_input: toolInput, ...metadata };
 }
 
-test('remaps Terra Medium to Luna Xhigh', () => {
+test('remaps Sol Medium to Luna Max', () => {
     const hookResponse = buildSubagentModelRoutingResponse(buildHookPayload({
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'Medium',
     }));
 
     assert.equal(hookResponse.hookSpecificOutput.updatedInput.model, 'gpt-5.6-luna');
     assert.equal(
         hookResponse.hookSpecificOutput.updatedInput.reasoning_effort,
-        'xhigh',
+        'max',
     );
 });
 
 test('emits only the allow response shape after a remap', () => {
     const hookResponse = buildSubagentModelRoutingResponse(buildHookPayload({
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
     }));
 
@@ -41,7 +41,7 @@ test('emits only the allow response shape after a remap', () => {
         permissionDecision: 'allow',
         updatedInput: {
             model: 'gpt-5.6-luna',
-            reasoning_effort: 'xhigh',
+            reasoning_effort: 'max',
         },
     });
 });
@@ -52,7 +52,7 @@ test('preserves every non-routing tool field', () => {
         message: 'do the work',
         child_permissions: { shell: 'ask' },
         output_contract: ['summary'],
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
     };
 
@@ -64,14 +64,14 @@ test('preserves every non-routing tool field', () => {
         child_permissions: { shell: 'ask' },
         output_contract: ['summary'],
         model: 'gpt-5.6-luna',
-        reasoning_effort: 'xhigh',
+        reasoning_effort: 'max',
     });
     assert.deepEqual(toolInput, {
         assignment: 'preserve',
         message: 'do the work',
         child_permissions: { shell: 'ask' },
         output_contract: ['summary'],
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
     });
 });
@@ -94,8 +94,8 @@ test('blocks malformed policy, unknown input, unavailable replacement, and untru
         buildHookPayload({ model: 'Unknown', reasoning_effort: 'medium' }),
     );
     const unavailableReplacementResponse = buildSubagentModelRoutingResponse(
-        buildHookPayload({ model: 'Terra', reasoning_effort: 'medium' }),
-        { availableModelIds: ['gpt-5.6-terra'] },
+        buildHookPayload({ model: 'Sol', reasoning_effort: 'medium' }),
+        { availableModelIds: ['gpt-5.6-sol'] },
     );
     const untrustedAdvisorResponse = buildSubagentModelRoutingResponse(
         buildHookPayload({
@@ -122,25 +122,62 @@ test('blocks malformed policy, unknown input, unavailable replacement, and untru
     }
 });
 
-test('allows a registered session advisor with trusted session metadata', () => {
-    const hookResponse = buildSubagentModelRoutingResponse(
-        buildHookPayload({
+for (const [eachModel, eachEffort, eachSelectedModel, eachSelectedEffort] of [
+    ['Sol', 'medium', 'gpt-5.6-luna', 'max'],
+    ['Astra', 'high', 'gpt-6-astra', 'high'],
+]) {
+    test(`allows a trusted session advisor requesting ${eachModel} ${eachEffort}`, () => {
+        const hookResponse = buildSubagentModelRoutingResponse(
+            buildHookPayload({
+                agent_type: 'session-advisor',
+                model: eachModel,
+                reasoning_effort: eachEffort,
+            }),
+            {
+                trustedSessionMetadata: {
+                    authorized: true,
+                    registeredAgentType: 'session-advisor',
+                },
+            },
+        );
+
+        assert.deepEqual(hookResponse.hookSpecificOutput.updatedInput, {
             agent_type: 'session-advisor',
-            model: 'Astra',
-            reasoning_effort: 'high',
-        }),
+            model: eachSelectedModel,
+            reasoning_effort: eachSelectedEffort,
+        });
+    });
+}
+
+test('the standalone hook silently remaps native Sol Medium and preserves other fields', () => {
+    const hookExecution = spawnSync(
+        process.execPath,
+        [fileURLToPath(new URL('./subagent_model_routing.mjs', import.meta.url))],
         {
-            trustedSessionMetadata: {
-                authorized: true,
-                registeredAgentType: 'session-advisor',
-            },
+            encoding: 'utf8',
+            input: JSON.stringify(buildHookPayload({
+                model: 'gpt-5.6-sol',
+                effort: 'medium',
+                message: 'keep',
+                child_permissions: { shell: 'ask' },
+                output_contract: ['summary'],
+            })),
         },
     );
-
-    assert.deepEqual(hookResponse.hookSpecificOutput.updatedInput, {
-        agent_type: 'session-advisor',
-        model: 'gpt-6-astra',
-        reasoning_effort: 'high',
+    assert.equal(hookExecution.status, 0);
+    assert.equal(hookExecution.stderr, '');
+    assert.deepEqual(JSON.parse(hookExecution.stdout), {
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'allow',
+            updatedInput: {
+                model: 'gpt-5.6-luna',
+                effort: 'max',
+                message: 'keep',
+                child_permissions: { shell: 'ask' },
+                output_contract: ['summary'],
+            },
+        },
     });
 });
 
@@ -201,7 +238,7 @@ test('the standalone hook command blocks an advisor without host metadata', () =
 
 test('keeps a second routing pass unchanged', () => {
     const firstResponse = buildSubagentModelRoutingResponse(buildHookPayload({
-        model: 'Terra',
+        model: 'Sol',
         reasoning_effort: 'medium',
         message: 'keep',
     }));
@@ -212,7 +249,7 @@ test('keeps a second routing pass unchanged', () => {
     assert.deepEqual(secondResponse, {});
     assert.deepEqual(firstResponse.hookSpecificOutput.updatedInput, {
         model: 'gpt-5.6-luna',
-        reasoning_effort: 'xhigh',
+        reasoning_effort: 'max',
         message: 'keep',
     });
 });

package/hooks/session/test_untracked_repo_detector.py

@@ -151,7 +151,7 @@ class TestSharedRegistryPath:
     def test_config_file_path_not_a_module_level_attribute(self) -> None:
         """Pin PR #230 round 7: _CONFIG_FILE_PATH inlined into _build_confirm_instruction.
 
-        Single-consumer module-level constant moved to local per file-global-constants rule.
+        Single-consumer module-level constant kept in the scope that reads it.
         """
         assert not hasattr(detector, "_CONFIG_FILE_PATH")