claude-dev-env 8.6.1 → 8.8.0

package/scripts/test_claude_account_profile.py

@@ -0,0 +1,220 @@
+"""Tests for the second-account profile sync and its launcher."""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+import claude_account_profile as profile
+
+NOW = datetime(2026, 9, 22, 21, 0, tzinfo=timezone.utc)
+
+
+def build_main_home(tmp_path: Path) -> Path:
+    main_home = tmp_path / "main"
+    (main_home / "skills" / "tdd").mkdir(parents=True)
+    (main_home / "rules").mkdir()
+    (main_home / "projects").mkdir()
+    (main_home / "CLAUDE.md").write_text("main instructions", encoding="utf-8")
+    (main_home / "settings.json").write_text("{}", encoding="utf-8")
+    (main_home / ".credentials.json").write_text("main sign-in", encoding="utf-8")
+    (main_home / ".claude.json").write_text("main state", encoding="utf-8")
+    (main_home / ".claude.json.backup").write_text("main backup", encoding="utf-8")
+    return main_home
+
+
+def sync(main_home: Path, profile_home: Path) -> profile.ProfileSyncReport:
+    return profile.sync_profile(main_home=main_home, profile_home=profile_home, now=NOW)
+
+
+class TestDefaultProfileHome:
+    def should_use_the_profiles_root_the_environment_names(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setenv("LLM_SETTINGS_PROFILES_ROOT", str(tmp_path))
+        assert profile.default_profile_home() == tmp_path / "ev"
+
+    def should_fall_back_to_the_profiles_root_in_the_user_home(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.delenv("LLM_SETTINGS_PROFILES_ROOT", raising=False)
+        monkeypatch.setattr(Path, "home", lambda: tmp_path)
+        assert profile.default_profile_home() == tmp_path / ".claude-profiles" / "ev"
+
+
+class TestIsAccountLocal:
+    def should_keep_sign_in_state_and_history_local(self) -> None:
+        for each_name in (
+            ".credentials.json",
+            ".credentials.json.bak-session-dashboard",
+            ".claude.json",
+            ".claude.json.backup",
+            "projects",
+        ):
+            assert profile.is_account_local(each_name)
+
+    def should_share_skills_rules_and_settings(self) -> None:
+        for each_name in ("skills", "rules", "CLAUDE.md", "settings.json", "plugins"):
+            assert not profile.is_account_local(each_name)
+
+
+class TestSyncProfile:
+    def should_link_every_shared_entry_to_the_main_home(self, tmp_path: Path) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        sync(main_home, profile_home)
+        assert (profile_home / "skills" / "tdd").is_dir()
+        assert (profile_home / "CLAUDE.md").read_text(
+            encoding="utf-8"
+        ) == "main instructions"
+        assert profile.links_to(profile_home / "rules", main_home / "rules")
+        assert profile.links_to(
+            profile_home / "settings.json", main_home / "settings.json"
+        )
+
+    def should_keep_the_accounts_own_sign_in_state_and_history_apart(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / ".credentials.json").write_text(
+            "second sign-in", encoding="utf-8"
+        )
+        sync(main_home, profile_home)
+        assert (profile_home / ".credentials.json").read_text(
+            encoding="utf-8"
+        ) == "second sign-in"
+        assert not (profile_home / ".claude.json").exists()
+        assert not (profile_home / ".claude.json.backup").exists()
+        assert not (profile_home / "projects").exists()
+
+    def should_move_a_stale_copy_aside_and_keep_its_content(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / "CLAUDE.md").write_text("stale copy", encoding="utf-8")
+        report = sync(main_home, profile_home)
+        moved_copy = (
+            profile_home / ".replaced" / NOW.strftime("%Y%m%dT%H%M%SZ") / "CLAUDE.md"
+        )
+        assert moved_copy.read_text(encoding="utf-8") == "stale copy"
+        assert profile.links_to(profile_home / "CLAUDE.md", main_home / "CLAUDE.md")
+        assert report.all_moved_aside == ("CLAUDE.md",)
+
+    def should_remove_a_same_content_copy_without_moving_it_aside(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / "CLAUDE.md").write_text("main instructions", encoding="utf-8")
+        report = sync(main_home, profile_home)
+        assert report.all_moved_aside == ()
+        assert not (profile_home / ".replaced").exists()
+        assert profile.links_to(profile_home / "CLAUDE.md", main_home / "CLAUDE.md")
+
+    def should_move_aside_a_link_that_points_somewhere_else(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        elsewhere = tmp_path / "old-shared" / "rules"
+        elsewhere.mkdir(parents=True)
+        (elsewhere / "keep.md").write_text("old rule", encoding="utf-8")
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        (profile_home / "rules").symlink_to(elsewhere, target_is_directory=True)
+        report = sync(main_home, profile_home)
+        assert (elsewhere / "keep.md").read_text(encoding="utf-8") == "old rule"
+        assert profile.links_to(profile_home / "rules", main_home / "rules")
+        assert report.all_moved_aside == ("rules",)
+
+    def should_change_nothing_on_a_second_run(self, tmp_path: Path) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        sync(main_home, profile_home)
+        second_report = sync(main_home, profile_home)
+        assert second_report.all_linked == ()
+        assert second_report.all_moved_aside == ()
+        assert second_report.all_unlinked == ()
+
+    def should_unlink_an_entry_the_main_home_no_longer_has(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        profile_home = tmp_path / "ev"
+        sync(main_home, profile_home)
+        (main_home / "rules").rmdir()
+        report = sync(main_home, profile_home)
+        assert not os.path.lexists(profile_home / "rules")
+        assert report.all_unlinked == ("rules",)
+
+
+    def should_remove_a_main_link_left_under_an_account_local_name(
+        self, tmp_path: Path
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        (main_home / ".credentials.json.bak").write_text("main backup", encoding="utf-8")
+        profile_home = tmp_path / "ev"
+        profile_home.mkdir()
+        os.link(main_home / ".credentials.json.bak", profile_home / ".credentials.json.bak")
+        report = sync(main_home, profile_home)
+        assert not os.path.lexists(profile_home / ".credentials.json.bak")
+        assert (main_home / ".credentials.json.bak").read_text(
+            encoding="utf-8"
+        ) == "main backup"
+        assert report.all_unlinked == (".credentials.json.bak",)
+
+
+class TestWriteLauncher:
+    def should_point_claude_at_the_profile_and_pass_every_argument(
+        self, tmp_path: Path
+    ) -> None:
+        profile_home = tmp_path / "ev"
+        launcher_path = profile.write_launcher(
+            launcher_directory=tmp_path / "bin", profile_home=profile_home, now=NOW
+        )
+        launcher_text = launcher_path.read_text(encoding="utf-8")
+        assert f'set "CLAUDE_CONFIG_DIR={profile_home}"' in launcher_text
+        assert "claude %*" in launcher_text
+
+    def should_move_an_older_launcher_aside(self, tmp_path: Path) -> None:
+        launcher_directory = tmp_path / "bin"
+        launcher_directory.mkdir()
+        (launcher_directory / "claude-ev.cmd").write_text(
+            "old launcher", encoding="utf-8"
+        )
+        profile.write_launcher(
+            launcher_directory=launcher_directory, profile_home=tmp_path / "ev", now=NOW
+        )
+        moved_launcher = launcher_directory / (
+            "claude-ev.cmd.replaced-" + NOW.strftime("%Y%m%dT%H%M%SZ")
+        )
+        assert moved_launcher.read_text(encoding="utf-8") == "old launcher"
+
+
+class TestMain:
+    def should_print_what_the_sync_changed(
+        self, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+    ) -> None:
+        main_home = build_main_home(tmp_path)
+        exit_code = profile.main(
+            [
+                "--main-home",
+                str(main_home),
+                "--profile-home",
+                str(tmp_path / "ev"),
+                "--launcher-directory",
+                str(tmp_path / "bin"),
+            ]
+        )
+        printed = json.loads(capsys.readouterr().out)
+        assert exit_code == 0
+        assert "CLAUDE.md" in printed["linked"]
+        assert printed["launcher"] == str(tmp_path / "bin" / "claude-ev.cmd")

package/scripts/test_claude_chain_usage.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import subprocess
 import sys
+from datetime import datetime
 from pathlib import Path
 
 import pytest
@@ -372,7 +373,10 @@ def test_probe_weekly_utilization_reuses_resolver_windows(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     class _FakeWindows:
+        session_utilization = None
+        session_resets_at = None
         weekly_utilization = 37.5
+        weekly_resets_at = None
 
     class _FakeResolver:
         def read_oauth_access_token(self, credentials_path: Path, now: object) -> str:
@@ -401,6 +405,42 @@ def test_probe_weekly_utilization_reuses_resolver_windows(
     assert weekly_utilization == pytest.approx(37.5)
 
 
+def should_read_both_meters_and_their_resets_for_one_account(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    session_reset = datetime(2026, 9, 22, 23, 0).astimezone()
+    weekly_reset = datetime(2026, 9, 26, 9, 0).astimezone()
+
+    class _FakeWindows:
+        session_utilization = 12.0
+        session_resets_at = session_reset
+        weekly_utilization = 64.0
+        weekly_resets_at = weekly_reset
+
+    class _FakeResolver:
+        def read_oauth_access_token(self, credentials_path: Path, now: object) -> str:
+            return "token-value"
+
+        def _fetch_usage_payload(self, access_token: str) -> dict[str, object]:
+            return {}
+
+        def extract_usage_windows(
+            self, usage_payload: dict[str, object]
+        ) -> _FakeWindows:
+            return _FakeWindows()
+
+    monkeypatch.setattr(
+        usage, "_load_resolve_usage_window_module", lambda: _FakeResolver()
+    )
+    account_meters = usage.probe_account_meters(Path(PLACEHOLDER_CREDENTIALS_PRIMARY))
+    assert account_meters == usage.AccountUsageMeters(
+        session_utilization=12.0,
+        session_resets_at=session_reset,
+        weekly_utilization=64.0,
+        weekly_resets_at=weekly_reset,
+    )
+
+
 def test_probe_weekly_utilization_raises_when_token_missing(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

package/scripts/test_durable_post_lint.py

@@ -460,3 +460,49 @@ def should_report_a_rewritten_release_body_through_the_command_line(
     )
     assert completed_process.returncode == 1
     assert "keep the generated text whole" in completed_process.stderr
+
+
+def test_contrast_framing_in_a_body_reports() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-comment",
+        title=None,
+        body_text="The queue ejected the entry, not the runner.\n",
+    )
+
+    assert [each_finding.code for each_finding in all_findings] == ["contrast-framing"]
+    assert "trailing-comma-not" in all_findings[0].message
+
+
+def test_contrast_framing_in_a_title_reports() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-create",
+        title="fix(lint): read the base rather than the worktree",
+        body_text=VALID_PR_BODY,
+    )
+
+    assert [each_finding.code for each_finding in all_findings] == ["contrast-framing"]
+    assert "substitution-rather-than" in all_findings[0].message
+
+
+def test_a_body_stating_what_is_stays_clean() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-comment",
+        title=None,
+        body_text="The queue ejected the entry. The runner stayed up.\n",
+    )
+
+    assert all_findings == ()
+
+
+def test_a_release_body_carrying_a_contrast_stays_accepted() -> None:
+    all_findings = durable_post_lint.lint_durable_post(
+        action="pr-edit",
+        title=None,
+        body_text=RELEASE_BODY.replace(
+            "This PR was generated with",
+            "Bumped rather than pinned. This PR was generated with",
+        ),
+        head_branch=RELEASE_BRANCH,
+    )
+
+    assert all_findings == ()

package/scripts/test_followup_cli.py

@@ -9,6 +9,8 @@ from pathlib import Path
 
 from dev_env_scripts_constants.followup_constants import (
     BACKLOG_EXCEEDED_EXIT_CODE,
+    BACKLOG_EXCEEDED_TEMPLATE,
+    BACKLOG_WITHIN_TEMPLATE,
     FOLLOWUP_BACKLOG_THRESHOLD,
 )
 from followup_cli import main
@@ -251,6 +253,44 @@ def test_count_escalates_once_the_backlog_passes_the_threshold(
     assert str(FOLLOWUP_BACKLOG_THRESHOLD) in output_text
 
 
+def test_count_writes_the_within_threshold_template_verbatim(
+    tmp_path: Path,
+) -> None:
+    exit_code, output_text = run_command(["count", "--repository-root", str(tmp_path)])
+
+    assert exit_code == 0
+    assert output_text == (
+        BACKLOG_WITHIN_TEMPLATE.format(
+            finding_count=0, threshold=FOLLOWUP_BACKLOG_THRESHOLD
+        )
+        + "\n"
+    )
+
+
+def test_count_writes_the_exceeded_template_verbatim(tmp_path: Path) -> None:
+    for each_index in range(FOLLOWUP_BACKLOG_THRESHOLD + 1):
+        record_followup_finding(
+            tmp_path,
+            FollowupFinding(
+                "code-rules",
+                f"run{each_index}.py",
+                "one smell",
+                f"code-rules/x{each_index}",
+            ),
+        )
+
+    exit_code, output_text = run_command(["count", "--repository-root", str(tmp_path)])
+
+    assert exit_code == BACKLOG_EXCEEDED_EXIT_CODE
+    assert output_text == (
+        BACKLOG_EXCEEDED_TEMPLATE.format(
+            finding_count=FOLLOWUP_BACKLOG_THRESHOLD + 1,
+            threshold=FOLLOWUP_BACKLOG_THRESHOLD,
+        )
+        + "\n"
+    )
+
+
 def test_list_names_the_check_behind_each_finding(tmp_path: Path) -> None:
     record_followup_finding(
         tmp_path,

package/scripts/test_merge_gate_checks.py

@@ -0,0 +1,92 @@
+"""Specifications for holding a merge policy document to its branch ruleset."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from merge_gate_checks import (
+    main,
+    missing_contexts,
+    parse_declared_contexts,
+    ruleset_contexts,
+)
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[3]
+POLICY_DOCUMENT_PATH = REPOSITORY_ROOT / "docs" / "merge-policy.md"
+RULESET_SNAPSHOT_PATH = REPOSITORY_ROOT / "docs" / "merge-policy-ruleset.json"
+INSTRUCTION_PAIRS_CONTEXT = "instruction-pairs / instruction-pairs"
+UTF8_ENCODING = "utf-8"
+
+
+def _ruleset_with_contexts(*all_contexts: str) -> list[dict[str, object]]:
+    return [
+        {"type": "deletion"},
+        {
+            "type": "required_status_checks",
+            "parameters": {
+                "required_status_checks": [
+                    {"context": each_context, "integration_id": 15368}
+                    for each_context in all_contexts
+                ]
+            },
+        },
+    ]
+
+
+def should_read_the_contexts_the_fenced_block_declares() -> None:
+    document_text = (
+        "# Merge policy\n\n"
+        "```required-status-checks\n"
+        f"{INSTRUCTION_PAIRS_CONTEXT}\n"
+        "```\n\n"
+        "```\n"
+        "python merge_gate_checks.py --refresh\n"
+        "```\n"
+    )
+
+    assert parse_declared_contexts(document_text) == [INSTRUCTION_PAIRS_CONTEXT]
+
+
+def should_ignore_a_document_with_no_declaration_block() -> None:
+    assert parse_declared_contexts("# Merge policy\n\nNo block here.\n") == []
+
+
+def should_read_every_context_the_ruleset_requires() -> None:
+    payload = _ruleset_with_contexts(INSTRUCTION_PAIRS_CONTEXT, "Ruff")
+
+    assert ruleset_contexts(payload) == {INSTRUCTION_PAIRS_CONTEXT, "Ruff"}
+
+
+def should_report_a_check_the_ruleset_stopped_requiring() -> None:
+    document_text = f"```required-status-checks\n{INSTRUCTION_PAIRS_CONTEXT}\n```\n"
+
+    assert missing_contexts(document_text, _ruleset_with_contexts("Ruff")) == [
+        INSTRUCTION_PAIRS_CONTEXT
+    ]
+
+
+def should_find_every_check_the_checked_in_policy_names() -> None:
+    document_text = POLICY_DOCUMENT_PATH.read_text(encoding=UTF8_ENCODING)
+    ruleset_payload = json.loads(
+        RULESET_SNAPSHOT_PATH.read_text(encoding=UTF8_ENCODING)
+    )
+
+    assert parse_declared_contexts(document_text)
+    assert missing_contexts(document_text, ruleset_payload) == []
+
+
+def should_exit_non_zero_when_a_named_check_left_the_ruleset(tmp_path: Path) -> None:
+    document_path = tmp_path / "merge-policy.md"
+    document_path.write_text(
+        f"```required-status-checks\n{INSTRUCTION_PAIRS_CONTEXT}\n```\n",
+        encoding=UTF8_ENCODING,
+    )
+    ruleset_path = tmp_path / "merge-policy-ruleset.json"
+    ruleset_path.write_text(
+        json.dumps(_ruleset_with_contexts("Ruff")), encoding=UTF8_ENCODING
+    )
+
+    exit_code = main(["--document", str(document_path), "--ruleset", str(ruleset_path)])
+
+    assert exit_code == 1

package/scripts/tests/test_code_review_constants.py

@@ -0,0 +1,78 @@
+"""Specifications for the permission modes the review binary is asked for.
+
+The review binary accepts one permission mode for an ordinary caller and a
+different one for root. Naming the wrong mode means the binary refuses the
+call, no review runs, and no stamp is ever minted.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+
+import pytest
+from dev_env_scripts_constants import code_review_constants
+
+BYPASS_MODE_TOKEN: str = "bypassPermissions"
+ACCEPT_EDITS_MODE_TOKEN: str = "acceptEdits"
+ROOT_USER_ID: int = 0
+UNPRIVILEGED_USER_ID: int = 1000
+
+
+def _permission_mode_seen_by(
+    monkeypatch: pytest.MonkeyPatch, effective_user_id: int
+) -> str:
+    """Read the review permission mode a caller with this user id resolves."""
+    monkeypatch.setattr(os, "geteuid", lambda: effective_user_id)
+    reloaded_constants = importlib.reload(code_review_constants)
+    return str(reloaded_constants.REVIEW_PERMISSION_MODE)
+
+
+def test_root_detection_agrees_with_this_process(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(os, "geteuid", lambda: ROOT_USER_ID)
+    reloaded_constants = importlib.reload(code_review_constants)
+
+    assert reloaded_constants.IS_ROOT_CALLER is True
+    assert reloaded_constants.ROOT_EFFECTIVE_USER_ID == ROOT_USER_ID
+
+
+def test_bypass_mode_names_the_token_the_binary_reads() -> None:
+    assert code_review_constants.PERMISSION_MODE_BYPASS == BYPASS_MODE_TOKEN
+
+
+def test_accept_edits_mode_names_the_token_the_binary_reads() -> None:
+    assert code_review_constants.PERMISSION_MODE_ACCEPT_EDITS == ACCEPT_EDITS_MODE_TOKEN
+
+
+def test_a_root_caller_resolves_the_mode_the_binary_accepts(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    assert _permission_mode_seen_by(monkeypatch, ROOT_USER_ID) == (
+        ACCEPT_EDITS_MODE_TOKEN
+    )
+
+
+def test_an_ordinary_caller_resolves_the_bypass_mode(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    assert _permission_mode_seen_by(monkeypatch, UNPRIVILEGED_USER_ID) == (
+        BYPASS_MODE_TOKEN
+    )
+
+
+def test_a_platform_without_a_user_id_still_loads_the_constants(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Windows exposes no ``os.geteuid``, and the module still imports.
+
+    Reading a missing ``os.geteuid`` raises, and every caller of the review
+    invoker dies at import. A platform that reports no user id is never the
+    root the review binary refuses, so it reads as an ordinary caller.
+    """
+    monkeypatch.delattr(os, "geteuid", raising=False)
+    reloaded_constants = importlib.reload(code_review_constants)
+
+    assert reloaded_constants.IS_ROOT_CALLER is False
+    assert reloaded_constants.REVIEW_PERMISSION_MODE == BYPASS_MODE_TOKEN

package/scripts/tests/test_codex_compat_materializer.py

@@ -173,9 +173,9 @@ def test_public_legacy_call_forms_validate_collection_entries(tmp_path: Path) ->
         publish_plan(config, all_planned_files=[object()])
 
 
-def test_render_codex_failure_blast_radius_requires_the_excerpt_heading() -> None:
-    with pytest.raises(MaterializerError, match="requires a Codex excerpt"):
-        materializer.render_codex_failure_blast_radius("# No excerpt\n")
+def test_render_codex_instruction_excerpt_requires_the_excerpt_heading() -> None:
+    with pytest.raises(MaterializerError, match="rules/correction-lens.md requires a Codex excerpt"):
+        materializer.render_codex_instruction_excerpt("# No excerpt\n", "rules/correction-lens.md")
 
 
 def test_validation_rejects_reparse_point_from_portable_attribute_seam(
@@ -823,13 +823,57 @@ def test_failure_blast_radius_projection_uses_the_canonical_excerpt() -> None:
     canonical_rule_path = Path(__file__).parents[2] / "rules" / "failure-blast-radius.md"
     canonical_rule = canonical_rule_path.read_text(encoding="utf-8")
 
-    projected_instruction = materializer.render_codex_failure_blast_radius(canonical_rule)
+    projected_instruction = materializer.render_codex_instruction_excerpt(
+        canonical_rule, "rules/failure-blast-radius.md"
+    )
 
     assert projected_instruction.startswith("Failure handling for this run")
     assert "Three attempts, then park." in projected_instruction
     assert "Report as: N of M complete" in projected_instruction
 
 
+def test_codex_instruction_projection_carries_every_listed_rule(tmp_path: Path) -> None:
+    rules_root = Path(__file__).parents[2] / "rules"
+    source = tmp_path / "source"
+    target = tmp_path / "target"
+    (source / "rules").mkdir(parents=True)
+    for each_relative_path in materializer.codex_instruction_rule_relative_paths:
+        canonical_path = rules_root / Path(each_relative_path).name
+        (source / each_relative_path).write_text(
+            canonical_path.read_text(encoding="utf-8"), encoding="utf-8"
+        )
+    config = MaterializerConfig(source, target, should_apply=True)
+
+    planned, report = build_plan(config, all_agents=[])
+    publish_plan(config, planned, report)
+
+    projected_instruction = (target / "AGENTS.md").read_text(encoding="utf-8")
+    assert "Failure handling for this run" in projected_instruction
+    assert "Correction handling for this run" in projected_instruction
+    manifest_record = _manifest_files(_required_manifest_path(config))["AGENTS.md"]
+    assert manifest_record["source"] == "rules/failure-blast-radius.md, rules/correction-lens.md"
+
+
+def test_codex_instruction_projection_skips_an_absent_listed_rule(
+    tmp_path: Path,
+) -> None:
+    rules_root = Path(__file__).parents[2] / "rules"
+    source = tmp_path / "source"
+    (source / "rules").mkdir(parents=True)
+    (source / "rules" / "correction-lens.md").write_text(
+        (rules_root / "correction-lens.md").read_text(encoding="utf-8"),
+        encoding="utf-8",
+    )
+    config = MaterializerConfig(source, tmp_path / "target", should_apply=False)
+
+    projection = materializer._build_codex_instruction_projection(config)
+
+    assert projection is not None
+    assert projection.source_identity == "rules/correction-lens.md"
+    assert "Correction handling for this run" in projection.content
+    assert "Failure handling for this run" not in projection.content
+
+
 def test_build_plan_publishes_owned_agents_projection_and_tracks_drift(
     tmp_path: Path,
 ) -> None: