claude-dev-env 2.7.1 → 2.9.0

package/scripts/test_grok_run_ledger.py

@@ -0,0 +1,116 @@
+"""Behavioral tests for the host-neutral Grok run ledger."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from dev_env_scripts_constants.grok_run_ledger_constants import (  # noqa: E402
+    TASK_STATUS_ADVISOR_BLOCKED,
+    TASK_STATUS_COMPLETED,
+    TASK_STATUS_PENDING,
+    TASK_STATUS_PENDING_REVIEW,
+)
+from grok_run_ledger import GrokRunLedger, is_legal_status  # noqa: E402
+
+
+def test_register_task_persists_atomically(tmp_path: Path) -> None:
+    ledger = GrokRunLedger(tmp_path)
+    ledger.register_task(task_id="O-04", all_dependencies=())
+    reloaded = GrokRunLedger(tmp_path)
+    record = reloaded.get_task("O-04")
+    assert record.status == TASK_STATUS_PENDING
+    assert is_legal_status(record.status)
+    payload = json.loads((tmp_path / "grok-run-ledger.json").read_text(encoding="utf-8"))
+    assert payload["tasks"][0]["task_id"] == "O-04"
+
+
+def test_dependencies_block_dispatch(tmp_path: Path) -> None:
+    ledger = GrokRunLedger(tmp_path)
+    ledger.register_task(task_id="dep", all_dependencies=())
+    ledger.register_task(task_id="child", all_dependencies=("dep",))
+    assert ledger.can_dispatch("child") is False
+    with pytest.raises(ValueError, match="dependencies"):
+        ledger.mark_in_progress(
+            task_id="child",
+            owner_id="w1",
+            advisor_session_id="s1",
+            base_sha="aaa",
+        )
+    ledger.mark_in_progress(
+        task_id="dep", owner_id="w0", advisor_session_id="s0", base_sha="aaa"
+    )
+    ledger.mark_completed(
+        task_id="dep",
+        reviewed_head="bbb",
+        all_changed_paths=(),
+        advisor_verdict="ENDORSE",
+        all_acceptance_mapping={},
+        all_test_evidence=["ok"],
+    )
+    assert ledger.can_dispatch("child") is True
+
+
+def test_one_live_owner_and_unique_advisor_session(tmp_path: Path) -> None:
+    ledger = GrokRunLedger(tmp_path)
+    ledger.register_task(task_id="a", all_dependencies=())
+    ledger.register_task(task_id="b", all_dependencies=())
+    ledger.mark_in_progress(
+        task_id="a", owner_id="owner", advisor_session_id="sess-a", base_sha="1"
+    )
+    with pytest.raises(ValueError, match="owner already live"):
+        ledger.mark_in_progress(
+            task_id="b", owner_id="owner", advisor_session_id="sess-b", base_sha="1"
+        )
+    with pytest.raises(ValueError, match="advisor session already bound"):
+        ledger.mark_in_progress(
+            task_id="b", owner_id="other", advisor_session_id="sess-a", base_sha="1"
+        )
+
+
+def test_snapshot_drift_moves_to_pending_review(tmp_path: Path) -> None:
+    ledger = GrokRunLedger(tmp_path)
+    ledger.register_task(task_id="t", all_dependencies=())
+    ledger.mark_in_progress(
+        task_id="t", owner_id="w", advisor_session_id="s", base_sha="base"
+    )
+    record = ledger.invalidate_on_snapshot_drift(task_id="t", current_sha="drifted")
+    assert record.status == TASK_STATUS_PENDING_REVIEW
+    assert record.owner_id is None
+
+
+def test_advisor_blocked_terminal(tmp_path: Path) -> None:
+    ledger = GrokRunLedger(tmp_path)
+    ledger.register_task(task_id="t", all_dependencies=())
+    ledger.mark_in_progress(
+        task_id="t", owner_id="w", advisor_session_id="s", base_sha="base"
+    )
+    record = ledger.mark_advisor_blocked(task_id="t", reason="bind failed")
+    assert record.status == TASK_STATUS_ADVISOR_BLOCKED
+    assert "bind failed" in record.test_evidence[0]
+
+
+def test_completed_records_acceptance_and_head(tmp_path: Path) -> None:
+    ledger = GrokRunLedger(tmp_path)
+    ledger.register_task(task_id="t", all_dependencies=())
+    ledger.mark_in_progress(
+        task_id="t", owner_id="w", advisor_session_id="s", base_sha="base"
+    )
+    record = ledger.mark_completed(
+        task_id="t",
+        reviewed_head="head",
+        all_changed_paths=("a.py",),
+        advisor_verdict="ENDORSE",
+        all_acceptance_mapping={"criterion": "evidence"},
+        all_test_evidence=["pytest -q"],
+    )
+    assert record.status == TASK_STATUS_COMPLETED
+    assert record.reviewed_head == "head"
+    assert record.changed_paths == ("a.py",)

package/scripts/test_invoke_code_review.py

@@ -15,11 +15,37 @@ import pytest
 import invoke_code_review as invoker
 from claude_chain_runner import ChainConfigurationError, ChainInvocationOutcome
 from _code_review_test_support import FIXTURE_SESSION_OPUS
+from dev_env_scripts_constants.claude_chain_constants import TERMINAL_STATUS_SERVED
 from dev_env_scripts_constants.code_review_constants import (
+    ALL_FINDING_SEVERITIES,
+    ALL_LOOP_TERMINALS,
+    ALL_RETAINED_VERIFICATION_VERDICTS,
     DEFAULT_CODE_REVIEW_EFFORT,
+    FINDING_FIELD_SEVERITY,
+    FINDING_FIELD_VERDICT,
     PERMISSION_MODE_ACCEPT_EDITS,
     PERMISSION_MODE_BYPASS,
+    RESULT_KEY_DRAFT_PRESERVED,
+    RESULT_KEY_REVIEWED_HEAD_COUNT,
+    RESULT_KEY_SURVIVING_FINDINGS,
+    RESULT_KEY_TERMINAL,
     REVIEW_PERMISSION_MODE,
+    SEVERITY_BLOCKER,
+    SEVERITY_HIGH,
+    SEVERITY_LOW,
+    SEVERITY_MEDIUM,
+    SEVERITY_NIT,
+    TERMINAL_ADVISOR_BLOCKED,
+    TERMINAL_CLEAN,
+    TERMINAL_NITS_FIXED,
+    VERDICT_CONFIRMED,
+    VERDICT_PLAUSIBLE,
+    VERDICT_REFUTED,
+    all_findings_carry_severity_and_verdict,
+    encode_review_loop_terminal_result,
+    is_nits_only_findings,
+    record_reviewed_head,
+    resolve_review_loop_terminal,
 )
 
 
@@ -66,6 +92,7 @@ def _serve_a_refusing_binary(
         stdout=EMPTY_REVIEW_STDOUT,
         stderr=REVIEW_BINARY_REFUSAL_TEXT,
         attempts=(),
+        terminal_status=TERMINAL_STATUS_SERVED,
     )
 
 
@@ -141,3 +168,274 @@ def test_host_profile_failure_reports_its_reason_on_stderr(
     captured_streams = capsys.readouterr()
     assert outcome.is_stamp_minted is False
     assert HOST_PROFILE_FAILURE_TEXT in captured_streams.err
+
+
+HEAD_SHA_ONE: str = "aaa111"
+HEAD_SHA_TWO: str = "bbb222"
+HEAD_SHA_THREE: str = "ccc333"
+HEAD_SHA_FOUR: str = "ddd444"
+FINDING_FILE_PATH: str = "pkg/module.py"
+FINDING_LINE_NUMBER: int = 12
+FINDING_SUMMARY_TEXT: str = "example finding"
+
+
+def _retained_finding(
+    *,
+    severity: str,
+    verdict: str = VERDICT_CONFIRMED,
+) -> dict[str, object]:
+    return {
+        "file": FINDING_FILE_PATH,
+        "line": FINDING_LINE_NUMBER,
+        "summary": FINDING_SUMMARY_TEXT,
+        FINDING_FIELD_SEVERITY: severity,
+        FINDING_FIELD_VERDICT: verdict,
+    }
+
+
+def test_severity_vocabulary_is_the_frozen_five_token_set() -> None:
+    assert ALL_FINDING_SEVERITIES == (
+        SEVERITY_BLOCKER,
+        SEVERITY_HIGH,
+        SEVERITY_MEDIUM,
+        SEVERITY_LOW,
+        SEVERITY_NIT,
+    )
+    assert ALL_FINDING_SEVERITIES == (
+        "blocker",
+        "high",
+        "medium",
+        "low",
+        "nit",
+    )
+
+
+def test_loop_terminals_are_the_frozen_three_token_set() -> None:
+    assert ALL_LOOP_TERMINALS == (
+        TERMINAL_CLEAN,
+        TERMINAL_NITS_FIXED,
+        TERMINAL_ADVISOR_BLOCKED,
+    )
+
+
+def test_retained_finding_requires_severity_and_verification_verdict() -> None:
+    complete_finding = _retained_finding(severity=SEVERITY_HIGH)
+    missing_severity = {
+        "file": FINDING_FILE_PATH,
+        "line": FINDING_LINE_NUMBER,
+        FINDING_FIELD_VERDICT: VERDICT_CONFIRMED,
+    }
+    missing_verdict = {
+        "file": FINDING_FILE_PATH,
+        "line": FINDING_LINE_NUMBER,
+        FINDING_FIELD_SEVERITY: SEVERITY_HIGH,
+    }
+    refuted_finding = _retained_finding(
+        severity=SEVERITY_LOW,
+        verdict=VERDICT_REFUTED,
+    )
+
+    assert all_findings_carry_severity_and_verdict([complete_finding]) is True
+    assert all_findings_carry_severity_and_verdict([missing_severity]) is False
+    assert all_findings_carry_severity_and_verdict([missing_verdict]) is False
+    assert all_findings_carry_severity_and_verdict([refuted_finding]) is False
+    assert VERDICT_CONFIRMED in ALL_RETAINED_VERIFICATION_VERDICTS
+    assert VERDICT_PLAUSIBLE in ALL_RETAINED_VERIFICATION_VERDICTS
+    assert VERDICT_REFUTED not in ALL_RETAINED_VERIFICATION_VERDICTS
+
+
+def test_review_of_new_head_increments_reviewed_head_count_once() -> None:
+    after_first = record_reviewed_head((), HEAD_SHA_ONE)
+    after_same_head = record_reviewed_head(after_first, HEAD_SHA_ONE)
+    after_second = record_reviewed_head(after_same_head, HEAD_SHA_TWO)
+
+    assert after_first == (HEAD_SHA_ONE,)
+    assert after_same_head == (HEAD_SHA_ONE,)
+    assert after_second == (HEAD_SHA_ONE, HEAD_SHA_TWO)
+    assert len(after_second) == 2
+
+
+def test_empty_findings_return_clean() -> None:
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=(),
+        reviewed_head_count=1,
+        is_gates_passed=True,
+        is_nits_applied=False,
+    )
+
+    assert terminal_status == TERMINAL_CLEAN
+
+
+def test_empty_findings_continue_when_gates_have_not_passed() -> None:
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=(),
+        reviewed_head_count=1,
+        is_gates_passed=False,
+        is_nits_applied=False,
+    )
+
+    assert terminal_status is None
+
+
+def test_nits_only_round_returns_nits_fixed_after_gates() -> None:
+    all_nits = (
+        _retained_finding(severity=SEVERITY_NIT),
+        _retained_finding(severity=SEVERITY_NIT, verdict=VERDICT_PLAUSIBLE),
+    )
+
+    assert is_nits_only_findings(all_nits) is True
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=all_nits,
+        reviewed_head_count=1,
+        is_gates_passed=True,
+        is_nits_applied=True,
+    )
+
+    assert terminal_status == TERMINAL_NITS_FIXED
+
+
+def test_nits_without_retained_verdict_do_not_return_nits_fixed() -> None:
+    severity_only_nit = {
+        "file": FINDING_FILE_PATH,
+        "line": FINDING_LINE_NUMBER,
+        "summary": FINDING_SUMMARY_TEXT,
+        FINDING_FIELD_SEVERITY: SEVERITY_NIT,
+    }
+
+    assert is_nits_only_findings((severity_only_nit,)) is True
+    assert all_findings_carry_severity_and_verdict((severity_only_nit,)) is False
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=(severity_only_nit,),
+        reviewed_head_count=1,
+        is_gates_passed=True,
+        is_nits_applied=True,
+    )
+
+    assert terminal_status is None
+
+
+def test_open_non_nit_findings_continue_at_any_head_count() -> None:
+    all_findings = (
+        _retained_finding(severity=SEVERITY_HIGH),
+        _retained_finding(severity=SEVERITY_NIT),
+    )
+    all_heads = record_reviewed_head((), HEAD_SHA_ONE)
+    all_heads = record_reviewed_head(all_heads, HEAD_SHA_TWO)
+    all_heads = record_reviewed_head(all_heads, HEAD_SHA_THREE)
+    all_heads = record_reviewed_head(all_heads, HEAD_SHA_FOUR)
+
+    assert len(all_heads) == 4
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=all_findings,
+        reviewed_head_count=len(all_heads),
+        is_gates_passed=True,
+        is_nits_applied=False,
+    )
+
+    assert terminal_status is None
+
+
+def test_unclassified_findings_continue_when_advisor_is_reachable() -> None:
+    unclassified_finding = {
+        "file": FINDING_FILE_PATH,
+        "line": FINDING_LINE_NUMBER,
+        "summary": FINDING_SUMMARY_TEXT,
+        FINDING_FIELD_VERDICT: VERDICT_CONFIRMED,
+    }
+
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=(unclassified_finding,),
+        reviewed_head_count=5,
+        is_gates_passed=True,
+        is_nits_applied=False,
+    )
+
+    assert terminal_status is None
+
+
+def test_nits_only_returns_nits_fixed_at_any_head_count() -> None:
+    all_nits = (_retained_finding(severity=SEVERITY_NIT),)
+
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=all_nits,
+        reviewed_head_count=5,
+        is_gates_passed=True,
+        is_nits_applied=True,
+    )
+
+    assert terminal_status == TERMINAL_NITS_FIXED
+
+
+def test_advisor_unreachable_with_unclassified_returns_advisor_blocked() -> None:
+    unclassified_finding = {
+        "file": FINDING_FILE_PATH,
+        "line": FINDING_LINE_NUMBER,
+        FINDING_FIELD_VERDICT: VERDICT_CONFIRMED,
+    }
+
+    terminal_status = resolve_review_loop_terminal(
+        all_findings=(unclassified_finding,),
+        reviewed_head_count=1,
+        is_gates_passed=False,
+        is_nits_applied=False,
+        is_advisor_unreachable=True,
+    )
+
+    assert terminal_status == TERMINAL_ADVISOR_BLOCKED
+
+
+def test_terminal_serialization_preserves_draft_and_findings() -> None:
+    surviving_finding = _retained_finding(severity=SEVERITY_MEDIUM)
+    encoded_payload = encode_review_loop_terminal_result(
+        terminal=TERMINAL_ADVISOR_BLOCKED,
+        all_surviving_findings=(surviving_finding,),
+        reviewed_head_count=4,
+        is_draft_preserved=True,
+    )
+
+    assert encoded_payload[RESULT_KEY_TERMINAL] == TERMINAL_ADVISOR_BLOCKED
+    assert encoded_payload[RESULT_KEY_DRAFT_PRESERVED] is True
+    assert encoded_payload[RESULT_KEY_REVIEWED_HEAD_COUNT] == 4
+    assert encoded_payload[RESULT_KEY_SURVIVING_FINDINGS] == [surviving_finding]
+
+
+def test_advisor_blocked_forces_draft_preserved_when_caller_passes_false() -> None:
+    surviving_finding = _retained_finding(severity=SEVERITY_HIGH)
+    advisor_blocked_payload = encode_review_loop_terminal_result(
+        terminal=TERMINAL_ADVISOR_BLOCKED,
+        all_surviving_findings=(surviving_finding,),
+        reviewed_head_count=1,
+        is_draft_preserved=False,
+    )
+    clean_payload = encode_review_loop_terminal_result(
+        terminal=TERMINAL_CLEAN,
+        all_surviving_findings=(),
+        reviewed_head_count=1,
+        is_draft_preserved=False,
+    )
+
+    assert advisor_blocked_payload[RESULT_KEY_DRAFT_PRESERVED] is True
+    assert clean_payload[RESULT_KEY_DRAFT_PRESERVED] is False
+
+
+def test_fourth_and_later_heads_are_recorded() -> None:
+    all_heads = (HEAD_SHA_ONE, HEAD_SHA_TWO, HEAD_SHA_THREE)
+    after_fourth = record_reviewed_head(all_heads, HEAD_SHA_FOUR)
+
+    assert after_fourth == (
+        HEAD_SHA_ONE,
+        HEAD_SHA_TWO,
+        HEAD_SHA_THREE,
+        HEAD_SHA_FOUR,
+    )
+    assert len(after_fourth) == 4
+
+
+def test_mixed_severities_are_not_nits_only() -> None:
+    all_findings = (
+        _retained_finding(severity=SEVERITY_NIT),
+        _retained_finding(severity=SEVERITY_BLOCKER),
+    )
+
+    assert is_nits_only_findings(all_findings) is False
+    assert is_nits_only_findings(()) is False

package/scripts/test_resolve_worker_spawn.py

@@ -23,6 +23,10 @@ from claude_chain_runner import (  # noqa: E402
     ChainConfigurationError,
     ChainInvocationOutcome,
 )
+from dev_env_scripts_constants.claude_chain_constants import (  # noqa: E402
+    TERMINAL_STATUS_CHAIN_EXHAUSTED,
+    TERMINAL_STATUS_SERVED,
+)
 from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     AGENT_FLAG,
     ALL_AGENT_FILENAMES_BY_ROLE,
@@ -133,6 +137,7 @@ def _claude_served(
         stdout=stdout,
         stderr="",
         attempts=(ChainAttempt(command="claude", status="served"),),
+        terminal_status=TERMINAL_STATUS_SERVED,
     )
 
 
@@ -143,6 +148,7 @@ def _claude_exhausted() -> ChainInvocationOutcome:
         stdout="",
         stderr="usage limit reached",
         attempts=(ChainAttempt(command="claude", status="usage_limited"),),
+        terminal_status=TERMINAL_STATUS_CHAIN_EXHAUSTED,
     )