claude-dev-env 4.2.0 → 7.0.0

package/scripts/policy_lint/selection.py

@@ -172,7 +172,7 @@ def _documents_from_changes(
     selection_kind = SelectionKind.STAGED if is_staged else SelectionKind.BASE
     return DocumentSet(
         tuple(all_documents), selection_kind, repository_root,
-        tuple(all_deleted_paths), tuple(all_renamed_paths),
+        tuple(all_deleted_paths), tuple(all_renamed_paths), base_revision,
     )
 
 
@@ -354,6 +354,7 @@ def _normalize_document_set(repository_root: Path, document_set: DocumentSet) ->
         repository_root,
         all_deleted_paths,
         all_renamed_paths,
+        document_set.base_revision,
     )
 
 

package/scripts/policy_lint/selection_git.py

@@ -10,6 +10,7 @@ from .config.constants import (
     ALL_MISSING_BLOB_ERROR_FRAGMENTS,
     ALL_UNBORN_HEAD_ERROR_FRAGMENTS,
     GIT_ENVIRONMENT_VARIABLE_PREFIX,
+    GIT_INDEX_ENVIRONMENT_VARIABLE,
     GIT_EXECUTABLE,
     NUL_BYTE,
     UTF8_ENCODING,
@@ -105,6 +106,7 @@ def _git_subprocess_environment() -> dict[str, str]:
         each_name: each_environment_text
         for each_name, each_environment_text in os.environ.items()
         if not each_name.upper().startswith(git_prefix)
+        or each_name.upper() == GIT_INDEX_ENVIRONMENT_VARIABLE
     }
 
 

package/scripts/refresh_pstack_plugin_skills.mjs

@@ -0,0 +1,200 @@
+/**
+ * Keep a pstack skills-directory plugin manifest listing every skill folder.
+ *
+ * Claude Code loads a folder under `~/.claude/skills` as a plugin when the
+ * folder holds `.claude-plugin/plugin.json`, and it namespaces that plugin's
+ * skills as `pstack:how`. It does not scan a plugin root for skill folders, so
+ * the manifest names each sub-skill path:
+ *
+ *     plugin root holds: how/SKILL.md, why/SKILL.md, docs/, .claude-plugin/
+ *     manifest before:   "skills": ["./how"]
+ *     manifest after:    "skills": ["./how", "./why"]   <- why/ picked up
+ *     second run:        no write                        <- the list matches
+ *     docs/, .claude-plugin/                             <- skipped, no SKILL.md
+ *
+ * The installer calls `refreshPstackPluginManifest` for a pstack folder the
+ * user installed. Running this file directly refreshes the same manifest after
+ * a pstack update.
+ */
+
+import {
+    existsSync,
+    mkdirSync,
+    readdirSync,
+    readFileSync,
+    realpathSync,
+    writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const PSTACK_PLUGIN_DIRECTORY_NAME = 'pstack';
+export const PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH = join('.claude-plugin', 'plugin.json');
+export const SKILL_MANIFEST_FILE_NAME = 'SKILL.md';
+export const SKILL_PATH_PREFIX = './';
+
+const CLAUDE_HOME_DIRECTORY_NAME = '.claude';
+const MANIFEST_SKILLS_KEY = 'skills';
+const MANIFEST_INDENT_SPACES = 2;
+const FILE_ENCODING = 'utf8';
+const HIDDEN_NAME_PREFIX = '.';
+
+/**
+ * Fields a first write seeds from the published pstack plugin. An existing
+ * manifest keeps its own values. This refresher changes only the skills list.
+ */
+const SEEDED_MANIFEST_FIELDS = Object.freeze({
+    $schema: 'https://anthropic.com/claude-code/plugin.schema.json',
+    name: PSTACK_PLUGIN_DIRECTORY_NAME,
+    version: '0.14.8',
+    description:
+        'if you want to go fast, go deep first. pstack helps you write less, but higher '
+        + 'quality code. rigorous agent workflows you can parallelize with confidence.',
+    author: Object.freeze({ name: 'Lauren Tan' }),
+    homepage: 'https://github.com/cursor/plugins/tree/main/pstack',
+    repository: 'https://github.com/cursor/plugins',
+    license: 'MIT',
+});
+
+/**
+ * Name every sub-folder of a plugin root that Claude Code loads as a skill.
+ *
+ * @param {string} pluginRoot Plugin folder holding one sub-folder per skill.
+ * @returns {string[]} The sorted names of each visible sub-folder holding a
+ *   skill manifest. A hidden folder and a folder without `SKILL.md` are left out.
+ */
+export function findPstackSkillDirectoryNames(pluginRoot) {
+    return readdirSync(pluginRoot, { withFileTypes: true })
+        .filter((eachEntry) => eachEntry.isDirectory())
+        .map((eachEntry) => eachEntry.name)
+        .filter((eachName) => !eachName.startsWith(HIDDEN_NAME_PREFIX))
+        .filter((eachName) => existsSync(join(pluginRoot, eachName, SKILL_MANIFEST_FILE_NAME)))
+        .sort();
+}
+
+function readManifestSkillPaths(manifestPath) {
+    if (!existsSync(manifestPath)) return { manifest: null, previousSkillPaths: [] };
+    const manifest = JSON.parse(readFileSync(manifestPath, FILE_ENCODING));
+    const listedSkillPaths = manifest[MANIFEST_SKILLS_KEY];
+    if (typeof listedSkillPaths === 'string') {
+        return { manifest, previousSkillPaths: [listedSkillPaths] };
+    }
+    if (Array.isArray(listedSkillPaths)) {
+        return { manifest, previousSkillPaths: listedSkillPaths };
+    }
+    return { manifest, previousSkillPaths: [] };
+}
+
+/**
+ * Rewrite a pstack plugin manifest's skills list to match its folder.
+ *
+ * Writes only when the list changes. A second call on an unchanged folder
+ * leaves the file byte for byte. An existing manifest keeps every field but
+ * the skills list.
+ *
+ * @param {string} pluginRoot Plugin folder holding the skill sub-folders.
+ * @returns {{didWrite: boolean, reason: string, previousSkillPaths: string[],
+ *   currentSkillPaths: string[]}} Whether this call wrote, and the paths
+ *   before and after. `reason` names a skip, and is empty on a write or an
+ *   unchanged list.
+ */
+export function refreshPstackPluginManifest(pluginRoot) {
+    const declined = { didWrite: false, previousSkillPaths: [], currentSkillPaths: [] };
+    if (!existsSync(pluginRoot)) {
+        return { ...declined, reason: 'plugin root is absent' };
+    }
+    if (existsSync(join(pluginRoot, SKILL_MANIFEST_FILE_NAME))) {
+        return { ...declined, reason: 'plugin root is itself a skill' };
+    }
+    const allSkillNames = findPstackSkillDirectoryNames(pluginRoot);
+    if (allSkillNames.length === 0) {
+        return { ...declined, reason: 'plugin root holds no skills' };
+    }
+    const manifestPath = join(pluginRoot, PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH);
+    const { manifest, previousSkillPaths } = readManifestSkillPaths(manifestPath);
+    const currentSkillPaths = allSkillNames.map((eachName) => SKILL_PATH_PREFIX + eachName);
+    const outcome = { reason: '', previousSkillPaths, currentSkillPaths };
+    const isUnchanged = manifest !== null
+        && previousSkillPaths.length === currentSkillPaths.length
+        && previousSkillPaths.every((eachPath, eachIndex) => eachPath === currentSkillPaths[eachIndex]);
+    if (isUnchanged) {
+        return { ...outcome, didWrite: false };
+    }
+    const refreshedManifest = {
+        ...(manifest === null ? SEEDED_MANIFEST_FIELDS : manifest),
+        [MANIFEST_SKILLS_KEY]: currentSkillPaths,
+    };
+    mkdirSync(join(pluginRoot, '.claude-plugin'), { recursive: true });
+    writeFileSync(
+        manifestPath,
+        JSON.stringify(refreshedManifest, null, MANIFEST_INDENT_SPACES) + '\n',
+        FILE_ENCODING,
+    );
+    return { ...outcome, didWrite: true };
+}
+
+/**
+ * Return the pstack plugin folder under a Claude home.
+ *
+ * @param {string} claudeHome The Claude home directory holding `skills`.
+ * @returns {string} The pstack plugin folder path, present or not.
+ */
+export function pstackPluginRootFor(claudeHome) {
+    return join(claudeHome, 'skills', PSTACK_PLUGIN_DIRECTORY_NAME);
+}
+
+/**
+ * Return the Claude home used when no folder argument is given.
+ *
+ * A named profile sets `CLAUDE_CONFIG_DIR`. The installer writes into that
+ * root. The command-line form reads the same variable.
+ *
+ * @param {Record<string, string|undefined>} environment The process environment.
+ * @returns {string} The Claude home directory holding `skills`.
+ */
+export function claudeHomeFrom(environment) {
+    return environment.CLAUDE_CONFIG_DIR || join(homedir(), CLAUDE_HOME_DIRECTORY_NAME);
+}
+
+function main() {
+    const explicitRoot = process.argv[2];
+    const pluginRoot = explicitRoot || pstackPluginRootFor(claudeHomeFrom(process.env));
+    const outcome = refreshPstackPluginManifest(pluginRoot);
+    if (!outcome.didWrite && outcome.reason) {
+        console.log(`No manifest written: ${outcome.reason}.`);
+        return;
+    }
+    if (!outcome.didWrite) {
+        console.log(`No change. ${outcome.currentSkillPaths.length} skills listed.`);
+        return;
+    }
+    console.log(`Updated. ${outcome.currentSkillPaths.length} skills listed.`);
+    for (const eachPath of outcome.currentSkillPaths) {
+        if (!outcome.previousSkillPaths.includes(eachPath)) console.log(`  added   ${eachPath}`);
+    }
+    for (const eachPath of outcome.previousSkillPaths) {
+        if (!outcome.currentSkillPaths.includes(eachPath)) console.log(`  removed ${eachPath}`);
+    }
+}
+
+/**
+ * Return whether node ran this module as its entry point.
+ *
+ * A directory link to this script gives node an invoked path that differs from
+ * this module's own path. Both sides resolve to their real location before
+ * the comparison.
+ *
+ * @param {string|undefined} invokedPath The path node reports as `argv[1]`.
+ * @returns {boolean} True when node ran this module as its entry point.
+ */
+function isEntryPoint(invokedPath) {
+    if (!invokedPath) return false;
+    try {
+        return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(invokedPath);
+    } catch {
+        return fileURLToPath(import.meta.url) === invokedPath;
+    }
+}
+
+if (isEntryPoint(process.argv[1])) main();

package/scripts/repository_checks/config/constants.py

@@ -131,11 +131,6 @@ ALL_TRACKED_SECRET_EXACT_EXEMPTIONS: frozenset[tuple[str, str, str]] = frozenset
             "home-path",
             "09f83c224a02c370d3d63de5c330e1a830fc92866330fc7963b5b5fd20ffcb91",
         ),
-        (
-            "packages/claude-dev-env/hooks/blocking/volatile_path_in_post_blocker.py",
-            "home-path",
-            "ed9203c8078e4c6b832600085f28f24656d679aa8dca82ecc2557afc3df25036",
-        ),
         (
             "packages/claude-dev-env/hooks/hooks_constants/hardcoded_user_path_constants.py",
             "home-path",

package/scripts/shared_tree_paths.py

@@ -11,7 +11,9 @@ from collections.abc import Mapping
 from pathlib import Path
 
 from dev_env_scripts_constants.shared_tree_constants import (
+    AGENTS_DIRECTORY_SUFFIX,
     CLAUDE_CONFIG_DIR_ENV_VAR,
+    DEFAULT_MANAGED_ROOT_NAME,
     PROCESS_TREE_DIRECTORY_NAME,
     PROCESS_TREE_KILL_MODULE_FILENAME,
     SCRIPTS_DIRECTORY_NAME,
@@ -29,6 +31,29 @@ def _shared_scripts_directory(from_root: Path, shared_subpackage_name: str) -> P
     )
 
 
+def _linked_managed_root(module_path: Path, anchor_depth: int) -> Path | None:
+    """Resolve the managed root whose scripts pointer targets this installed tree.
+
+    Args:
+        module_path: The module path inside the managed scripts tree.
+        anchor_depth: Parent index of the package or agents root.
+
+    Returns:
+        The Claude managed root when its scripts pointer resolves to this tree.
+    """
+    package_root = module_path.resolve().parents[anchor_depth]
+    if not package_root.name.endswith(AGENTS_DIRECTORY_SUFFIX):
+        return None
+    managed_name = package_root.name.removesuffix(AGENTS_DIRECTORY_SUFFIX) or DEFAULT_MANAGED_ROOT_NAME
+    managed_root = package_root.parent / managed_name
+    linked_scripts = managed_root / SCRIPTS_DIRECTORY_NAME
+    if not linked_scripts.is_dir():
+        return None
+    if linked_scripts.resolve() != package_root / SCRIPTS_DIRECTORY_NAME:
+        return None
+    return managed_root
+
+
 def resolve_shared_scripts_directory(
     module_file: str | Path,
     all_environment: Mapping[str, str],
@@ -44,9 +69,10 @@ def resolve_shared_scripts_directory(
         ok:   an un-resolved parent keeps the link side, where _shared sits
         flag: a resolved parent walks the link and misses _shared entirely
 
-    Tries the un-resolved parent first, then the configured managed root,
-    then the resolved parent. When none holds the marker, returns the
-    un-resolved candidate, so an import failure names a readable path.
+    Tries the un-resolved parent first, then a verified installed scripts
+    pointer, then the configured managed root, then the resolved parent.
+    If none holds the marker, returns the un-resolved candidate so an
+    import failure names a readable path.
 
     Args:
         module_file: Path of the importing module (``__file__``).
@@ -63,6 +89,9 @@ def resolve_shared_scripts_directory(
         module_path.absolute().parents[anchor_depth], shared_subpackage_name
     )
     all_candidates = [un_resolved_candidate]
+    linked_root = _linked_managed_root(module_path, anchor_depth)
+    if linked_root is not None:
+        all_candidates.append(_shared_scripts_directory(linked_root, shared_subpackage_name))
     configured_root_text = all_environment.get(CLAUDE_CONFIG_DIR_ENV_VAR, "").strip()
     if configured_root_text:
         all_candidates.append(

package/scripts/test_durable_post_lint.py

@@ -0,0 +1,332 @@
+"""Tests for action-aware durable GitHub post linting."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+
+import durable_post_lint
+
+SCRIPT_PATH = _SCRIPTS_DIRECTORY / "durable_post_lint.py"
+VALID_PR_BODY = """## Summary
+
+Summary text.
+
+## Description
+
+Description text.
+
+## Why
+
+Why text.
+
+## How
+
+How text.
+
+## Verification
+
+Verification text.
+"""
+
+
+@pytest.mark.parametrize(
+    ("action", "title", "body_text"),
+    [
+        ("pr-create", "feat: add durable post linting", VALID_PR_BODY),
+        ("pr-edit", "fix(cli): validate post input", None),
+        ("pr-comment", None, "Comment body."),
+        ("pr-review", None, "Review body."),
+        ("issue-create", None, "Issue body."),
+        ("issue-edit", None, "Updated issue body."),
+        ("issue-comment", None, "Issue comment."),
+        ("github-mcp-post", None, "MCP body."),
+    ],
+)
+def test_all_actions_accept_valid_inputs(
+    action: str, title: str | None, body_text: str | None
+) -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action=action,
+        title=title,
+        body_text=body_text,
+    )
+    assert all_findings == ()
+
+
+def test_unknown_action_raises_usage_error() -> None:
+    with pytest.raises(durable_post_lint.DurablePostUsageError):
+        durable_post_lint.lint_durable_post(
+            action="release-create",
+            title=None,
+            body_text="Release body.",
+        )
+
+
+@pytest.mark.parametrize(
+    ("title", "body_text"),
+    [
+        (None, VALID_PR_BODY),
+        ("feat: add durable post linting", None),
+    ],
+)
+def test_pr_create_requires_title_and_body(
+    title: str | None, body_text: str | None
+) -> None:
+    with pytest.raises(durable_post_lint.DurablePostUsageError):
+        durable_post_lint.lint_durable_post(
+            action="pr-create",
+            title=title,
+            body_text=body_text,
+        )
+
+
+def test_pr_edit_requires_one_edit_field() -> None:
+    with pytest.raises(durable_post_lint.DurablePostUsageError):
+        durable_post_lint.lint_durable_post(
+            action="pr-edit",
+            title=None,
+            body_text=None,
+        )
+
+
+@pytest.mark.parametrize(
+    "action",
+    [
+        "pr-comment",
+        "pr-review",
+        "issue-create",
+        "issue-edit",
+        "issue-comment",
+        "github-mcp-post",
+    ],
+)
+def test_body_actions_require_body(action: str) -> None:
+    with pytest.raises(durable_post_lint.DurablePostUsageError):
+        durable_post_lint.lint_durable_post(
+            action=action,
+            title=None,
+            body_text=None,
+        )
+
+
+@pytest.mark.parametrize(
+    "title",
+    [
+        "feat: add durable post linting",
+        "fix(cli): validate body files",
+        "refactor!: replace post validation",
+        "docs(skill)!: explain durable posts",
+    ],
+)
+def test_pr_titles_accept_repository_conventional_forms(title: str) -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-edit",
+        title=title,
+        body_text=None,
+    )
+    assert all_findings == ()
+
+
+@pytest.mark.parametrize(
+    "title",
+    [
+        "Add durable post linting",
+        "feature: add durable post linting",
+        "fix(): add durable post linting",
+        "fix:add durable post linting",
+        "fix: ",
+    ],
+)
+def test_pr_titles_reject_nonconventional_forms(title: str) -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-edit",
+        title=title,
+        body_text=None,
+    )
+    assert [each_finding.code for each_finding in all_findings] == ["invalid-pr-title"]
+
+
+@pytest.mark.parametrize(
+    "missing_heading",
+    ["Summary", "Description", "Why", "How", "Verification"],
+)
+def test_pr_body_reports_each_missing_heading(missing_heading: str) -> None:
+    body_text = VALID_PR_BODY.replace(f"## {missing_heading}\n", "")
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-create",
+        title="feat: add durable post linting",
+        body_text=body_text,
+    )
+    assert [each_finding.message for each_finding in all_findings] == [
+        f"body is missing required heading: {missing_heading}"
+    ]
+
+
+def test_non_pr_body_needs_no_pr_headings() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="issue-comment",
+        title=None,
+        body_text="A concise issue comment.",
+    )
+    assert all_findings == ()
+
+
+@pytest.mark.parametrize(
+    ("body_text", "expected_marker"),
+    [
+        (
+            r"See C:\Users\example\.claude-profile-a\jobs\job-1\artifact.png",
+            ".claude-profile-a/jobs/",
+        ),
+        (
+            r"Edited C:\Users\example\.claude\worktrees\feature\file.py",
+            ".claude/worktrees/",
+        ),
+        (
+            r"Saved in C:\Users\example\AppData\Local\Temp\report.txt",
+            "appdata/local/temp",
+        ),
+        ("Saved in /tmp/report.txt", "/tmp/"),
+        (r"Saved in %TEMP%\report.txt", "%temp%"),
+        (r"Saved in $env:TEMP\report.txt", "$env:temp"),
+        ("Saved in $CLAUDE_JOB_DIR/report.txt", "$claude_job_dir"),
+    ],
+)
+def test_volatile_path_markers_match_hook_behavior(
+    body_text: str, expected_marker: str
+) -> None:
+    assert durable_post_lint.find_volatile_path_marker(body_text) == expected_marker
+
+
+@pytest.mark.parametrize(
+    "body_text",
+    [
+        "the `.claude/worktrees/` prefix is a manifest key",
+        ".claude/worktrees/ entries are skipped by the manifest",
+        "(.claude-profile-a/jobs/) is a directory name",
+        "worktrees live under `.claude/worktrees/<name>`",
+        "the constant is `.claude/worktrees/`. Next.",
+    ],
+)
+def test_anchored_marker_near_misses_remain_allowed(body_text: str) -> None:
+    assert durable_post_lint.find_volatile_path_marker(body_text) is None
+
+
+def test_volatile_body_returns_content_finding() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="issue-comment",
+        title=None,
+        body_text="Saved in /tmp/report.txt",
+    )
+    assert [each_finding.code for each_finding in all_findings] == [
+        "volatile-local-path"
+    ]
+
+
+def test_read_body_file_accepts_utf8(tmp_path: Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text("Café", encoding="utf-8")
+    assert durable_post_lint.read_body_file(body_file) == "Café"
+
+
+def test_read_body_file_rejects_missing_file(tmp_path: Path) -> None:
+    missing_file = tmp_path / "missing.md"
+    with pytest.raises(durable_post_lint.DurablePostInputError):
+        durable_post_lint.read_body_file(missing_file)
+
+
+def test_read_body_file_rejects_invalid_utf8(tmp_path: Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_bytes(b"\xff\xfe")
+    with pytest.raises(durable_post_lint.DurablePostInputError):
+        durable_post_lint.read_body_file(body_file)
+
+
+def test_cli_returns_clean_exit_for_valid_pr_create(tmp_path: Path) -> None:
+    body_file = tmp_path / "body.md"
+    body_file.write_text(VALID_PR_BODY, encoding="utf-8")
+    completed_process = subprocess.run(
+        [
+            sys.executable,
+            str(SCRIPT_PATH),
+            "--action",
+            "pr-create",
+            "--title",
+            "feat: add durable post linting",
+            "--body-file",
+            str(body_file),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+    assert completed_process.stderr == ""
+
+
+def test_cli_returns_content_exit_without_echoing_body(tmp_path: Path) -> None:
+    body_text = "private body words saved in /tmp/report.txt"
+    body_file = tmp_path / "body.md"
+    body_file.write_text(body_text, encoding="utf-8")
+    completed_process = subprocess.run(
+        [
+            sys.executable,
+            str(SCRIPT_PATH),
+            "--action",
+            "issue-comment",
+            "--body-file",
+            str(body_file),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert completed_process.returncode == 1
+    assert "volatile local artifact path" in completed_process.stderr
+    assert body_text not in completed_process.stderr
+
+
+def test_cli_returns_usage_exit_for_missing_body_file(tmp_path: Path) -> None:
+    missing_file = tmp_path / "missing.md"
+    completed_process = subprocess.run(
+        [
+            sys.executable,
+            str(SCRIPT_PATH),
+            "--action",
+            "issue-comment",
+            "--body-file",
+            str(missing_file),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert completed_process.returncode == 2
+    assert "body file is not readable" in completed_process.stderr
+
+
+def test_cli_has_no_inline_body_flag() -> None:
+    completed_process = subprocess.run(
+        [
+            sys.executable,
+            str(SCRIPT_PATH),
+            "--action",
+            "issue-comment",
+            "--body",
+            "Inline body.",
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert completed_process.returncode == 2
+    assert "unrecognized arguments" in completed_process.stderr

package/scripts/test_shared_tree_paths.py

@@ -171,3 +171,36 @@ def test_generalized_resolver_serves_a_deeper_anchor(tmp_path: Path) -> None:
         3,
     )
     assert resolved_scripts_directory == expected_scripts_directory
+
+
+@pytest.mark.parametrize("managed_name", (".claude", "profile-a"))
+def test_resolved_agents_scripts_find_the_verified_managed_root(
+    tmp_path: Path, managed_name: str,
+) -> None:
+    agents_name = ".agents" if managed_name == ".claude" else f"{managed_name}.agents"
+    agents_root = tmp_path / agents_name
+    scripts_directory = agents_root / "scripts"
+    scripts_directory.mkdir(parents=True)
+    module_file = scripts_directory / "runner.py"
+    module_file.write_text("", encoding="utf-8")
+    managed_root = tmp_path / managed_name
+    managed_root.mkdir()
+    _create_directory_link(from_link=managed_root / "scripts", to_target=scripts_directory)
+    expected = _write_process_tree_kill_stub(managed_root)
+    resolved_directory = shared_tree_paths.resolve_shared_process_tree_scripts_directory(module_file, {})
+    assert resolved_directory == expected
+
+
+def test_neighboring_managed_root_cannot_supply_a_foreign_shared_tree(tmp_path: Path) -> None:
+    agents_root = tmp_path / ".agents"
+    scripts_directory = agents_root / "scripts"
+    scripts_directory.mkdir(parents=True)
+    module_file = scripts_directory / "runner.py"
+    module_file.write_text("", encoding="utf-8")
+    managed_root = tmp_path / ".claude"
+    foreign_scripts = managed_root / "scripts"
+    foreign_scripts.mkdir(parents=True)
+    _write_process_tree_kill_stub(managed_root)
+    resolved_directory = shared_tree_paths.resolve_shared_process_tree_scripts_directory(module_file, {})
+    expected = agents_root / "_shared" / "process-tree" / "scripts"
+    assert resolved_directory == expected