claude-dev-env 2.15.0 → 2.15.1

package/scripts/test_dispatcher_profile_import.py

@@ -0,0 +1,184 @@
+"""Exercise the installed dispatcher layout in isolated profile trees."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+_DISPATCHER_NAMES = ("resolve_worker_spawn.py", "invoke_code_review.py")
+_SHARED_DIRECTORY_NAMES = ("advisor", "process-tree")
+
+
+def _stage_profile_tree(
+    source_package_directory: Path, target_profile_directory: Path
+) -> Path:
+    source_scripts_directory = source_package_directory / "scripts"
+    target_scripts_directory = target_profile_directory / "scripts"
+    shutil.copytree(source_scripts_directory, target_scripts_directory)
+    for each_shared_name in _SHARED_DIRECTORY_NAMES:
+        source_shared_directory = (
+            source_package_directory / "_shared" / each_shared_name
+        )
+        target_shared_directory = (
+            target_profile_directory / "_shared" / each_shared_name
+        )
+        shutil.copytree(source_shared_directory, target_shared_directory)
+    return target_scripts_directory
+
+
+def _stage_shadow_import_root(
+    target_profile_directory: Path, dispatcher_module_name: str
+) -> Path:
+    shadow_import_root = (
+        target_profile_directory / f"shadow-import-root-{dispatcher_module_name}"
+    )
+    shadow_import_root.mkdir()
+    (shadow_import_root / "tier_model_ids.py").write_text(
+        "raise RuntimeError('shadow tier_model_ids imported')\n",
+        encoding="utf-8",
+    )
+    (shadow_import_root / "claude_chain_runner.py").write_text(
+        "raise RuntimeError('shadow claude_chain_runner imported')\n",
+        encoding="utf-8",
+    )
+    shadow_constants_root = shadow_import_root / "advisor_scripts_constants"
+    shadow_constants_root.mkdir()
+    (shadow_constants_root / "__init__.py").write_text(
+        "raise RuntimeError('shadow advisor constants imported')\n",
+        encoding="utf-8",
+    )
+    shadow_scripts_constants_root = shadow_import_root / "dev_env_scripts_constants"
+    shadow_scripts_constants_root.mkdir()
+    (shadow_scripts_constants_root / "__init__.py").write_text(
+        "raise RuntimeError('shadow dev-env constants imported')\n",
+        encoding="utf-8",
+    )
+    return shadow_import_root
+
+
+@pytest.fixture(scope="module")
+def installed_dispatcher_scripts(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Path:
+    """Stage one installed profile for both dispatcher import checks."""
+    source_package_directory = Path(__file__).resolve().parent.parent
+    target_profile_directory = tmp_path_factory.mktemp("dispatcher_profile") / ".claude"
+    return _stage_profile_tree(source_package_directory, target_profile_directory)
+
+
+@pytest.mark.parametrize("dispatcher_name", _DISPATCHER_NAMES)
+def test_installed_dispatcher_help_imports_advisor_constants(
+    dispatcher_name: str, installed_dispatcher_scripts: Path
+) -> None:
+    """Each deployed dispatcher imports and serves help from an isolated tree."""
+    target_scripts_directory = installed_dispatcher_scripts
+    target_profile_directory = target_scripts_directory.parent
+
+    completed_process = subprocess.run(
+        [
+            sys.executable,
+            "-S",
+            "-E",
+            str(target_scripts_directory / dispatcher_name),
+            "--help",
+        ],
+        cwd=target_profile_directory,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stderr == ""
+    assert "usage:" in completed_process.stdout
+
+
+@pytest.mark.parametrize("dispatcher_name", _DISPATCHER_NAMES)
+def test_imported_dispatcher_promotes_all_profile_owned_roots(
+    dispatcher_name: str, installed_dispatcher_scripts: Path
+) -> None:
+    """Fresh imported-module loading selects every installed profile root."""
+    dispatcher_module_name = dispatcher_name.rsplit(".", maxsplit=1)[0]
+    target_profile_directory = installed_dispatcher_scripts.parent
+    shadow_import_root = _stage_shadow_import_root(
+        target_profile_directory, dispatcher_module_name
+    )
+    advisor_scripts_root = target_profile_directory / "_shared" / "advisor" / "scripts"
+    advisor_config_root = advisor_scripts_root / "config"
+    process_tree_scripts_root = (
+        target_profile_directory / "_shared" / "process-tree" / "scripts"
+    )
+    process_tree_config_root = process_tree_scripts_root / "config"
+    all_expected_roots = [
+        str(advisor_config_root),
+        str(advisor_scripts_root),
+        str(installed_dispatcher_scripts),
+        str(shadow_import_root),
+    ]
+    if dispatcher_module_name == "resolve_worker_spawn":
+        all_expected_roots = [
+            str(process_tree_config_root),
+            str(process_tree_scripts_root),
+            *all_expected_roots,
+        ]
+    child_code = "\n".join(
+        (
+            "import importlib",
+            "import json",
+            "import sys",
+            "from pathlib import Path",
+            f"dispatcher_module_name = {dispatcher_module_name!r}",
+            "shadow_import_root, scripts_root, advisor_scripts_root, advisor_config_root = (",
+            f"    {str(shadow_import_root)!r},",
+            f"    {str(installed_dispatcher_scripts)!r},",
+            f"    {str(advisor_scripts_root)!r},",
+            f"    {str(advisor_config_root)!r},",
+            ")",
+            "sys.path[:0] = [",
+            "    shadow_import_root,",
+            "    scripts_root,",
+            "    advisor_scripts_root,",
+            "    advisor_config_root,",
+            "]",
+            "assert all(each_name not in sys.modules for each_name in (",
+            "    dispatcher_module_name,",
+            "    'tier_model_ids',",
+            "    'advisor_scripts_constants',",
+            "))",
+            "dispatcher = importlib.import_module(dispatcher_module_name)",
+            "tier_model_ids = importlib.import_module('tier_model_ids')",
+            "advisor_scripts_constants = importlib.import_module('advisor_scripts_constants')",
+            "print(json.dumps({",
+            "    'dispatcher': str(Path(dispatcher.__file__).resolve()),",
+            "    'tier_model_ids': str(Path(tier_model_ids.__file__).resolve()),",
+            "    'advisor_scripts_constants': str(Path(advisor_scripts_constants.__file__).resolve()),",
+            "    'roots': sys.path[:6],",
+            "}))",
+        )
+    )
+    completed_process = subprocess.run(
+        [sys.executable, "-S", "-E", "-c", child_code],
+        cwd=target_profile_directory,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert completed_process.returncode == 0, completed_process.stderr
+    assert completed_process.stderr == ""
+    all_import_results = json.loads(completed_process.stdout)
+    assert all_import_results["dispatcher"] == str(
+        installed_dispatcher_scripts / dispatcher_name
+    )
+    assert all_import_results["tier_model_ids"] == str(
+        advisor_scripts_root / "tier_model_ids.py"
+    )
+    assert all_import_results["advisor_scripts_constants"] == str(
+        advisor_config_root / "advisor_scripts_constants" / "__init__.py"
+    )
+    assert all_import_results["roots"][: len(all_expected_roots)] == all_expected_roots

package/scripts/test_resolve_worker_spawn.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import io
 import json
 import subprocess
 import sys
@@ -9,6 +10,7 @@ import threading
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Self
 
 import pytest
 
@@ -17,6 +19,7 @@ if str(_SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(_SCRIPTS_DIR))
 
 import claude_chain_runner as chain_runner  # noqa: E402
+import invoke_code_review as invoker
 import resolve_worker_spawn as dispatcher  # noqa: E402
 from claude_chain_runner import (  # noqa: E402
     ChainAttempt,
@@ -87,6 +90,7 @@ FIXTURE_ROLE = "code-quality-agent"
 MIN_WORKER_TIMEOUT_SECONDS_CONSTANT_NAME = "MIN_WORKER_TIMEOUT_SECONDS"
 LARGE_PROMPT_CHARACTER_COUNT = 40000
 WINDOWS_SAFE_ARGV_ELEMENT_CEILING = 8192
+LOCK_WAIT_TIMEOUT_SECONDS = 1
 EXPECTED_PRIMARY_AGENT_FOR_DEFAULT_ROLE = Path(
     ALL_AGENT_FILENAMES_BY_ROLE[DEFAULT_ROLE][0]
 ).stem
@@ -1085,7 +1089,7 @@ def test_headless_chain_runner_lock_serializes_distinct_cwds(
         claude_outcome=_claude_served(),
         host_profile=HOST_PROFILE_THIRD_PARTY,
     )
-    all_errors: list[BaseException] = []
+    all_errors: list[Exception] = []
     barrier = threading.Barrier(2)
 
     def _run_with_working_directory(working_directory: Path) -> None:
@@ -1122,6 +1126,120 @@ def test_headless_chain_runner_lock_serializes_distinct_cwds(
     assert chain_runner.chain_subprocess_runner is not None
 
 
+def test_shared_chain_runner_lock_serializes_cross_dispatcher_cwds(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    first_working_directory = tmp_path / "project-a"
+    second_working_directory = tmp_path / "project-b"
+    first_working_directory.mkdir()
+    second_working_directory.mkdir()
+    observed_working_directories: list[Path] = []
+    all_errors: list[BaseException] = []
+
+    class CoordinatedLock:
+        def __init__(self) -> None:
+            self._lock = threading.Lock()
+            self.first_acquired = threading.Event()
+            self.second_attempted = threading.Event()
+            self.enter_count = 0
+
+        def __enter__(self) -> Self:
+            self.enter_count += 1
+            if self.enter_count == 1:
+                self.first_acquired.set()
+            elif self.enter_count == 2:
+                self.second_attempted.set()
+            self._lock.acquire()
+            return self
+
+        def __exit__(self, *all_positionals: object) -> None:
+            del all_positionals
+            self._lock.release()
+
+    coordinated_lock = CoordinatedLock()
+
+    def tracking_subprocess_runner(
+        all_invocation_tokens: Sequence[str],
+        *all_positionals: object,
+        **all_keywords: object,
+    ) -> subprocess.CompletedProcess[str]:
+        del all_invocation_tokens, all_positionals
+        observed_working_directories.append(Path(str(all_keywords["cwd"])))
+        return subprocess.CompletedProcess(
+            args=["claude"], returncode=0, stdout="{}", stderr=""
+        )
+
+    def run_review_runner(
+        all_claude_arguments: list[str], *, timeout_seconds: int
+    ) -> ChainInvocationOutcome:
+        del all_claude_arguments, timeout_seconds
+        if not coordinated_lock.second_attempted.wait(
+            timeout=LOCK_WAIT_TIMEOUT_SECONDS
+        ):
+            all_errors.append(AssertionError("shared lock was never contended"))
+            return _claude_served()
+        chain_runner.chain_subprocess_runner(
+            ["claude"], capture_output=True, text=True, timeout=1, check=False
+        )
+        return _claude_served()
+
+    def run_spawn_runner(
+        all_claude_arguments: list[str], *, timeout_seconds: int
+    ) -> ChainInvocationOutcome:
+        del all_claude_arguments, timeout_seconds
+        chain_runner.chain_subprocess_runner(
+            ["claude"], capture_output=True, text=True, timeout=1, check=False
+        )
+        return _claude_served()
+
+    monkeypatch.setattr(
+        chain_runner, "chain_subprocess_runner", tracking_subprocess_runner
+    )
+    monkeypatch.setattr(
+        chain_runner, "chain_subprocess_runner_lock", lambda: coordinated_lock,
+        raising=False,
+    )
+    monkeypatch.setattr(invoker, "review_claude_runner", run_review_runner)
+    monkeypatch.setattr(dispatcher, "spawn_claude_runner", run_spawn_runner)
+
+    def run_review() -> None:
+        try:
+            invoker._run_claude_with_empty_stdin(
+                ["-p", "review"],
+                timeout_seconds=1,
+                working_directory=first_working_directory,
+            )
+        except Exception as raised_error:  # noqa: BLE001
+            all_errors.append(raised_error)
+
+    def run_spawn() -> None:
+        try:
+            dispatcher._run_claude_with_headless_overrides(
+                ["-p", "spawn"],
+                timeout_seconds=1,
+                working_directory=second_working_directory,
+                prompt_stdin=io.StringIO(FIXTURE_PROMPT_TEXT),
+            )
+        except Exception as raised_error:  # noqa: BLE001
+            all_errors.append(raised_error)
+
+    review_thread = threading.Thread(target=run_review)
+    spawn_thread = threading.Thread(target=run_spawn)
+    review_thread.start()
+    coordinated_lock.first_acquired.wait(timeout=LOCK_WAIT_TIMEOUT_SECONDS)
+    spawn_thread.start()
+    review_thread.join(timeout=10)
+    spawn_thread.join(timeout=10)
+
+    assert all_errors == []
+    assert coordinated_lock.enter_count == 2
+    assert observed_working_directories == [
+        first_working_directory,
+        second_working_directory,
+    ]
+    assert chain_runner.chain_subprocess_runner is tracking_subprocess_runner
+
+
 def test_usage_limit_fallover_delivers_full_prompt_to_each_binary(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:

package/scripts/test_validate_instruction_pairs.py

@@ -4,6 +4,16 @@ from pathlib import Path
 from validate_instruction_pairs import validate_repository
 
 
+def read_workflow(workflow_filename: str) -> str:
+    workflow_path = (
+        Path(__file__).resolve().parents[3]
+        / ".github"
+        / "workflows"
+        / workflow_filename
+    )
+    return workflow_path.read_text(encoding="utf-8")
+
+
 def initialize_repository(repository_root: Path) -> None:
     subprocess.run(["git", "init", "--quiet"], cwd=repository_root, check=True)
     subprocess.run(
@@ -88,3 +98,23 @@ def test_untracked_import_fails_tracking_check(tmp_path: Path) -> None:
     all_errors = validate_repository(tmp_path)
 
     assert any("Git mode 100644" in each_error for each_error in all_errors)
+
+
+def test_pull_request_trigger_is_unconditional() -> None:
+    workflow_text = read_workflow("validate-instruction-pairs.yml")
+
+    assert "  pull_request:\n  push:\n" in workflow_text
+
+
+def test_instruction_pairs_status_context_stays_exact() -> None:
+    workflow_text = read_workflow("validate-instruction-pairs.yml")
+    reusable_workflow_text = read_workflow("instruction-pairs-reusable.yml")
+
+    assert (
+        "  instruction-pairs:\n"
+        "    uses: ./.github/workflows/instruction-pairs-reusable.yml\n"
+        "    with:\n"
+        "      validator-ref: ${{ github.event.pull_request.head.sha || github.sha }}\n"
+        in workflow_text
+    )
+    assert "  instruction-pairs:\n    name: instruction-pairs\n" in reusable_workflow_text

package/scripts/profile-isolation-launchers/config/mcp-bundles.json

@@ -1,25 +0,0 @@
-{
-  "schemaVersion": 1,
-  "supportedActivationInterface": "claude-config-dir-mcp-json",
-  "mcpConfigFileName": "mcp.json",
-  "bundles": {
-    "lean": {
-      "id": "lean",
-      "allServerNames": ["filesystem-readonly"]
-    },
-    "full": {
-      "id": "full",
-      "allServerNames": ["filesystem-readonly", "github-readonly"]
-    }
-  },
-  "serverByName": {
-    "filesystem-readonly": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-filesystem", "${PROFILE_ROOT}"]
-    },
-    "github-readonly": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-github"]
-    }
-  }
-}

package/scripts/profile-isolation-launchers/config/profile-isolation-constants.mjs

@@ -1,60 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const CONFIG_DIRECTORY_PATH = dirname(fileURLToPath(import.meta.url));
-
-/**
- * @param {string} fileName
- * @returns {unknown}
- */
-function readJsonConfigFile(fileName) {
-  const absolutePath = join(CONFIG_DIRECTORY_PATH, fileName);
-  return JSON.parse(readFileSync(absolutePath, 'utf8'));
-}
-
-export const PROFILES_MANIFEST_FILE_NAME = 'profiles.manifest.json';
-export const SHARED_ALLOWLIST_FILE_NAME = 'shared-allowlist.json';
-
-/**
- * Sole authoritative profile-root environment variable for CLI isolation.
- * CLAUDE_HOME is never honored as a profile root by this contract.
- */
-export const CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE = 'CLAUDE_CONFIG_DIR';
-export const CLAUDE_HOME_ENVIRONMENT_VARIABLE = 'CLAUDE_HOME';
-export const CLAUDE_CODE_TMPDIR_ENVIRONMENT_VARIABLE = 'CLAUDE_CODE_TMPDIR';
-export const CLAUDE_CODE_PLUGIN_SEED_DIR_ENVIRONMENT_VARIABLE = 'CLAUDE_CODE_PLUGIN_SEED_DIR';
-
-export const PROFILES_ROOT_ENVIRONMENT_VARIABLE = 'LLM_SETTINGS_PROFILES_ROOT';
-export const SHARED_SOURCE_ROOT_ENVIRONMENT_VARIABLE = 'LLM_SETTINGS_SHARED_SOURCE_ROOT';
-export const PLUGIN_SEED_ROOT_ENVIRONMENT_VARIABLE = 'LLM_SETTINGS_PLUGIN_SEED_ROOT';
-
-export const DEFAULT_PROFILES_ROOT_DIRECTORY_NAME = '.claude-profiles';
-export const DEFAULT_SHARED_SOURCE_DIRECTORY_NAME = 'shared-source';
-export const DEFAULT_PLUGIN_SEED_DIRECTORY_NAME = 'plugin-seed';
-
-export const MIGRATION_MODE_CLEAN_LOCAL_RUNTIME = 'clean-local-runtime';
-export const MIGRATION_MODE_MATERIALIZE_FROM_LEGACY = 'materialize-from-legacy';
-
-export const MCP_BUNDLE_LEAN = 'lean';
-export const MCP_BUNDLE_FULL = 'full';
-
-export const LAUNCHER_SCHEMA_VERSION = 1;
-export const PROFILE_ISOLATION_CONTRACT_OWNER = 'profile-isolation-contract';
-export const PACKAGE_FILES_WHITELIST_SCRIPTS_ENTRY = 'scripts/';
-export const LIVE_DEPLOYMENT_RESERVED_FOR = 'L1';
-export const INSTALL_DESTINATION_ROOT_RELATIVE_PATH = 'scripts/profile-isolation-launchers';
-
-/**
- * @returns {Record<string, unknown>}
- */
-export function loadProfilesManifestDocument() {
-  return /** @type {Record<string, unknown>} */ (readJsonConfigFile(PROFILES_MANIFEST_FILE_NAME));
-}
-
-/**
- * @returns {Record<string, unknown>}
- */
-export function loadSharedAllowlistDocument() {
-  return /** @type {Record<string, unknown>} */ (readJsonConfigFile(SHARED_ALLOWLIST_FILE_NAME));
-}

package/scripts/profile-isolation-launchers/config/profiles.manifest.json

@@ -1,54 +0,0 @@
-{
-  "schemaVersion": 1,
-  "profilesRootPlaceholder": "${PROFILES_ROOT}",
-  "sharedSourcePlaceholder": "${SHARED_SOURCE_ROOT}",
-  "pluginSeedPlaceholder": "${PLUGIN_SEED_ROOT}",
-  "migrationOrder": ["profile-c", "profile-b", "profile-a", "master", "profile-d"],
-  "profiles": {
-    "master": {
-      "id": "master",
-      "aliases": ["default"],
-      "directoryName": "master",
-      "launcherNames": ["claude"],
-      "fullLauncherNames": ["claude-full"],
-      "migrationMode": "materialize-from-legacy",
-      "mcpBundle": "lean"
-    },
-    "profile-a": {
-      "id": "profile-a",
-      "aliases": [],
-      "directoryName": "profile-a",
-      "launcherNames": ["claude-profile-a"],
-      "fullLauncherNames": ["claude-profile-a-full"],
-      "migrationMode": "materialize-from-legacy",
-      "mcpBundle": "lean"
-    },
-    "profile-c": {
-      "id": "profile-c",
-      "aliases": [],
-      "directoryName": "profile-c",
-      "launcherNames": ["claude-profile-c"],
-      "fullLauncherNames": ["claude-profile-c-full"],
-      "migrationMode": "clean-local-runtime",
-      "mcpBundle": "lean"
-    },
-    "profile-b": {
-      "id": "profile-b",
-      "aliases": [],
-      "directoryName": "profile-b",
-      "launcherNames": ["claude-profile-b"],
-      "fullLauncherNames": ["claude-profile-b-full"],
-      "migrationMode": "clean-local-runtime",
-      "mcpBundle": "lean"
-    },
-    "profile-d": {
-      "id": "profile-d",
-      "aliases": [],
-      "directoryName": "profile-d",
-      "launcherNames": ["claude-profile-d"],
-      "fullLauncherNames": ["claude-profile-d-full"],
-      "migrationMode": "clean-local-runtime",
-      "mcpBundle": "lean"
-    }
-  }
-}

package/scripts/profile-isolation-launchers/config/shared-allowlist.json

@@ -1,64 +0,0 @@
-{
-  "schemaVersion": 1,
-  "description": "Read-mostly paths shared across CLI profiles via links. Everything else defaults to physical profile-local.",
-  "allSharedRelativePaths": [
-    "CLAUDE.md",
-    "agents",
-    "skills",
-    "rules",
-    "commands",
-    "output-styles",
-    "system-prompts",
-    "audit-rubrics",
-    "docs",
-    "tools",
-    "hooks",
-    "scripts"
-  ],
-  "allAlwaysLocalRelativePaths": [
-    ".claude.json",
-    "settings.json",
-    "settings.local.json",
-    "credentials",
-    ".credentials.json",
-    "projects",
-    "sessions",
-    "history",
-    "history.jsonl",
-    "teams",
-    "tasks",
-    "jobs",
-    "daemon",
-    "plugins",
-    "marketplaces",
-    "registries",
-    "caches",
-    "file-history",
-    "shell-snapshots",
-    "browser",
-    "data",
-    "state",
-    "logs",
-    "locks",
-    "offsets",
-    "telemetry",
-    "verification",
-    "backups",
-    "tmp",
-    "tmpdir",
-    "session-env",
-    "statsig",
-    "todos",
-    "plans",
-    "debug",
-    ".state",
-    ".queue"
-  ],
-  "allDesktopExcludedPathFragments": [
-    "Claude Desktop",
-    "Claude Desktop Profiles",
-    "CLAUDE_USER_DATA_DIR",
-    "claude-desktop",
-    "Claude.exe"
-  ]
-}