claude-dev-env 2.35.0 → 2.36.0

package/bin/select-pstack-models.test.mjs

@@ -0,0 +1,378 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    allPstackRoleRequirements,
+    selectPstackDelegation,
+} from '../scripts/select_pstack_models.mjs';
+
+const ALL_PSTACK_ROLES = [
+    'feature, refactoring',
+    'bug-fix',
+    'perf-issue',
+    'hillclimb',
+    'judgment and prose',
+    'hardest tasks',
+    'how explorer',
+    'how explainer',
+    'how critics',
+    'why investigators',
+    'why synthesizer',
+    'reflect tooling',
+    'reflect judgment, divergent, synthesizer',
+    'arena runners',
+    'arena cross-judge pool',
+    'swarm workers',
+    'architect runners',
+    'interrogate reviewers',
+];
+
+function writeHostPreferences(preferencesDirectory, host, modelsByRole) {
+    mkdirSync(preferencesDirectory, { recursive: true });
+    writeFileSync(
+        join(preferencesDirectory, 'pstack-model-preferences.' + host + '.json'),
+        JSON.stringify({ host, modelsByRole }),
+    );
+}
+
+function selectWithPreferences(preferencesDirectory, overrides) {
+    return selectPstackDelegation({
+        host: 'codex',
+        inventoryHost: 'codex',
+        role: 'feature, refactoring',
+        delegationIndex: 0,
+        availableModelIds: ['gpt-5.6-sol'],
+        confirmedSuitableModelIds: [],
+        parentFallback: {
+            isAllowed: false,
+            hasMaterialCapabilityLoss: false,
+        },
+        preferencesDirectory,
+        ...overrides,
+    });
+}
+
+test('portable policy represents every pstack role without model ids', () => {
+    assert.deepEqual(Object.keys(allPstackRoleRequirements), ALL_PSTACK_ROLES);
+    const serializedRequirements = JSON.stringify(allPstackRoleRequirements);
+    assert.doesNotMatch(serializedRequirements, /gpt-|claude-|grok-/i);
+});
+
+test('Codex preferences select every available model in a diverse panel', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-codex-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'how critics': ['gpt-5.6-terra', 'gpt-5.6-sol', 'gpt-6-astra'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'how critics',
+            delegationIndex: 1,
+            availableModelIds: ['gpt-5.6-sol', 'gpt-6-astra', 'gpt-5.6-terra'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.equal(selection.selectedHost, 'codex');
+        assert.equal(selection.selectionSource, 'host-preference');
+        assert.deepEqual(selection.panel.selectedModelIds, [
+            'gpt-5.6-terra',
+            'gpt-5.6-sol',
+            'gpt-6-astra',
+        ]);
+        assert.equal(selection.panel.isCrossModelDiverse, true);
+        assert.deepEqual(selection.nativeSpawnArguments, { model: 'gpt-5.6-sol' });
+        assert.equal(selection.omitNativeModelArgument, false);
+        assert.equal(selection.availabilityValidated, true);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a foreign host reads only its own saved preferences', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-host-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['gpt-5.6-sol'],
+        });
+        writeHostPreferences(preferencesDirectory, 'claude', {
+            'feature, refactoring': ['confirmed-claude-model'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            host: 'claude',
+            inventoryHost: 'claude',
+            availableModelIds: ['confirmed-claude-model', 'gpt-5.6-sol'],
+        });
+        assert.equal(selection.selectedHost, 'claude');
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'confirmed-claude-model',
+        });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('an unavailable preferred model uses a confirmed host alternative', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-alternative-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['gpt-5.6-sol'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            availableModelIds: ['confirmed-current-model'],
+            confirmedSuitableModelIds: ['confirmed-current-model'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.equal(selection.selectionSource, 'confirmed-host-alternative');
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'confirmed-current-model',
+        });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('the arena cross-judge pool selects one model other than the parent', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-judge-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'arena cross-judge pool': ['gpt-5.6-sol', 'gpt-6-astra'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'arena cross-judge pool',
+            parentModelId: 'gpt-5.6-sol',
+            availableModelIds: ['gpt-5.6-sol', 'gpt-6-astra'],
+        });
+        assert.equal(selection.panel.agentCount, 1);
+        assert.deepEqual(selection.nativeSpawnArguments, { model: 'gpt-6-astra' });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+test('the arena cross-judge prefers a real alternative over parent inheritance', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-judge-parent-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'arena cross-judge pool': ['auto', 'confirmed-other-model'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'arena cross-judge pool',
+            parentModelId: 'current-parent-model',
+            availableModelIds: ['confirmed-other-model'],
+            parentFallback: {
+                isAllowed: true,
+                hasMaterialCapabilityLoss: false,
+            },
+        });
+        assert.deepEqual(selection.nativeSpawnArguments, {
+            model: 'confirmed-other-model',
+        });
+        assert.equal(selection.omitNativeModelArgument, false);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a same-model swarm reports its actual panel composition', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-swarm-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'swarm workers': ['gpt-5.6-luna'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'swarm workers',
+            delegationIndex: 2,
+            panel: {
+                agentCount: 4,
+                requiresDistinctModels: false,
+            },
+            availableModelIds: ['gpt-5.6-luna'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.equal(selection.panel.agentCount, 4);
+        assert.deepEqual(selection.panel.selectedModelIds, [
+            'gpt-5.6-luna',
+            'gpt-5.6-luna',
+            'gpt-5.6-luna',
+            'gpt-5.6-luna',
+        ]);
+        assert.equal(selection.panel.isCrossModelDiverse, false);
+        assert.deepEqual(selection.nativeSpawnArguments, { model: 'gpt-5.6-luna' });
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('a diversity-required panel fails without enough distinct real models', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-diversity-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'interrogate reviewers': ['gpt-5.6-terra', 'auto', 'gpt-5.6-sol'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'interrogate reviewers',
+            availableModelIds: ['gpt-5.6-terra', 'gpt-5.6-sol'],
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.equal(selection.requiresUserChoice, true);
+        assert.equal(selection.failure, 'distinct-models-unavailable');
+        assert.equal(selection.panel.isCrossModelDiverse, false);
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('parent inheritance omits the native model argument', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-parent-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'feature, refactoring': ['inherit-parent'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            availableModelIds: [],
+            parentFallback: {
+                isAllowed: true,
+                hasMaterialCapabilityLoss: false,
+            },
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.equal(selection.selectionSource, 'parent-inheritance');
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+        assert.equal(selection.omitNativeModelArgument, true);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('material capability loss requires a user choice before inheritance', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-parent-loss-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'hardest tasks': ['inherit-parent'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'hardest tasks',
+            availableModelIds: [],
+            parentFallback: {
+                isAllowed: true,
+                hasMaterialCapabilityLoss: true,
+            },
+        });
+        assert.equal(selection.canDelegate, false);
+        assert.equal(selection.requiresUserChoice, true);
+        assert.equal(selection.failure, 'parent-capability-loss');
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('inventory and confirmed alternatives must belong to the selected host', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-inventory-'));
+    try {
+        assert.throws(
+            () => selectWithPreferences(preferencesDirectory, {
+                host: 'codex',
+                inventoryHost: 'claude',
+            }),
+            /inventory host must match selected host/,
+        );
+        assert.throws(
+            () => selectWithPreferences(preferencesDirectory, {
+                availableModelIds: ['confirmed-current-model'],
+                confirmedSuitableModelIds: ['missing-model'],
+            }),
+            /confirmed suitable models must be available/,
+        );
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('an empty model set materializes allowed parent inheritance', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-empty-parent-'));
+    try {
+        const selection = selectWithPreferences(preferencesDirectory, {
+            availableModelIds: [],
+            parentFallback: {
+                isAllowed: true,
+                hasMaterialCapabilityLoss: false,
+            },
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.equal(selection.selectionSource, 'parent-inheritance');
+        assert.deepEqual(selection.panel.selectedModelIds, [null]);
+        assert.equal(selection.omitNativeModelArgument, true);
+        assert.deepEqual(selection.nativeSpawnArguments, {});
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('delegation index and fallback flags require exact boundary types', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-boundary-'));
+    try {
+        for (const invalidIndex of [undefined, Number.NaN, 0.5, -1]) {
+            assert.throws(
+                () => selectWithPreferences(preferencesDirectory, {
+                    delegationIndex: invalidIndex,
+                }),
+                /delegation index must be a non-negative integer/,
+            );
+        }
+        for (const invalidRole of ['toString', ['feature, refactoring']]) {
+            assert.throws(
+                () => selectWithPreferences(preferencesDirectory, {
+                    role: invalidRole,
+                }),
+                /role must name a portable pstack role/,
+            );
+        }
+        assert.throws(
+            () => selectWithPreferences(preferencesDirectory, {
+                parentFallback: {
+                    isAllowed: 'yes',
+                    hasMaterialCapabilityLoss: false,
+                },
+            }),
+            /parent fallback flags must be booleans/,
+        );
+        assert.throws(
+            () => selectWithPreferences(preferencesDirectory, {
+                parentFallback: {
+                    isAllowed: true,
+                },
+            }),
+            /parent fallback flags must be booleans/,
+        );
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});
+
+test('an optional-diversity review panel reports repeated models', () => {
+    const preferencesDirectory = mkdtempSync(join(tmpdir(), 'pstack-review-panel-'));
+    try {
+        writeHostPreferences(preferencesDirectory, 'codex', {
+            'how critics': ['gpt-5.6-sol'],
+        });
+        const selection = selectWithPreferences(preferencesDirectory, {
+            role: 'how critics',
+            delegationIndex: 2,
+            panel: {
+                agentCount: 3,
+                requiresDistinctModels: false,
+            },
+            availableModelIds: ['gpt-5.6-sol'],
+        });
+        assert.equal(selection.canDelegate, true);
+        assert.deepEqual(selection.panel.selectedModelIds, [
+            'gpt-5.6-sol',
+            'gpt-5.6-sol',
+            'gpt-5.6-sol',
+        ]);
+        assert.equal(selection.panel.isCrossModelDiverse, false);
+    } finally {
+        rmSync(preferencesDirectory, { recursive: true, force: true });
+    }
+});

package/hooks/hooks_constants/tool_names.py

@@ -0,0 +1,20 @@
+"""Shared names for mutation and shell tools."""
+
+from __future__ import annotations
+
+BASH_TOOL_NAME: str = "Bash"
+POWERSHELL_TOOL_NAME: str = "PowerShell"
+WRITE_TOOL_NAME: str = "Write"
+EDIT_TOOL_NAME: str = "Edit"
+MULTI_EDIT_TOOL_NAME: str = "MultiEdit"
+APPLY_PATCH_TOOL_NAME: str = "apply_patch"
+
+ALL_BASH_AND_POWERSHELL_TOOL_NAMES: frozenset[str] = frozenset(
+    {BASH_TOOL_NAME, POWERSHELL_TOOL_NAME}
+)
+ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES: frozenset[str] = frozenset(
+    {WRITE_TOOL_NAME, EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME}
+)
+ALL_WRITE_EDIT_MULTI_EDIT_APPLY_PATCH_TOOL_NAMES: frozenset[str] = frozenset(
+    ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES | {APPLY_PATCH_TOOL_NAME}
+)

package/hooks/validators/fast_save_validators.py

@@ -14,7 +14,7 @@ the CLI mode calls. A save-path finding matches the CLI mode's finding for
 the same validator; only Mypy and the process-per-check overhead are gone.
 """
 
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Collection, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -125,92 +125,61 @@ class _FastSaveValidatorSpecification:
     no_matching_files_message: str
 
 
-def _all_fast_save_validator_specifications() -> (
-    "tuple[_FastSaveValidatorSpecification, ...]"
-):
-    """Return the save-path roster: every non-Mypy, non-Ruff file-scoped check."""
+def _build_specification(
+    display_name: str,
+    checks: str,
+    applies_to_file: FilePredicate,
+    collect_violation_lines: FileViolationLineCollector,
+    no_matching_files_message: str,
+) -> _FastSaveValidatorSpecification:
+    return _FastSaveValidatorSpecification(
+        display_name,
+        checks,
+        applies_to_file,
+        collect_violation_lines,
+        no_matching_files_message,
+    )
+
+
+def _python_specifications() -> tuple[_FastSaveValidatorSpecification, ...]:
+    return (
+        _build_specification("Python Style", "1,2,3,4", _is_python_file, _violation_lines_from(validate_python_style_file), NO_PYTHON_FILES_MESSAGE),
+        _build_specification("Abbreviations", "5", _is_python_file, _violation_lines_from(validate_abbreviation_file), NO_PYTHON_FILES_MESSAGE),
+        _build_specification("Magic Values", "7", _is_python_file, _violation_lines_from(validate_magic_literal_file), NO_PYTHON_FILES_MESSAGE),
+        _build_specification("Security", "27,28,29", _is_python_file, _violation_lines_from(validate_security_file), NO_PYTHON_FILES_MESSAGE),
+        _build_specification("Code Quality", "30,31,32", _is_python_file, _violation_lines_from(validate_code_quality_file), NO_PYTHON_FILES_MESSAGE),
+        _build_specification("Python Anti-patterns", "33,34,35", _is_python_file, _violation_lines_from(validate_python_antipattern_file), NO_PYTHON_FILES_MESSAGE),
+        _build_specification("Type Safety", "39,40", _is_python_file, _violation_lines_from(validate_type_safety_file), NO_PYTHON_FILES_MESSAGE),
+    )
+
+
+def _test_specifications() -> tuple[_FastSaveValidatorSpecification, ...]:
+    return (
+        _build_specification("Test Safety", "11,21", _is_test_python_file, _collect_test_safety_violation_lines, NO_TEST_FILES_MESSAGE),
+        _build_specification("Useless Tests", "12", _is_test_python_file, _violation_lines_from(validate_useless_test_file), NO_TEST_FILES_MESSAGE),
+    )
+
+
+def _non_python_specifications() -> tuple[_FastSaveValidatorSpecification, ...]:
     return (
-        # Python naming, style, and constants.
-        _FastSaveValidatorSpecification(
-            "Python Style",
-            "1,2,3,4",
-            _is_python_file,
-            _violation_lines_from(validate_python_style_file),
-            NO_PYTHON_FILES_MESSAGE,
-        ),
-        _FastSaveValidatorSpecification(
-            "Abbreviations",
-            "5",
-            _is_python_file,
-            _violation_lines_from(validate_abbreviation_file),
-            NO_PYTHON_FILES_MESSAGE,
-        ),
-        _FastSaveValidatorSpecification(
-            "Magic Values",
-            "7",
-            _is_python_file,
-            _violation_lines_from(validate_magic_literal_file),
-            NO_PYTHON_FILES_MESSAGE,
-        ),
-        _FastSaveValidatorSpecification(
-            "Security",
-            "27,28,29",
-            _is_python_file,
-            _violation_lines_from(validate_security_file),
-            NO_PYTHON_FILES_MESSAGE,
-        ),
-        _FastSaveValidatorSpecification(
-            "Code Quality",
-            "30,31,32",
-            _is_python_file,
-            _violation_lines_from(validate_code_quality_file),
-            NO_PYTHON_FILES_MESSAGE,
-        ),
-        # Python anti-patterns and typing.
-        _FastSaveValidatorSpecification(
-            "Python Anti-patterns",
-            "33,34,35",
-            _is_python_file,
-            _violation_lines_from(validate_python_antipattern_file),
-            NO_PYTHON_FILES_MESSAGE,
-        ),
-        _FastSaveValidatorSpecification(
-            "Type Safety",
-            "39,40",
-            _is_python_file,
-            _violation_lines_from(validate_type_safety_file),
-            NO_PYTHON_FILES_MESSAGE,
-        ),
-        # Scoped to a test_*.py-shaped file.
-        _FastSaveValidatorSpecification(
-            "Test Safety",
-            "11,21",
-            _is_test_python_file,
-            _collect_test_safety_violation_lines,
-            NO_TEST_FILES_MESSAGE,
-        ),
-        _FastSaveValidatorSpecification(
-            "Useless Tests",
-            "12",
-            _is_test_python_file,
-            _violation_lines_from(validate_useless_test_file),
-            NO_TEST_FILES_MESSAGE,
-        ),
-        # Non-Python or multi-language files.
-        _FastSaveValidatorSpecification(
-            "React",
-            "17",
-            _is_react_file,
-            _collect_react_violation_lines,
-            NO_REACT_FILES_MESSAGE,
-        ),
-        _FastSaveValidatorSpecification(
-            "PR References",
-            "6",
-            _is_code_reference_file,
-            _violation_lines_from(validate_pr_reference_file),
-            NO_CODE_REFERENCE_FILES_MESSAGE,
-        ),
+        _build_specification("React", "17", _is_react_file, _collect_react_violation_lines, NO_REACT_FILES_MESSAGE),
+        _build_specification("PR References", "6", _is_code_reference_file, _violation_lines_from(validate_pr_reference_file), NO_CODE_REFERENCE_FILES_MESSAGE),
+    )
+
+
+def _all_fast_save_validator_specifications(
+    excluded_validator_names: Collection[str] = (),
+) -> tuple[_FastSaveValidatorSpecification, ...]:
+    """Return the save-path roster: every non-Mypy, non-Ruff file-scoped check."""
+    all_specifications = (
+        *_python_specifications(),
+        *_test_specifications(),
+        *_non_python_specifications(),
+    )
+    return tuple(
+        each_specification
+        for each_specification in all_specifications
+        if each_specification.display_name not in excluded_validator_names
     )
 
 
@@ -250,11 +219,14 @@ def _run_specification(
     return _fast_save_outcome(specification, False, violation_report)
 
 
-def run_fast_save_validators(files: "list[Path]") -> "list[ValidatorResult]":
+def run_fast_save_validators(
+    files: "list[Path]", excluded_validator_names: Collection[str] = ()
+) -> "list[ValidatorResult]":
     """Run every save-path validator in-process, skipping Mypy and Ruff.
 
     Args:
-        files: The files under validation -- one reconstructed file in gate mode.
+        files: Files under validation. Gate mode passes one reconstructed file.
+        excluded_validator_names: Display names omitted from this run.
 
     Returns:
         One result per in-process validator, in roster order. The caller adds
@@ -262,5 +234,7 @@ def run_fast_save_validators(files: "list[Path]") -> "list[ValidatorResult]":
     """
     return [
         _run_specification(each_specification, files)
-        for each_specification in _all_fast_save_validator_specifications()
+        for each_specification in _all_fast_save_validator_specifications(
+            excluded_validator_names
+        )
     ]

package/hooks/validators/run_all_validators.py

@@ -19,7 +19,7 @@ from dataclasses import dataclass
 from functools import lru_cache
 from datetime import datetime
 from pathlib import Path
-from typing import Callable, Dict, List, Optional, Tuple
+from typing import Callable, Collection, Dict, List, Optional, Tuple
 
 from ._path_setup import hooks_directory_on_path  # noqa: F401
 from .config.baseline_identity_constants import (
@@ -51,7 +51,7 @@ from blocking.codex_apply_patch import (
     parse_codex_apply_patch,
     payload_patch_command,
 )
-from hooks_constants.pre_tool_use_dispatcher_constants import (
+from hooks_constants.tool_names import (
     APPLY_PATCH_TOOL_NAME,
 )
 from hooks_constants.hook_block_logger import log_hook_block
@@ -885,6 +885,8 @@ def validate_proposed_file(
     file_path: str,
     proposed_content: str,
     config_source_path: Optional[Path] = None,
+    include_ruff: bool = True,
+    excluded_validator_names: Collection[str] = (),
 ) -> List[ValidatorResult]:
     """Validate *proposed_content* as if written to *file_path*.
 
@@ -901,10 +903,12 @@ def validate_proposed_file(
         proposed_content: The reconstructed post-edit content of that file.
         config_source_path: Path Ruff resolves its config from; defaults to
             *file_path* when the caller passes nothing.
+        include_ruff: Whether to run Ruff after the in-process validators.
+        excluded_validator_names: Display names omitted from the in-process run.
 
     Returns:
-        One ValidatorResult per save-path check, plus Ruff. Mypy never runs
-        here; CLI/full mode is the only caller that still runs it.
+        One ValidatorResult per in-process check, plus Ruff when requested.
+        Mypy never runs here; CLI/full mode is the only caller that still runs it.
     """
     with tempfile.TemporaryDirectory() as temporary_directory:
         temporary_file = _temporary_path_preserving_directory_signal(
@@ -916,10 +920,14 @@ def validate_proposed_file(
             if config_source_path is not None
             else Path(file_path)
         )
-        return [
-            *run_fast_save_validators([temporary_file]),
-            run_ruff_checks([temporary_file], resolved_config_source_path),
-        ]
+        all_results = run_fast_save_validators(
+            [temporary_file], excluded_validator_names
+        )
+        if include_ruff:
+            all_results.append(
+                run_ruff_checks([temporary_file], resolved_config_source_path)
+            )
+        return all_results
 
 
 def _validator_summaries(results: List[ValidatorResult]) -> str:

package/hooks/validators/test_fast_save_validators_policy_lint.py

@@ -0,0 +1,25 @@
+"""Prove the fast-save validator seam can omit native or duplicate checks."""
+
+from pathlib import Path
+
+from .fast_save_validators import run_fast_save_validators
+
+_CLEAN_SOURCE = (
+    "def add_two_numbers(first_number: int, second_number: int) -> int:\n"
+    "    return first_number + second_number\n"
+)
+_OVERLAPPING_VALIDATOR_NAMES = frozenset(
+    {"Python Style", "Magic Values", "Type Safety", "Test Safety", "React"}
+)
+
+
+def test_fast_save_validators_excludes_requested_outcomes(tmp_path: Path) -> None:
+    target_path = tmp_path / "probe.py"
+    target_path.write_text(_CLEAN_SOURCE, encoding="utf-8")
+    all_results = run_fast_save_validators(
+        [target_path], _OVERLAPPING_VALIDATOR_NAMES
+    )
+
+    all_result_names = {each_result.name for each_result in all_results}
+    assert all_result_names.isdisjoint(_OVERLAPPING_VALIDATOR_NAMES)
+    assert "Abbreviations" in all_result_names