claude-dev-env 4.3.0 → 7.1.0

package/{.agents/skills/run-claude-dev-env/driver.mjs → scripts/ci/installer-lifecycle.mjs}

@@ -1,29 +1,4 @@
 #!/usr/bin/env node
-/**
- * Smoke driver for the claude-dev-env installer.
- *
- * The installer (bin/install.mjs) writes into os.homedir()/.claude and
- * os.homedir()/.agents and has
- * three global side effects: it copies files under ~/.claude/ and ~/.agents/, sets
- * `git config --global core.hooksPath`, and writes ~/.mypy.ini. There is no
- * flag to redirect the target, so this driver isolates every side effect by
- * spawning the installer with HOME, USERPROFILE, and GIT_CONFIG_GLOBAL all
- * pointed at a throwaway sandbox directory. Node's os.homedir() follows
- * USERPROFILE on Windows and HOME on POSIX, so setting both redirects the
- * install target on either platform without touching the real ~/.claude/.
- *
- * The isolated GIT_CONFIG_GLOBAL is seeded with `safe.directory = *` so the
- * installer's `git status` source-conflict guard runs even when the checkout
- * lives somewhere git flags as dubious ownership (for example a UNC network
- * share), while the installer's `git config --global core.hooksPath` write
- * still lands only in the sandbox config.
- *
- * It runs the three lifecycle commands an agent cares about — `--help`, a full
- * install, and `--uninstall` — and asserts the observable result of each
- * against the sandbox tree. Exit code 0 means every assertion held.
- *
- * Usage: node .claude/skills/run-claude-dev-env/driver.mjs
- */
 
 import { spawnSync } from 'node:child_process';
 import {
@@ -41,7 +16,7 @@ import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 
 const DRIVER_DIRECTORY = dirname(fileURLToPath(import.meta.url));
-const PACKAGE_ROOT = resolve(DRIVER_DIRECTORY, '..', '..', '..');
+const PACKAGE_ROOT = resolve(DRIVER_DIRECTORY, '..', '..');
 const INSTALL_ENTRY = join(PACKAGE_ROOT, 'bin', 'install.mjs');
 
 const checks = [];
@@ -68,7 +43,7 @@ function collectFilesRecursive(directory) {
 
 function runInstaller(sandboxHome, installerArguments) {
     const gitConfigGlobal = join(sandboxHome, '.gitconfig-sandbox');
-    const result = spawnSync(process.execPath, [INSTALL_ENTRY, ...installerArguments], {
+    const installerProcess = spawnSync(process.execPath, [INSTALL_ENTRY, ...installerArguments], {
         cwd: PACKAGE_ROOT,
         encoding: 'utf8',
         env: {
@@ -78,7 +53,7 @@ function runInstaller(sandboxHome, installerArguments) {
             GIT_CONFIG_GLOBAL: gitConfigGlobal,
         },
     });
-    return result;
+    return installerProcess;
 }
 
 function main() {

package/scripts/ci/installer-lifecycle.test.mjs

@@ -0,0 +1,26 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const CI_DIRECTORY = dirname(fileURLToPath(import.meta.url));
+const DRIVER_PATH = join(CI_DIRECTORY, 'installer-lifecycle.mjs');
+const DRIVER_TIMEOUT_MILLISECONDS = 60_000;
+
+ test('the installer lifecycle driver completes in an isolated home', () => {
+    const lifecycleProcess = spawnSync(process.execPath, [DRIVER_PATH], {
+        encoding: 'utf8',
+        timeout: DRIVER_TIMEOUT_MILLISECONDS,
+    });
+    assert.equal(lifecycleProcess.status, 0, `${lifecycleProcess.stdout}\n${lifecycleProcess.stderr}`);
+    assert.match(lifecycleProcess.stdout, /ALL CHECKS PASSED/);
+    assert.match(lifecycleProcess.stdout, /Sandbox removed:/);
+});
+
+test('the Windows adapter invokes the CI-owned lifecycle driver', () => {
+    const adapterSource = readFileSync(join(CI_DIRECTORY, 'windows-installer-lifecycle.ps1'), 'utf8');
+    assert.match(adapterSource, /\$driverPath = Join-Path \$PSScriptRoot 'installer-lifecycle\.mjs'/);
+    assert.doesNotMatch(adapterSource, /skills\\run-claude-dev-env/);
+});

package/scripts/ci/windows-installer-lifecycle.ps1

@@ -1,13 +1,3 @@
-# Windows CI adapter for the Node installer lifecycle driver.
-#
-# The driver already redirects HOME, USERPROFILE, and GIT_CONFIG_GLOBAL into a
-# throwaway sandbox. This adapter records that isolation contract, runs the
-# 16-check driver, and writes bounded evidence under -EvidenceRoot so a failed
-# Windows runner leaves an actionable artifact.
-#
-# Usage (from packages/claude-dev-env):
-#   pwsh -NoProfile -File scripts/ci/windows-installer-lifecycle.ps1 -EvidenceRoot <dir>
-
 [CmdletBinding()]
 param(
     [Parameter(Mandatory = $true)]
@@ -17,7 +7,7 @@ param(
 $ErrorActionPreference = 'Stop'
 
 $packageRoot = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path
-$driverPath = Join-Path $packageRoot '.claude\skills\run-claude-dev-env\driver.mjs'
+$driverPath = Join-Path $PSScriptRoot 'installer-lifecycle.mjs'
 $allIsolationEnvNames = @(
     'HOME',
     'USERPROFILE',

package/scripts/codex_compat_materializer.py

@@ -615,7 +615,7 @@ def _resolved_codex_enforcer_command(config: MaterializerConfig) -> str:
 
 def _source_codex_enforcer_hook(
     all_source_manifest: dict[str, object], command: str
-) -> dict[str, object]:
+) -> dict[str, object] | None:
     """Read the source enforcer hook shape and resolve its target command."""
     all_events = all_source_manifest.get("hooks")
     if not isinstance(all_events, dict):
@@ -637,11 +637,7 @@ def _source_codex_enforcer_hook(
             resolved_hook = dict(each_hook)
             resolved_hook[codex_hook_command_field_name] = command
             return resolved_hook
-    return {
-        "type": "command",
-        codex_hook_command_field_name: command,
-        "timeout": codex_hook_timeout_seconds,
-    }
+    return None
 
 
 def _hook_records(raw_hooks: object) -> list[dict[str, object]]:
@@ -668,6 +664,72 @@ def _is_code_rules_enforcer_hook(all_hook_record: dict[str, object]) -> bool:
     )
 
 
+def _is_managed_codex_enforcer_hook(
+    all_hook_record: dict[str, object], managed_command: str
+) -> bool:
+    """Report whether a hook record is the materializer's target command."""
+    command = all_hook_record.get(codex_hook_command_field_name)
+    if not isinstance(command, str):
+        return False
+    normalized_command = command.replace("\\", path_separator)
+    normalized_managed_command = managed_command.replace("\\", path_separator)
+    if os.name == "nt":
+        return normalized_command.casefold() == normalized_managed_command.casefold()
+    return normalized_command == normalized_managed_command
+
+
+def _without_managed_codex_enforcer(
+    entry: object, managed_command: str
+) -> object | None:
+    """Remove the managed enforcer while preserving every other hook record."""
+    if not isinstance(entry, dict):
+        return entry
+    if entry.get("matcher") != codex_hook_matcher:
+        return entry
+    copied_entry = dict(entry)
+    all_hook_records = copied_entry.get(codex_hook_records_field_name)
+    if not isinstance(all_hook_records, list):
+        return copied_entry
+    all_retained_hooks = [
+        each_hook
+        for each_hook in all_hook_records
+        if not isinstance(each_hook, dict)
+        or not _is_managed_codex_enforcer_hook(each_hook, managed_command)
+    ]
+    if all_retained_hooks == all_hook_records:
+        return copied_entry
+    if not all_retained_hooks:
+        return None
+    copied_entry[codex_hook_records_field_name] = all_retained_hooks
+    return copied_entry
+
+
+def _remove_managed_codex_enforcer(
+    all_target_manifest: dict[str, object], managed_command: str
+) -> dict[str, object]:
+    """Remove the retired managed enforcer from the target manifest."""
+    all_events = all_target_manifest.get(codex_hook_records_field_name, {})
+    if not isinstance(all_events, dict):
+        raise MaterializerError("Codex hook manifest requires a hooks object")
+    all_pre_tool_use = all_events.get(codex_hook_event_name)
+    if all_pre_tool_use is None:
+        return _prune_retired_codex_hooks(all_target_manifest)
+    if not isinstance(all_pre_tool_use, list):
+        raise MaterializerError("Codex hook manifest requires a PreToolUse list")
+    all_retained_entries: list[object] = []
+    for each_entry in all_pre_tool_use:
+        maybe_retained_entry = _without_managed_codex_enforcer(
+            each_entry, managed_command
+        )
+        if maybe_retained_entry is not None:
+            all_retained_entries.append(maybe_retained_entry)
+    merged_events = dict(all_events)
+    merged_events[codex_hook_event_name] = all_retained_entries
+    merged_manifest = dict(all_target_manifest)
+    merged_manifest[codex_hook_records_field_name] = merged_events
+    return _prune_retired_codex_hooks(merged_manifest)
+
+
 def _is_retired_codex_hook_command(command: object) -> bool:
     """Report whether a command names a known retired hook path."""
     if not isinstance(command, str):
@@ -764,13 +826,20 @@ def _has_modified_codex_enforcer_hook(
     current_hooks = _codex_enforcer_hooks(current_manifest)
     if not current_hooks:
         return False
-    return current_hooks != _codex_enforcer_hooks(planned_manifest)
+    planned_hooks = _codex_enforcer_hooks(planned_manifest)
+    if all(each_hook in current_hooks for each_hook in planned_hooks):
+        return False
+    return current_hooks != planned_hooks
 
 
 def _merge_codex_hook_manifest(
-    all_target_manifest: dict[str, object], all_focused_hook: dict[str, object]
+    all_target_manifest: dict[str, object],
+    all_focused_hook: dict[str, object] | None,
+    managed_command: str,
 ) -> dict[str, object]:
     """Preserve target hook order while merging one deterministic enforcer entry."""
+    if all_focused_hook is None:
+        return _remove_managed_codex_enforcer(all_target_manifest, managed_command)
     all_events = all_target_manifest.get(codex_hook_records_field_name, {})
     if not isinstance(all_events, dict):
         raise MaterializerError("Codex hook manifest requires a hooks object")
@@ -797,13 +866,17 @@ def _merge_codex_hook_manifest(
         if merged_apply_patch_entry is None:
             merged_apply_patch_entry = copied_entry
             merged_hooks = [
-                each_hook for each_hook in all_hook_records if not _is_code_rules_enforcer_hook(each_hook)
+                each_hook
+                for each_hook in all_hook_records
+                if not _is_managed_codex_enforcer_hook(each_hook, managed_command)
             ]
             merged_apply_patch_entry[codex_hook_records_field_name] = merged_hooks
             merged_pre_tool_use.append(merged_apply_patch_entry)
         else:
             merged_hooks.extend(
-                each_hook for each_hook in all_hook_records if not _is_code_rules_enforcer_hook(each_hook)
+                each_hook
+                for each_hook in all_hook_records
+                if not _is_managed_codex_enforcer_hook(each_hook, managed_command)
             )
     if merged_apply_patch_entry is None:
         merged_apply_patch_entry = {
@@ -831,10 +904,11 @@ def _build_codex_hook_projection(config: MaterializerConfig) -> PlannedFile | No
         if target_path.is_file()
         else {"hooks": {}}
     )
-    focused_hook = _source_codex_enforcer_hook(
-        source_manifest, _resolved_codex_enforcer_command(config)
+    managed_command = _resolved_codex_enforcer_command(config)
+    focused_hook = _source_codex_enforcer_hook(source_manifest, managed_command)
+    projected_manifest = _merge_codex_hook_manifest(
+        target_manifest, focused_hook, managed_command
     )
-    projected_manifest = _merge_codex_hook_manifest(target_manifest, focused_hook)
     projected_content = json.dumps(projected_manifest, ensure_ascii=False, indent=manifest_indentation_width) + line_separator
     return PlannedFile(
         codex_hook_manifest_source_path,
@@ -849,6 +923,8 @@ def _build_codex_hook_dependency_projection(
     config: MaterializerConfig,
 ) -> list[PlannedFile]:
     """Build the reviewed source files required by the target enforcer."""
+    if not _has_source_codex_enforcer(config):
+        return []
     all_dependencies: list[PlannedFile] = []
     for each_relative_path in codex_hook_dependency_manifest:
         source_path = _validated_source_file(
@@ -871,6 +947,16 @@ def _build_codex_hook_dependency_projection(
     return all_dependencies
 
 
+def _has_source_codex_enforcer(config: MaterializerConfig) -> bool:
+    """Report whether hooks.json registers the enforcer."""
+    source_path = _find_codex_hook_source(config)
+    if source_path is None:
+        return False
+    source_manifest = _read_json_object(source_path, "source Codex hook manifest")
+    managed_command = _resolved_codex_enforcer_command(config)
+    return _source_codex_enforcer_hook(source_manifest, managed_command) is not None
+
+
 def discover_agents(config: MaterializerConfig) -> list[ClaudeAgent]:
     """Discover and parse Markdown agents below the source root.
 

package/scripts/dev_env_scripts_constants/shared_tree_constants.py

@@ -1,8 +1,4 @@
-"""Constants for resolving directories inside the installed shared tree.
-
-These name the shape of the installed tree itself, not any one worker or
-skill that reads it, so every caller of shared_tree_paths shares them.
-"""
+"""Directory names for the installed shared tree."""
 
 from __future__ import annotations
 
@@ -15,3 +11,6 @@ SCRIPTS_DIRECTORY_NAME: str = "scripts"
 PROCESS_TREE_DIRECTORY_NAME: str = "process-tree"
 
 PROCESS_TREE_KILL_MODULE_FILENAME: str = "process_tree_kill.py"
+
+AGENTS_DIRECTORY_SUFFIX: str = ".agents"
+DEFAULT_MANAGED_ROOT_NAME: str = ".claude"

package/{.agents/skills/_shared/pr-loop/scripts → scripts}/durable_post_lint.py

@@ -8,7 +8,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass
 from pathlib import Path
 
-from skills_pr_loop_constants.durable_post_lint_constants import (
+from durable_post_lint_config.config.constants import (
     ACTION_PR_CREATE,
     ACTION_PR_EDIT,
     ALL_BARE_VOLATILE_PATH_MARKERS,
@@ -16,6 +16,7 @@ from skills_pr_loop_constants.durable_post_lint_constants import (
     ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS,
     ALL_POST_ACTIONS,
     ALL_PR_DESCRIPTION_ACTIONS,
+    ALL_RELEASE_BODY_MARKERS,
     ALL_REQUIRED_PR_DESCRIPTION_HEADINGS,
     ALL_TITLE_ACTIONS,
     BODY_FILE_ENCODING,
@@ -35,6 +36,9 @@ from skills_pr_loop_constants.durable_post_lint_constants import (
     MISSING_HEADING_MESSAGE_TEMPLATE,
     PATH_ANCHOR_CHARACTER,
     PATH_SEGMENT_START_CHARACTERS,
+    RELEASE_BRANCH_PREFIX,
+    REWRITTEN_RELEASE_BODY_CODE,
+    REWRITTEN_RELEASE_BODY_MESSAGE,
     TITLE_NOT_ALLOWED_MESSAGE,
     TITLE_REQUIRED_MESSAGE,
     VOLATILE_PATH_CODE,
@@ -82,14 +86,7 @@ def _text_has_anchored_marker(normalized_text: str, marker: str) -> bool:
 
 
 def find_volatile_path_marker(body_text: str) -> str | None:
-    """Return the first volatile path marker in a GitHub post body.
-
-    Args:
-        body_text: Post body text to scan.
-
-    Returns:
-        The matched marker, or None when the body names no volatile path.
-    """
+    """Return the first volatile path marker in a GitHub post body."""
     normalized_text = body_text.replace("\\", PATH_ANCHOR_CHARACTER).lower()
     for each_marker in ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS:
         if _text_has_anchored_marker(normalized_text, each_marker):
@@ -101,17 +98,7 @@ def find_volatile_path_marker(body_text: str) -> str | None:
 
 
 def read_body_file(body_file: Path) -> str:
-    """Read one UTF-8 body file without exposing its contents on failure.
-
-    Args:
-        body_file: Local post body file.
-
-    Returns:
-        Decoded body text.
-
-    Raises:
-        DurablePostInputError: The file is missing, unreadable, or invalid UTF-8.
-    """
+    """Read one UTF-8 body file without exposing its contents on failure."""
     try:
         return body_file.read_text(encoding=BODY_FILE_ENCODING)
     except (OSError, UnicodeError) as error:
@@ -153,9 +140,25 @@ def _title_findings(title: str | None) -> list[DurablePostFinding]:
     return [DurablePostFinding(code=INVALID_TITLE_CODE, message=INVALID_TITLE_MESSAGE)]
 
 
+def _is_release_automation_branch(head_branch: str | None) -> bool:
+    return head_branch is not None and head_branch.startswith(RELEASE_BRANCH_PREFIX)
+
+
+def _release_body_findings(body_text: str) -> list[DurablePostFinding]:
+    if all(each_marker in body_text for each_marker in ALL_RELEASE_BODY_MARKERS):
+        return []
+    return [
+        DurablePostFinding(
+            code=REWRITTEN_RELEASE_BODY_CODE,
+            message=REWRITTEN_RELEASE_BODY_MESSAGE,
+        )
+    ]
+
+
 def _body_findings(
     action: str,
     body_text: str | None,
+    head_branch: str | None = None,
 ) -> list[DurablePostFinding]:
     if body_text is None:
         return []
@@ -167,7 +170,9 @@ def _body_findings(
                 message=BODY_MUST_NOT_BE_EMPTY_MESSAGE,
             )
         )
-    if action in ALL_PR_DESCRIPTION_ACTIONS:
+    if _is_release_automation_branch(head_branch):
+        all_findings.extend(_release_body_findings(body_text))
+    elif action in ALL_PR_DESCRIPTION_ACTIONS:
         all_findings.extend(_description_heading_findings(body_text))
     if find_volatile_path_marker(body_text) is not None:
         all_findings.append(
@@ -183,22 +188,14 @@ def lint_durable_post(
     action: str,
     title: str | None,
     body_text: str | None,
+    head_branch: str | None = None,
 ) -> tuple[DurablePostFinding, ...]:
-    """Return content findings for one locally valid GitHub post request.
-
-    Args:
-        action: GitHub post action name.
-        title: Pull request title when the action accepts one.
-        body_text: Decoded body text when the action accepts a body.
-
-    Returns:
-        Content findings in stable rule order.
-
-    Raises:
-        DurablePostUsageError: The action and supplied fields are not a valid request.
-    """
+    """Return content findings for one locally valid GitHub post request."""
     _validate_request_shape(action, title, body_text)
-    return (*_title_findings(title), *_body_findings(action, body_text))
+    return (
+        *_title_findings(title),
+        *_body_findings(action, body_text, head_branch),
+    )
 
 
 def _parse_arguments(all_arguments: Sequence[str]) -> argparse.Namespace:
@@ -206,18 +203,12 @@ def _parse_arguments(all_arguments: Sequence[str]) -> argparse.Namespace:
     parser.add_argument("--action", required=True)
     parser.add_argument("--title")
     parser.add_argument("--body-file", type=Path)
+    parser.add_argument("--head-branch")
     return parser.parse_args(list(all_arguments))
 
 
 def main(all_arguments: Sequence[str]) -> int:
-    """Validate one GitHub post and return its result status.
-
-    Args:
-        all_arguments: Command arguments after the script name.
-
-    Returns:
-        Zero when clean, one for content findings, or two for invalid input.
-    """
+    """Validate one GitHub post and return its result status."""
     arguments = _parse_arguments(all_arguments)
     try:
         body_text = (
@@ -229,6 +220,7 @@ def main(all_arguments: Sequence[str]) -> int:
             action=arguments.action,
             title=arguments.title,
             body_text=body_text,
+            head_branch=arguments.head_branch,
         )
     except (DurablePostInputError, DurablePostUsageError) as error:
         sys.stderr.write(f"{error}\n")

package/{.agents/skills/_shared/pr-loop/scripts/skills_pr_loop_constants/durable_post_lint_constants.py → scripts/durable_post_lint_config/config/constants.py}

@@ -23,7 +23,6 @@ ALL_POST_ACTIONS: frozenset[str] = frozenset(
         ACTION_PR_REVIEW,
     }
 )
-
 ALL_BODY_REQUIRED_ACTIONS: frozenset[str] = frozenset(
     {
         ACTION_GITHUB_MCP_POST,
@@ -35,13 +34,10 @@ ALL_BODY_REQUIRED_ACTIONS: frozenset[str] = frozenset(
         ACTION_PR_REVIEW,
     }
 )
-
 ALL_PR_DESCRIPTION_ACTIONS: frozenset[str] = frozenset(
     {ACTION_PR_CREATE, ACTION_PR_EDIT}
 )
-
 ALL_TITLE_ACTIONS: frozenset[str] = frozenset({ACTION_PR_CREATE, ACTION_PR_EDIT})
-
 ALL_CONVENTIONAL_TITLE_TYPES: tuple[str, ...] = (
     "build",
     "chore",
@@ -55,11 +51,9 @@ ALL_CONVENTIONAL_TITLE_TYPES: tuple[str, ...] = (
     "style",
     "test",
 )
-
 CONVENTIONAL_TITLE_PATTERN: re.Pattern[str] = re.compile(
     rf"^(?:{'|'.join(ALL_CONVENTIONAL_TITLE_TYPES)})(?:\([^)\r\n]+\))?!?: [^\s].*$"
 )
-
 ALL_REQUIRED_PR_DESCRIPTION_HEADINGS: tuple[str, ...] = (
     "Summary",
     "Description",
@@ -67,12 +61,10 @@ ALL_REQUIRED_PR_DESCRIPTION_HEADINGS: tuple[str, ...] = (
     "How",
     "Verification",
 )
-
 ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS: tuple[str, ...] = (
     ".claude-profile-a/jobs/",
     ".claude/worktrees/",
 )
-
 ALL_BARE_VOLATILE_PATH_MARKERS: tuple[str, ...] = (
     "appdata/local/temp",
     "/tmp/",
@@ -80,7 +72,6 @@ ALL_BARE_VOLATILE_PATH_MARKERS: tuple[str, ...] = (
     "$env:temp",
     "$claude_job_dir",
 )
-
 BODY_FILE_ENCODING = "utf-8"
 CLEAN_EXIT_CODE = 0
 CONTENT_FINDING_EXIT_CODE = 1
@@ -88,7 +79,6 @@ EMPTY_BODY_CODE = "empty-body"
 INPUT_ERROR_EXIT_CODE = 2
 PATH_ANCHOR_CHARACTER = "/"
 PATH_SEGMENT_START_CHARACTERS = "_-"
-
 BODY_FILE_UNREADABLE_MESSAGE = "body file is not readable UTF-8 text"
 BODY_REQUIRED_MESSAGE = "this action requires a body file"
 BODY_MUST_NOT_BE_EMPTY_MESSAGE = "body file must contain text"
@@ -104,3 +94,13 @@ TITLE_NOT_ALLOWED_MESSAGE = "this action does not accept a title"
 TITLE_REQUIRED_MESSAGE = "pr-create requires a title"
 VOLATILE_PATH_CODE = "volatile-local-path"
 VOLATILE_PATH_MESSAGE = "body contains a volatile local artifact path"
+RELEASE_BRANCH_PREFIX = "release-please--branches--"
+ALL_RELEASE_BODY_MARKERS: tuple[str, ...] = (
+    ":robot: I have created a release",
+    "This PR was generated with [Release Please]",
+)
+REWRITTEN_RELEASE_BODY_CODE = "rewritten-release-body"
+REWRITTEN_RELEASE_BODY_MESSAGE = (
+    "release automation reads this body back to recognize its own merge; "
+    "keep the generated text whole"
+)

package/{.agents/skills/_shared/pr-loop/scripts/test_durable_post_lint_constants.py → scripts/durable_post_lint_config/config/test_constants.py}

@@ -1,9 +1,11 @@
 """Tests for durable GitHub post linter constants."""
 
-from skills_pr_loop_constants.durable_post_lint_constants import (
+from durable_post_lint_config.config.constants import (
     ALL_CONVENTIONAL_TITLE_TYPES,
     ALL_POST_ACTIONS,
+    ALL_RELEASE_BODY_MARKERS,
     CONVENTIONAL_TITLE_PATTERN,
+    RELEASE_BRANCH_PREFIX,
 )
 
 
@@ -23,3 +25,14 @@ def test_action_inventory_covers_pull_request_issue_and_tool_posts() -> None:
 def test_title_pattern_uses_every_configured_type() -> None:
     for each_title_type in ALL_CONVENTIONAL_TITLE_TYPES:
         assert CONVENTIONAL_TITLE_PATTERN.fullmatch(f"{each_title_type}: one change")
+
+
+def should_carry_both_markers_release_automation_writes() -> None:
+    assert ALL_RELEASE_BODY_MARKERS == (
+        ":robot: I have created a release",
+        "This PR was generated with [Release Please]",
+    )
+
+
+def should_name_the_branch_prefix_release_automation_pushes() -> None:
+    assert RELEASE_BRANCH_PREFIX == "release-please--branches--"