claude-dev-env 2.14.1 → 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/tests/AGENTS.md

@@ -10,6 +10,8 @@ pytest suite for the Python scripts and Pester suite for the PowerShell scripts
 | `test_setup_project_paths_config.py` | Configuration constants used by `setup_project_paths.py` |
 | `test_sweep_empty_dirs.py` | `sweep_empty_dirs.py` — age check, one-shot mode, and continuous-watch behavior |
 | `test_sync_to_cursor.py` | `sync_to_cursor/` package — mapping, hashing, manifest, and path resolution |
+| `test_rules.py` | Discovered Claude `rules/*.md` mappings to stem-named Cursor `.mdc` files |
+| `test_engine.py` | `sync_to_cursor` engine `--claude-root` / `--cursor-root` layout flags |
 | `test_grok_worker_constants.py` | `grok_worker_constants.py` — the accepted batch worker-key set stays in step with the worker key constants, and the unknown-key message names both its placeholders |
 
 ## PowerShell test files

package/scripts/tests/test_engine.py

@@ -0,0 +1,102 @@
+"""Tests for sync_to_cursor engine CLI roots."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent.parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from sync_to_cursor.engine import run as run_sync_to_cursor
+
+_CODE_STANDARDS_SECTION_ORDER = (
+    "COMMENT PRESERVATION",
+    "CORE PRINCIPLES",
+    "⚡ HOOK-ENFORCED RULES",
+    "3. REUSE CONSTANTS / 4. CONFIG LOCATIONS",
+    "5. NO ABBREVIATIONS",
+    "6. COMPLETE TYPE HINTS",
+    "9. SELF-CONTAINED COMPONENTS",
+)
+_TEST_QUALITY_SECTION_ORDER = (
+    "Delete Useless Tests",
+    "Test Dependencies MUST FAIL",
+    "Core Testing Principles",
+    "React Testing Patterns",
+    "Test File Organization",
+)
+
+
+def _write_minimal_curated_rules(rules_directory: Path) -> None:
+    rules_directory.mkdir(parents=True, exist_ok=True)
+    (rules_directory / "code-standards.md").write_text(
+        "# Code standards stub\n", encoding="utf-8"
+    )
+    (rules_directory / "tasklings-preferences.md").write_text(
+        '---\npaths:\n  - "Y:/x/**"\n---\n\n# Tasklings\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "bdd.md").write_text("# BDD\n", encoding="utf-8")
+    (rules_directory / "testing.md").write_text(
+        '---\npaths:\n  - "**/test_*.py"\n---\n\n# Testing\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "research-mode.md").write_text("# RM\n", encoding="utf-8")
+    (rules_directory / "conservative-action.md").write_text("# CA\n", encoding="utf-8")
+    (rules_directory / "explore-thoroughly.md").write_text("# ET\n", encoding="utf-8")
+
+
+def _write_minimal_docs(docs_directory: Path) -> None:
+    docs_directory.mkdir(parents=True, exist_ok=True)
+    (docs_directory / "CODE_RULES.md").write_text(
+        "\n\n".join(f"## {title}\n\nalpha" for title in _CODE_STANDARDS_SECTION_ORDER)
+        + "\n",
+        encoding="utf-8",
+    )
+    (docs_directory / "TEST_QUALITY.md").write_text(
+        "\n\n".join(f"## {title}\n\nbeta" for title in _TEST_QUALITY_SECTION_ORDER)
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def test_explicit_roots_write_stem_named_mdc(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    claude = tmp_path / "claude-home"
+    cursor = tmp_path / "cursor-home"
+    _write_minimal_curated_rules(claude / "rules")
+    _write_minimal_docs(claude / "docs")
+    (claude / "rules" / "plain-language.md").write_text(
+        "# Plain language\n\nUse short sentences.\n",
+        encoding="utf-8",
+    )
+    (claude / "rules" / "CLAUDE.md").write_text("# Inventory\n", encoding="utf-8")
+    monkeypatch.delenv("LLM_SETTINGS_ROOT", raising=False)
+    assert cursor.exists() is False
+    assert (
+        run_sync_to_cursor(
+            [
+                "--force",
+                "--claude-root",
+                str(claude),
+                "--cursor-root",
+                str(cursor),
+            ]
+        )
+        == 0
+    )
+    generated = (cursor / "rules" / "plain-language.mdc").read_text(encoding="utf-8")
+    assert 'description: "Plain language"' in generated
+    assert "alwaysApply: true" in generated
+    assert "Use short sentences." in generated
+    assert not (cursor / "rules" / "CLAUDE.mdc").is_file()
+
+
+def test_explicit_roots_require_both_flags(tmp_path: Path) -> None:
+    with pytest.raises(SystemExit):
+        run_sync_to_cursor(["--force", "--claude-root", str(tmp_path)])

package/scripts/tests/test_rules.py

@@ -0,0 +1,79 @@
+"""Tests for discovered Claude-to-Cursor rule mappings."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent.parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from sync_to_cursor.rules import build_mappings
+
+_PACKAGE_ROOT = _SCRIPTS_DIR.parent
+_SKIPPED_RULE_FILE_NAMES = frozenset({"CLAUDE.md", "AGENTS.md"})
+
+
+def _write_minimal_curated_rules(rules_directory: Path) -> None:
+    rules_directory.mkdir(parents=True, exist_ok=True)
+    (rules_directory / "code-standards.md").write_text(
+        "# Code standards stub\n", encoding="utf-8"
+    )
+    (rules_directory / "tasklings-preferences.md").write_text(
+        '---\npaths:\n  - "Y:/x/**"\n---\n\n# Tasklings\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "bdd.md").write_text("# BDD\n", encoding="utf-8")
+    (rules_directory / "testing.md").write_text(
+        '---\npaths:\n  - "**/test_*.py"\n---\n\n# Testing\n',
+        encoding="utf-8",
+    )
+    (rules_directory / "research-mode.md").write_text("# RM\n", encoding="utf-8")
+    (rules_directory / "conservative-action.md").write_text("# CA\n", encoding="utf-8")
+    (rules_directory / "explore-thoroughly.md").write_text("# ET\n", encoding="utf-8")
+
+
+def test_build_mappings_emits_stem_mdc_for_remaining_claude_rules(
+    tmp_path: Path,
+) -> None:
+    claude = tmp_path / ".claude"
+    _write_minimal_curated_rules(claude / "rules")
+    (claude / "docs").mkdir(parents=True, exist_ok=True)
+    (claude / "rules" / "plain-language.md").write_text(
+        "# Plain language\n\nBe brief.\n",
+        encoding="utf-8",
+    )
+    (claude / "rules" / "CLAUDE.md").write_text(
+        "# Package inventory\n", encoding="utf-8"
+    )
+    (claude / "rules" / "AGENTS.md").write_text("# Agent inventory\n", encoding="utf-8")
+    mappings = build_mappings(claude)
+    output_by_key = {each_mapping.key: each_mapping for each_mapping in mappings}
+    discovered = output_by_key["plain-language"]
+    assert discovered.output_name == "plain-language.mdc"
+    assert discovered.always_apply is True
+    assert discovered.description == "Plain language"
+    assert "CLAUDE.md" not in {
+        each_source.name
+        for each_mapping in mappings
+        for each_source in each_mapping.sources
+    }
+    assert "AGENTS.md" not in {
+        each_source.name
+        for each_mapping in mappings
+        for each_source in each_mapping.sources
+    }
+
+
+def test_every_shipped_claude_rule_maps_to_an_mdc() -> None:
+    mappings = build_mappings(_PACKAGE_ROOT)
+    output_name_by_rule_file = {}
+    for each_mapping in mappings:
+        for each_source in each_mapping.sources:
+            if each_source.parent.name == "rules" and each_source.suffix == ".md":
+                output_name_by_rule_file[each_source.name] = each_mapping.output_name
+    for each_rule_file in sorted((_PACKAGE_ROOT / "rules").glob("*.md")):
+        if each_rule_file.name in _SKIPPED_RULE_FILE_NAMES:
+            continue
+        assert each_rule_file.name in output_name_by_rule_file, each_rule_file.name

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));
-}