claude-dev-env 2.15.0 → 2.15.1

package/_shared/advisor/scripts/tier_model_ids.py

@@ -30,8 +30,12 @@ from collections.abc import Mapping
 from pathlib import Path
 
 _config_directory = str(Path(__file__).resolve().parent / "config")
-if _config_directory not in sys.path:
-    sys.path.insert(0, _config_directory)
+sys.path[:] = [
+    each_existing_entry
+    for each_existing_entry in sys.path
+    if each_existing_entry != _config_directory
+]
+sys.path[:0] = [_config_directory]
 
 from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
     ALL_CLI_MODEL_ID_BY_TIER,

package/bin/install.mjs

@@ -114,6 +114,35 @@ const RETIRED_SKILL_REASON_LABEL = 'retired';
 const STALE_FILE_REASON_LABEL = 'stale';
 const MANIFEST_MANAGED_PERMISSIONS_KEY = 'managedPermissions';
 
+/**
+ * Managed-home-relative directories this package leaves to whoever deployed
+ * them: it writes nothing inside them and prunes nothing out of them.
+ *
+ * `scripts/profile-isolation-launchers` is the live CLI profile launcher. Its
+ * executable modules are deployed from a separate source, so a payload covering
+ * only part of that tree left config and code out of step. This package stopped
+ * shipping its part, and the stale-file prune reads a path the package no longer
+ * writes as stale, which would move the live files aside on the next install.
+ * Naming the directory here keeps both halves of the tree with their owner.
+ */
+const RETAINED_UNMANAGED_RELATIVE_PATHS = [
+    'scripts/profile-isolation-launchers',
+];
+
+/**
+ * Report whether a path a prior manifest recorded sits inside a directory this
+ * package leaves to another owner.
+ *
+ * @param {string} candidatePath The absolute path the prior manifest recorded.
+ * @param {string} managedHomeDirectory The managed home the relative names resolve against.
+ * @returns {boolean} True when the path sits inside a retained unmanaged directory.
+ */
+function isRetainedUnmanagedPath(candidatePath, managedHomeDirectory) {
+    return RETAINED_UNMANAGED_RELATIVE_PATHS.some(
+        relativePath => isInsideDirectory(candidatePath, join(managedHomeDirectory, relativePath)),
+    );
+}
+
 export const CORE_INCLUDE_DIRECTORIES = [
     'rules', 'docs', 'commands', 'agents', 'audit-rubrics', '_shared', 'scripts',
 ];
@@ -832,6 +861,7 @@ export function pruneStaleInstalledFiles(
         const stalePath = resolve(priorFile);
         if (!isInsideDirectory(stalePath, resolvedRoot)) continue;
         if (currentFileKeys.has(comparisonKeyForPath(stalePath, options))) continue;
+        if (isRetainedUnmanagedPath(stalePath, managedHomeDirectory)) continue;
         if (!isMovableStaleFile(stalePath)) continue;
         const backupRelativePath = relative(resolvedRoot, stalePath);
         const didMove = moveIntoRunBackup(
@@ -2590,13 +2620,15 @@ function realPathOrSelf(filesystemPath) {
 }
 
 /**
- * Load profile id → directoryName from the A1 launcher contract when present.
- * Falls back to identity mapping when the file is missing, unreadable, or empty.
+ * Load profile id → directoryName for the install targets this package resolves.
+ *
+ * Each profile's directory carries the profile's own name, so the map is an
+ * identity over the ids a multi-target install accepts.
  *
  * @returns {Record<string, string>}
  */
 function loadDirectoryNameByProfileId() {
-    const fallbackDirectoryNameByProfileId = {
+    return {
         main: 'main',
         editor: 'editor',
         mel: 'mel',
@@ -2604,35 +2636,6 @@ function loadDirectoryNameByProfileId() {
         master: 'master',
         kimi: 'kimi',
     };
-    const manifestPath = join(
-        PACKAGE_ROOT,
-        'scripts',
-        'profile-isolation-launchers',
-        'config',
-        'profiles.manifest.json',
-    );
-    if (!existsSync(manifestPath)) {
-        return fallbackDirectoryNameByProfileId;
-    }
-    try {
-        const document = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        /** @type {Record<string, string>} */
-        const directoryNameByProfileId = {};
-        const profiles = document && typeof document === 'object' ? document.profiles : null;
-        if (profiles && typeof profiles === 'object') {
-            for (const [eachProfileId, eachProfile] of Object.entries(profiles)) {
-                if (eachProfile && typeof eachProfile === 'object' && typeof eachProfile.directoryName === 'string') {
-                    directoryNameByProfileId[eachProfileId] = eachProfile.directoryName;
-                }
-            }
-        }
-        if (Object.keys(directoryNameByProfileId).length === 0) {
-            return fallbackDirectoryNameByProfileId;
-        }
-        return directoryNameByProfileId;
-    } catch {
-        return fallbackDirectoryNameByProfileId;
-    }
 }
 
 /**

package/bin/install.test.mjs

@@ -1281,25 +1281,59 @@ const README_BASENAME_PATTERN = /^readme\.md$/i;
 
 
 /**
- * Build a sandbox holding an installed skills root and a run backup root.
+ * Build a sandbox holding one installed managed root and a run backup root.
  *
- * @param {object} installedFiles Forward-slash relative paths under the skills root mapped to contents.
- * @returns {{root: string, skillsRoot: string, backupRoot: string}} The sandbox paths.
+ * @param {object} installedFiles Forward-slash relative paths under the installed root mapped to contents.
+ * @param {string} [managedRootName] The managed top-level directory the files sit under.
+ * @returns {{root: string, skillsRoot: string, installedRoot: string, backupRoot: string}} The sandbox paths.
  */
-function createStalePruneSandbox(installedFiles) {
+function createStalePruneSandbox(installedFiles, managedRootName = 'skills') {
     const root = mkdtempSync(join(tmpdir(), 'cdev-stale-prune-'));
-    const skillsRoot = join(root, 'skills');
+    const installedRoot = join(root, managedRootName);
     const backupRoot = join(root, 'pruned', 'run-timestamp');
-    mkdirSync(skillsRoot, { recursive: true });
+    mkdirSync(installedRoot, { recursive: true });
     for (const [relativePath, contents] of Object.entries(installedFiles)) {
-        const targetPath = join(skillsRoot, relativePath);
+        const targetPath = join(installedRoot, relativePath);
         mkdirSync(dirname(targetPath), { recursive: true });
         writeFileSync(targetPath, contents);
     }
-    return { root, skillsRoot, backupRoot };
+    return { root, skillsRoot: installedRoot, installedRoot, backupRoot };
 }
 
 
+test('pruneStaleInstalledFiles leaves a retained unmanaged path the package stopped shipping in place', () => {
+    const sandbox = createStalePruneSandbox({
+        'profile-isolation-launchers/config/mcp-bundles.json': '{"schemaVersion":1}\n',
+        'sync-to-cursor.py': 'print("shipped")\n',
+    }, 'scripts');
+    try {
+        const shippedFilePath = join(sandbox.installedRoot, 'sync-to-cursor.py');
+        const retainedFilePath = join(
+            sandbox.installedRoot, 'profile-isolation-launchers', 'config', 'mcp-bundles.json',
+        );
+
+        const pruneOutcome = pruneStaleInstalledFiles(
+            [shippedFilePath, retainedFilePath],
+            [shippedFilePath],
+            sandbox.installedRoot,
+            sandbox.backupRoot,
+            { managedHomeDirectory: sandbox.root },
+        );
+
+        assert.equal(pruneOutcome.prunedCount, 0, 'a retained unmanaged path never counts as pruned');
+        assert.deepEqual(pruneOutcome.failedPaths, [], 'skipping a retained path reports no failed move');
+        assert.equal(
+            existsSync(retainedFilePath),
+            true,
+            'the launcher file a prior install recorded stays where the live launcher reads it',
+        );
+        assert.equal(existsSync(shippedFilePath), true, 'a file this run wrote stays in place');
+    } finally {
+        rmSync(sandbox.root, { recursive: true, force: true });
+    }
+});
+
+
 /**
  * Run a callable with console.warn captured, returning its value and the warnings.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "2.15.0",
+    "version": "2.15.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {
@@ -8,7 +8,7 @@
         "codex-compat": "bin/codex-compat.mjs"
     },
     "scripts": {
-        "test": "node --test \"bin/*.test.mjs\" \"skills/**/*.test.mjs\" \"scripts/profile-isolation-launchers/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\""
+        "test": "node --test \"bin/*.test.mjs\" \"skills/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\""
     },
     "files": [
         "bin/",

package/scripts/AGENTS.md

@@ -37,7 +37,6 @@ Utility scripts installed into `~/.claude/scripts/` by `bin/install.mjs`. Each s
 |---|---|
 | `ci/` | CI-only adapters; `windows-installer-lifecycle.ps1` runs the Node installer 16-check driver under isolated HOME/USERPROFILE/GIT_CONFIG_GLOBAL and writes bounded evidence |
 | `dev_env_scripts_constants/` | Named constants (`timing.py`, `grok_worker_constants.py`, …) for scripts in this directory, including worker-advisor placeholder launcher/model/effort, four verdict signals, correction cap, and advisor timeout |
-| `profile-isolation-launchers/` | Profile-launcher contract plus MCP activation, Windows shortcut source semantics, and version preflight: profiles manifest, shared-path allowlist, profile resolver, `CLAUDE_CONFIG_DIR` authority, lean/full MCP bundle materialization into profile `mcp.json`, pure CLI/Desktop version-compatibility classifier consumed by launcher preflight, read-only shortcut inventory and preview reconcile under `windows/`. Live launcher execution, provenance pin, live shortcut mutation, and L1 deploy stay residual |
 | `sync_to_cursor/` | Package that builds Cursor `.mdc` files from Claude rules and docs |
 | `tests/` | pytest suite for the Python scripts and Pester (`*.Tests.ps1`) suite for the PowerShell scripts in this directory |
 
@@ -49,12 +48,6 @@ Python scripts (pytest):
 python -m pytest packages/claude-dev-env/scripts/tests/
 ```
 
-Profile-isolation launcher contract (node:test):
-
-```bash
-node --test packages/claude-dev-env/scripts/profile-isolation-launchers/**/*.test.mjs
-```
-
 PowerShell scripts (Pester 5+, `*.Tests.ps1`):
 
 ```powershell

package/scripts/claude_chain_runner.py

@@ -48,7 +48,9 @@ import os
 import subprocess
 import sys
 import tempfile
-from collections.abc import Callable, Sequence
+import threading
+from collections.abc import Callable, Iterator, Sequence
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from pathlib import Path
 from types import ModuleType
@@ -327,6 +329,35 @@ class WeeklyUsageAccountReport(Protocol):
 
 
 chain_subprocess_runner = _run_captured_subprocess
+_shared_chain_subprocess_lock = threading.Lock()
+
+
+def chain_subprocess_runner_lock() -> threading.Lock:
+    """Return the lock for adapters that temporarily configure the runner."""
+    return _shared_chain_subprocess_lock
+
+
+@contextmanager
+def override_chain_subprocess_runner(
+    replacement_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> Iterator[Callable[..., subprocess.CompletedProcess[str]]]:
+    """Temporarily replace the chain subprocess seam under its shared lock.
+
+    Args:
+        replacement_runner: Callable used for subprocess invocations during the
+            context.
+
+    Yields:
+        The runner that was active before the replacement.
+    """
+    global chain_subprocess_runner
+    with chain_subprocess_runner_lock():
+        previous_runner = chain_subprocess_runner
+        chain_subprocess_runner = replacement_runner
+        try:
+            yield previous_runner
+        finally:
+            chain_subprocess_runner = previous_runner
 
 
 def _load_chain_usage_module() -> ModuleType:
@@ -1138,6 +1169,22 @@ def _persist_served_affinity(
         return
 
 
+def _run_cli_chain(
+    all_claude_arguments: list[str],
+    *,
+    timeout_seconds: int,
+    stdin_text: str | None,
+    routing_mode: str,
+) -> ChainInvocationOutcome:
+    """Run the CLI-selected chain arguments through the public runner."""
+    return run_claude(
+        all_claude_arguments,
+        timeout_seconds=timeout_seconds,
+        stdin_text=stdin_text,
+        routing_mode=routing_mode,
+    )
+
+
 def _build_argument_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         description="Run a claude invocation through the fallback chain."
@@ -1206,7 +1253,7 @@ def main(all_command_arguments: list[str]) -> int:
     all_claude_arguments = _strip_leading_separator(parsed_arguments.passthrough)
     maybe_stdin_text = _read_piped_stdin_text()
     try:
-        chain_outcome = run_claude(
+        chain_outcome = _run_cli_chain(
             all_claude_arguments,
             timeout_seconds=parsed_arguments.timeout_seconds,
             stdin_text=maybe_stdin_text,

package/scripts/invoke_code_review.py

@@ -28,20 +28,30 @@ import argparse
 import json
 import subprocess
 import sys
-import threading
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
-if str(Path(__file__).resolve().parent) not in sys.path:
-    sys.path.insert(0, str(Path(__file__).resolve().parent))
+_scripts_directory_path = Path(__file__).resolve().parent
+_scripts_directory = str(_scripts_directory_path)
+sys.path[:] = [
+    each_existing_entry
+    for each_existing_entry in sys.path
+    if each_existing_entry != _scripts_directory
+]
+sys.path[:0] = [_scripts_directory]
 
 _advisor_scripts_path = str(
-    Path(__file__).resolve().parent.parent / "_shared" / "advisor" / "scripts"
+    _scripts_directory_path.parent / "_shared" / "advisor" / "scripts"
 )
-if _advisor_scripts_path not in sys.path:
-    sys.path.insert(0, _advisor_scripts_path)
+sys.path[:] = [
+    each_existing_entry
+    for each_existing_entry in sys.path
+    if each_existing_entry != _advisor_scripts_path
+]
+sys.path[:0] = [_advisor_scripts_path]
 
+from tier_model_ids import detect_host_profile  # noqa: E402
 from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
     HOST_PROFILE_CLAUDE,
 )
@@ -93,14 +103,6 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
 from dev_env_scripts_constants.timing import (  # noqa: E402
     DEFAULT_CODE_REVIEW_TIMEOUT_SECONDS,
 )
-from tier_model_ids import detect_host_profile  # noqa: E402
-
-_CHAIN_RUNNER_LOCK = threading.Lock()
-
-
-def _chain_runner_lock() -> threading.Lock:
-    """Return the module lock that serializes chain-runner stdin/cwd swaps."""
-    return _CHAIN_RUNNER_LOCK
 
 
 @dataclass(frozen=True)
@@ -302,44 +304,39 @@ def _run_claude_with_empty_stdin(
     working_directory: Path,
 ) -> ChainInvocationOutcome:
     working_directory_path = str(working_directory)
-    with _CHAIN_RUNNER_LOCK:
-        previous_runner: TextCapturingSubprocessRunner = (
-            chain_runner.chain_subprocess_runner
-        )
 
-        def _runner_with_empty_stdin(
-            all_invocation_tokens: Sequence[str],
-            *all_positionals: object,
-            **all_keywords: object,
-        ) -> subprocess.CompletedProcess[str]:
-            del all_positionals
-            maybe_timeout = all_keywords.get("timeout")
-            timeout_for_run: float | None
-            if isinstance(maybe_timeout, (int, float)):
-                timeout_for_run = float(maybe_timeout)
-            else:
-                timeout_for_run = None
-            forwarded_text_codec = collect_forwarded_text_codec(all_keywords)
-            completed_process: subprocess.CompletedProcess[str] = previous_runner(
-                all_invocation_tokens,
-                capture_output=True,
-                text=True,
-                timeout=timeout_for_run,
-                check=False,
-                stdin=subprocess.DEVNULL,
-                cwd=working_directory_path,
-                **forwarded_text_codec,
-            )
-            return completed_process
-
-        empty_stdin_runner: TextCapturingSubprocessRunner = _runner_with_empty_stdin
-        setattr(chain_runner, "chain_subprocess_runner", empty_stdin_runner)
-        try:
-            return review_claude_runner(
-                all_claude_arguments, timeout_seconds=timeout_seconds
-            )
-        finally:
-            setattr(chain_runner, "chain_subprocess_runner", previous_runner)
+    def _runner_with_empty_stdin(
+        all_invocation_tokens: Sequence[str],
+        *all_positionals: object,
+        **all_keywords: object,
+    ) -> subprocess.CompletedProcess[str]:
+        del all_positionals
+        maybe_timeout = all_keywords.get("timeout")
+        timeout_for_run: float | None
+        if isinstance(maybe_timeout, (int, float)):
+            timeout_for_run = float(maybe_timeout)
+        else:
+            timeout_for_run = None
+        forwarded_text_codec = collect_forwarded_text_codec(all_keywords)
+        completed_process: subprocess.CompletedProcess[str] = previous_runner(
+            all_invocation_tokens,
+            capture_output=True,
+            text=True,
+            timeout=timeout_for_run,
+            check=False,
+            stdin=subprocess.DEVNULL,
+            cwd=working_directory_path,
+            **forwarded_text_codec,
+        )
+        return completed_process
+
+    empty_stdin_runner: TextCapturingSubprocessRunner = _runner_with_empty_stdin
+    with chain_runner.override_chain_subprocess_runner(
+        empty_stdin_runner
+    ) as previous_runner:
+        return review_claude_runner(
+            all_claude_arguments, timeout_seconds=timeout_seconds
+        )
 
 
 def _in_session_outcome() -> CodeReviewOutcome:

package/scripts/resolve_worker_spawn.py

@@ -26,21 +26,31 @@ import argparse
 import json
 import subprocess
 import sys
-import threading
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from pathlib import Path
 from typing import IO
 
-if str(Path(__file__).resolve().parent) not in sys.path:
-    sys.path.insert(0, str(Path(__file__).resolve().parent))
+_scripts_directory_path = Path(__file__).resolve().parent
+_scripts_directory = str(_scripts_directory_path)
+sys.path[:] = [
+    each_existing_entry
+    for each_existing_entry in sys.path
+    if each_existing_entry != _scripts_directory
+]
+sys.path[:0] = [_scripts_directory]
 
 _advisor_scripts_path = str(
-    Path(__file__).resolve().parent.parent / "_shared" / "advisor" / "scripts"
+    _scripts_directory_path.parent / "_shared" / "advisor" / "scripts"
 )
-if _advisor_scripts_path not in sys.path:
-    sys.path.insert(0, _advisor_scripts_path)
+sys.path[:] = [
+    each_existing_entry
+    for each_existing_entry in sys.path
+    if each_existing_entry != _advisor_scripts_path
+]
+sys.path[:0] = [_advisor_scripts_path]
 
+from tier_model_ids import detect_host_profile  # noqa: E402
 from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
     HOST_PROFILE_CLAUDE,
 )
@@ -94,14 +104,6 @@ from grok_headless_runner import (  # noqa: E402
     run_headless_worker,
 )
 from grok_worker_preflight import PreflightOutcome, run_preflight  # noqa: E402
-from tier_model_ids import detect_host_profile  # noqa: E402
-
-_HEADLESS_CHAIN_RUNNER_LOCK = threading.Lock()
-
-
-def _headless_chain_runner_lock() -> threading.Lock:
-    """Return the module lock that serializes headless chain-runner swaps."""
-    return _HEADLESS_CHAIN_RUNNER_LOCK
 
 
 @dataclass(frozen=True)
@@ -184,41 +186,34 @@ def _run_claude_with_headless_overrides(
     prompt_stdin: IO[str],
 ) -> ChainInvocationOutcome:
     working_directory_path = str(working_directory)
-    with _HEADLESS_CHAIN_RUNNER_LOCK:
-        previous_runner: TextCapturingSubprocessRunner = (
-            chain_runner.chain_subprocess_runner
-        )
 
-        def _runner_with_headless_overrides(
-            all_invocation_tokens: Sequence[str],
-            *all_positionals: object,
-            **all_keywords: object,
-        ) -> subprocess.CompletedProcess[str]:
-            del all_positionals
-            prompt_stdin.seek(0)
-            forwarded_text_codec = collect_forwarded_text_codec(all_keywords)
-            completed_process: subprocess.CompletedProcess[str] = previous_runner(
-                all_invocation_tokens,
-                capture_output=True,
-                text=True,
-                timeout=_timeout_seconds_from_keywords(all_keywords),
-                check=False,
-                stdin=prompt_stdin,
-                cwd=working_directory_path,
-                **forwarded_text_codec,
-            )
-            return completed_process
-
-        headless_runner: TextCapturingSubprocessRunner = (
-            _runner_with_headless_overrides
+    def _runner_with_headless_overrides(
+        all_invocation_tokens: Sequence[str],
+        *all_positionals: object,
+        **all_keywords: object,
+    ) -> subprocess.CompletedProcess[str]:
+        del all_positionals
+        prompt_stdin.seek(0)
+        forwarded_text_codec = collect_forwarded_text_codec(all_keywords)
+        completed_process: subprocess.CompletedProcess[str] = previous_runner(
+            all_invocation_tokens,
+            capture_output=True,
+            text=True,
+            timeout=_timeout_seconds_from_keywords(all_keywords),
+            check=False,
+            stdin=prompt_stdin,
+            cwd=working_directory_path,
+            **forwarded_text_codec,
+        )
+        return completed_process
+
+    headless_runner: TextCapturingSubprocessRunner = _runner_with_headless_overrides
+    with chain_runner.override_chain_subprocess_runner(
+        headless_runner
+    ) as previous_runner:
+        return spawn_claude_runner(
+            all_claude_arguments, timeout_seconds=timeout_seconds
         )
-        setattr(chain_runner, "chain_subprocess_runner", headless_runner)
-        try:
-            return spawn_claude_runner(
-                all_claude_arguments, timeout_seconds=timeout_seconds
-            )
-        finally:
-            setattr(chain_runner, "chain_subprocess_runner", previous_runner)
 
 
 def _prompt_file_unreadable_outcome(

package/scripts/test_claude_chain_runner.py

@@ -17,6 +17,8 @@ import claude_chain_runner as runner  # noqa: E402
 import claude_chain_usage as chain_usage  # noqa: E402
 from claude_chain_runner import (  # noqa: E402
     ChainEntry,
+    chain_subprocess_runner_lock,
+    override_chain_subprocess_runner,
     default_affinity_state_path,
     extract_resume_session_id,
     load_affinity_store,
@@ -78,6 +80,32 @@ from dev_env_scripts_constants.claude_chain_constants import (  # noqa: E402
 
 _LARGE_CAPTURE_BYTE_COUNT = 400_000
 _LARGE_CAPTURE_MARKER = "X"
+
+
+def test_chain_subprocess_runner_lock_is_shared() -> None:
+    first_lock = chain_subprocess_runner_lock()
+    second_lock = chain_subprocess_runner_lock()
+
+    assert first_lock is second_lock
+
+
+def test_override_chain_subprocess_runner_restores_previous_runner() -> None:
+    previous_runner = runner.chain_subprocess_runner
+
+    def replacement_runner(
+        all_invocation_tokens: list[str],
+        **all_keywords: object,
+    ) -> subprocess.CompletedProcess[str]:
+        del all_invocation_tokens, all_keywords
+        return subprocess.CompletedProcess([], 0, "", "")
+
+    with override_chain_subprocess_runner(replacement_runner) as active_runner:
+        assert active_runner is previous_runner
+        assert runner.chain_subprocess_runner is replacement_runner
+
+    assert runner.chain_subprocess_runner is previous_runner
+
+
 _STDIN_ECHO_PAYLOAD = "charter body for spool path"
 _UNDECODABLE_STDOUT_BYTES = b"ok \x90 end"
 _DECODED_UNDECODABLE_STDOUT = "ok \ufffd end"