claude-dev-env 2.9.0 → 2.11.0

package/skills/e-code-review/scripts/test_effort_evaluation.py

@@ -0,0 +1,180 @@
+"""Behavior tests for the effort evaluation harness."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+_CONSTANTS_PARENT = _SCRIPTS_DIRECTORY / "config"
+for each_path in (_SCRIPTS_DIRECTORY, _CONSTANTS_PARENT):
+    path_text = str(each_path)
+    if path_text not in sys.path:
+        sys.path.insert(0, path_text)
+
+from e_code_review_effort_constants import (  # noqa: E402
+    ALL_EFFORT_LEVELS,
+    ALL_FIXTURE_BANDS,
+    ALL_SKILL_EFFORT_LEVELS,
+    MINIMUM_QUALITY_HOLD_SCORE,
+    THINKING_ENABLED_DEFAULT,
+    WORKFLOW_FAMILY_E_CODE_REVIEW,
+)
+from effort_evaluation import (  # noqa: E402
+    build_synthetic_row,
+    evaluation_evidence_path,
+    fixtures_directory,
+    load_evaluation_evidence,
+    load_fixtures,
+    map_evaluation_effort_to_skill_level,
+    quality_holds,
+    recommend_effort_by_band,
+    resolve_skill_effort_for_band,
+    skill_defaults_from_recommendation,
+    validate_evaluation_row,
+)
+
+
+def test_fixtures_directory_points_at_frozen_json() -> None:
+    directory = fixtures_directory()
+    assert directory.is_dir()
+    assert directory.name == "fixtures"
+    assert (directory / "easy.json").is_file()
+
+
+def test_loads_three_frozen_fixture_bands() -> None:
+    all_fixtures = load_fixtures()
+    assert len(all_fixtures) == len(ALL_FIXTURE_BANDS)
+    bands = {str(each_fixture["band"]) for each_fixture in all_fixtures}
+    assert bands == set(ALL_FIXTURE_BANDS)
+    for each_fixture in all_fixtures:
+        assert each_fixture["fixture_id"]
+        assert isinstance(each_fixture["seeded_findings"], list)
+        assert len(each_fixture["seeded_findings"]) >= 1
+
+
+def test_validate_row_accepts_complete_row_and_rejects_thinking_off() -> None:
+    good_row = build_synthetic_row(
+        fixture_id="easy-comment-preservation",
+        fixture_band="easy",
+        effort="low",
+        quality_score=0.9,
+        finding_recall=1.0,
+        finding_precision=1.0,
+        visible_tokens=1200,
+        latency_ms=4000,
+    )
+    assert validate_evaluation_row(good_row) == []
+    assert good_row["thinking_enabled"] is THINKING_ENABLED_DEFAULT
+    bad_row = dict(good_row)
+    bad_row["thinking_enabled"] = False
+    problems = validate_evaluation_row(bad_row)
+    assert any("thinking_enabled" in each_problem for each_problem in problems)
+    bool_score_row = dict(good_row)
+    bool_score_row["quality_score"] = True
+    bool_problems = validate_evaluation_row(bool_score_row)
+    assert any("quality_score" in each_problem for each_problem in bool_problems)
+
+
+def test_recommend_picks_lowest_effort_that_holds_quality() -> None:
+    all_rows = [
+        build_synthetic_row("easy-a", "easy", "low", 0.5, 0.5, 0.5, 100, 1000),
+        build_synthetic_row("easy-a", "easy", "medium", 0.95, 0.95, 0.95, 200, 2000),
+        build_synthetic_row("easy-a", "easy", "xhigh", 0.99, 0.99, 0.99, 400, 5000),
+        build_synthetic_row("medium-a", "medium", "high", 0.9, 0.9, 0.9, 300, 3000),
+        build_synthetic_row(
+            "demanding-a", "demanding", "max", 0.85, 0.85, 0.85, 800, 9000
+        ),
+    ]
+    for each_row in all_rows:
+        assert validate_evaluation_row(each_row) == []
+    recommendation = recommend_effort_by_band(all_rows)
+    by_band = recommendation["recommendation_by_band"]
+    assert isinstance(by_band, dict)
+    assert by_band["easy"]["recommended_effort"] == "medium"
+    assert by_band["easy"]["cited_row"]["effort"] == "medium"
+    assert by_band["medium"]["recommended_effort"] == "high"
+    assert by_band["demanding"]["recommended_effort"] == "max"
+    assert recommendation["thinking_enabled"] is True
+    assert recommendation["cost_latency_lever"] == "effort"
+    assert recommendation["defaults_unchanged"] is True
+
+
+def test_recommend_blocks_band_without_holding_row() -> None:
+    all_rows = [
+        build_synthetic_row("easy-a", "easy", "low", 0.1, 0.1, 0.1, 50, 500),
+    ]
+    recommendation = recommend_effort_by_band(all_rows)
+    easy = recommendation["recommendation_by_band"]["easy"]
+    assert easy["recommended_effort"] is None
+    assert easy["cited_row"] is None
+    assert "quality floor" in str(easy["blocker"])
+
+
+def test_quality_holds_uses_named_floor() -> None:
+    holding = build_synthetic_row(
+        "x", "easy", "low", MINIMUM_QUALITY_HOLD_SCORE, 1.0, 1.0, 1, 1
+    )
+    failing = build_synthetic_row(
+        "x", "easy", "low", MINIMUM_QUALITY_HOLD_SCORE - 0.01, 1.0, 1.0, 1, 1
+    )
+    assert quality_holds(holding) is True
+    assert quality_holds(failing) is False
+
+
+def test_effort_levels_cover_cli_set() -> None:
+    assert "low" in ALL_EFFORT_LEVELS
+    assert "max" in ALL_EFFORT_LEVELS
+    assert len(ALL_EFFORT_LEVELS) == 5
+
+
+def test_evidence_rows_validate_and_skill_defaults_cite_rows() -> None:
+    evidence_path = evaluation_evidence_path()
+    assert evidence_path.is_file()
+    assert evidence_path.name == "effort_defaults_evidence.json"
+    evidence = load_evaluation_evidence()
+    assert evidence["workflow_family"] == WORKFLOW_FAMILY_E_CODE_REVIEW
+    assert evidence["thinking_enabled"] is True
+    all_rows = evidence["all_rows"]
+    assert isinstance(all_rows, list)
+    for each_row in all_rows:
+        assert isinstance(each_row, dict)
+        assert validate_evaluation_row(each_row) == []
+    recommendation = recommend_effort_by_band(all_rows)
+    skill_defaults = skill_defaults_from_recommendation(recommendation)
+    assert skill_defaults["workflow_family"] == WORKFLOW_FAMILY_E_CODE_REVIEW
+    default_by_band = skill_defaults["default_by_band"]
+    assert isinstance(default_by_band, dict)
+    for each_band in ALL_FIXTURE_BANDS:
+        band_default = default_by_band[each_band]
+        assert band_default["skill_effort"] in ALL_SKILL_EFFORT_LEVELS
+        assert band_default["cited_row"] is not None
+        assert band_default["cited_row"]["thinking_enabled"] is True
+
+
+def test_committed_skill_defaults_match_resolver() -> None:
+    assert resolve_skill_effort_for_band("easy") == "medium"
+    assert resolve_skill_effort_for_band("medium") == "xhigh"
+    assert resolve_skill_effort_for_band("demanding") == "xhigh"
+    evidence = load_evaluation_evidence()
+    committed = evidence["skill_defaults"]["default_by_band"]
+    for each_band in ALL_FIXTURE_BANDS:
+        assert committed[each_band]["skill_effort"] == resolve_skill_effort_for_band(
+            each_band
+        )
+        assert committed[each_band]["cited_row"]["effort"] is not None
+
+
+def test_map_high_and_max_to_skill_xhigh() -> None:
+    assert map_evaluation_effort_to_skill_level("high") == "xhigh"
+    assert map_evaluation_effort_to_skill_level("max") == "xhigh"
+    assert map_evaluation_effort_to_skill_level("medium") == "medium"
+
+
+def test_resolve_rejects_unknown_band() -> None:
+    try:
+        resolve_skill_effort_for_band("not-a-band")
+    except ValueError as error:
+        assert "unknown fixture band" in str(error)
+    else:
+        raise AssertionError("expected ValueError for unknown band")

package/skills/e-code-review/scripts/test_finding_pipeline.py

@@ -0,0 +1,197 @@
+"""Red fixtures: low-severity findings survive collection; filter is separate."""
+
+from __future__ import annotations
+
+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 e_code_review_scripts_constants.finding_pipeline_constants import (
+    ALL_COLLECTION_SEVERITIES,
+    COLLECTION_STAGE_NAME,
+    FILTER_STAGE_NAME,
+    FINDING_FIELD_CATEGORY,
+    FINDING_FIELD_EVIDENCE,
+    FINDING_FIELD_FILE,
+    FINDING_FIELD_LINE,
+    FINDING_FIELD_SEVERITY,
+    REPORT_EVERY_FINDING_INSTRUCTION,
+    SEVERITY_BLOCKER,
+    SEVERITY_HIGH,
+    SEVERITY_LOW,
+    SEVERITY_MEDIUM,
+    SEVERITY_NIT,
+)
+from finding_pipeline import (
+    CollectedFinding,
+    FindingCollection,
+    collect_findings,
+    filter_findings_by_severity,
+)
+
+
+def _seeded_findings() -> list[CollectedFinding]:
+    return [
+        CollectedFinding(
+            file_path="pkg/a.py",
+            line_number=10,
+            severity=SEVERITY_BLOCKER,
+            category="correctness",
+            evidence="raises on empty input",
+        ),
+        CollectedFinding(
+            file_path="pkg/b.py",
+            line_number=20,
+            severity=SEVERITY_HIGH,
+            category="security",
+            evidence="shell=True with user text",
+        ),
+        CollectedFinding(
+            file_path="pkg/c.py",
+            line_number=30,
+            severity=SEVERITY_MEDIUM,
+            category="api-contracts",
+            evidence="return type narrowed",
+        ),
+        CollectedFinding(
+            file_path="pkg/d.py",
+            line_number=40,
+            severity=SEVERITY_LOW,
+            category="simplification",
+            evidence="duplicated helper body",
+        ),
+        CollectedFinding(
+            file_path="pkg/e.py",
+            line_number=50,
+            severity=SEVERITY_NIT,
+            category="conventions",
+            evidence="typo in comment",
+        ),
+    ]
+
+
+def test_collection_retains_every_seeded_severity_including_low_and_nit() -> None:
+    all_seeded = _seeded_findings()
+    collection = collect_findings(all_seeded)
+
+    assert collection.stage_name == COLLECTION_STAGE_NAME
+    all_severities = {
+        each.severity for each in collection.all_findings
+    }
+    assert all_severities == set(ALL_COLLECTION_SEVERITIES)
+    assert len(collection.all_findings) == len(all_seeded)
+    low_finding = next(
+        each for each in collection.all_findings if each.severity == SEVERITY_LOW
+    )
+    assert low_finding.file_path == "pkg/d.py"
+    assert low_finding.line_number == 40
+    assert low_finding.evidence == "duplicated helper body"
+    assert low_finding.category == "simplification"
+
+
+def test_each_collected_finding_keeps_file_line_evidence_and_category() -> None:
+    collection = collect_findings(_seeded_findings())
+    for each_finding in collection.all_findings:
+        as_mapping = each_finding.as_mapping()
+        assert as_mapping[FINDING_FIELD_FILE]
+        assert as_mapping[FINDING_FIELD_LINE] > 0
+        assert as_mapping[FINDING_FIELD_EVIDENCE]
+        assert as_mapping[FINDING_FIELD_CATEGORY]
+        assert as_mapping[FINDING_FIELD_SEVERITY] in ALL_COLLECTION_SEVERITIES
+
+
+def test_filter_is_explicit_later_stage_and_does_not_mutate_collection() -> None:
+    collection = collect_findings(_seeded_findings())
+    collected_snapshot = [
+        (
+            each.file_path,
+            each.line_number,
+            each.severity,
+            each.category,
+            each.evidence,
+        )
+        for each in collection.all_findings
+    ]
+
+    filtered = filter_findings_by_severity(
+        collection,
+        minimum_severity=SEVERITY_MEDIUM,
+    )
+
+    assert filtered.stage_name == FILTER_STAGE_NAME
+    all_filtered_severities = {each.severity for each in filtered.all_findings}
+    assert SEVERITY_LOW not in all_filtered_severities
+    assert SEVERITY_NIT not in all_filtered_severities
+    assert SEVERITY_MEDIUM in all_filtered_severities
+    assert SEVERITY_BLOCKER in all_filtered_severities
+
+    after_filter_snapshot = [
+        (
+            each.file_path,
+            each.line_number,
+            each.severity,
+            each.category,
+            each.evidence,
+        )
+        for each in collection.all_findings
+    ]
+    assert after_filter_snapshot == collected_snapshot
+    assert len(collection.all_findings) == 5
+
+
+def test_filter_rejects_unknown_minimum_severity() -> None:
+    collection = collect_findings(_seeded_findings())
+    with pytest.raises(ValueError, match="unknown minimum severity"):
+        filter_findings_by_severity(collection, minimum_severity="P1")
+
+
+def test_filter_rejects_unknown_finding_severity_with_value_error() -> None:
+    collection = FindingCollection(
+        stage_name=COLLECTION_STAGE_NAME,
+        all_findings=(
+            CollectedFinding(
+                file_path="pkg/x.py",
+                line_number=1,
+                severity="P0",
+                category="correctness",
+                evidence="bypass collect",
+            ),
+        ),
+    )
+    with pytest.raises(ValueError, match="unknown collection severity"):
+        filter_findings_by_severity(collection, minimum_severity=SEVERITY_LOW)
+
+
+def test_collect_rejects_finding_missing_required_fields() -> None:
+    with pytest.raises(ValueError, match="file"):
+        collect_findings(
+            [
+                CollectedFinding(
+                    file_path="",
+                    line_number=1,
+                    severity=SEVERITY_LOW,
+                    category="correctness",
+                    evidence="x",
+                )
+            ]
+        )
+
+
+def test_report_every_finding_instruction_names_all_severities() -> None:
+    for each_severity in ALL_COLLECTION_SEVERITIES:
+        assert each_severity in REPORT_EVERY_FINDING_INSTRUCTION
+    assert "consumer stage" in REPORT_EVERY_FINDING_INSTRUCTION
+    assert "Do not drop findings by severity during collection" in (
+        REPORT_EVERY_FINDING_INSTRUCTION
+    )
+
+
+def test_collection_record_type_is_immutable() -> None:
+    collection = collect_findings(_seeded_findings())
+    assert isinstance(collection, FindingCollection)
+    assert collection.stage_name == COLLECTION_STAGE_NAME

package/skills/e-code-review/scripts/test_grok_code_review.py

@@ -134,6 +134,83 @@ def test_run_medium_review_happy_path() -> None:
     assert len(batch.all_retained_findings) == MEDIUM_REVIEW_FINDER_COUNT - 1
 
 
+def _one_candidate_per_angle(head: str) -> list[FinderCandidate]:
+    return [
+        FinderCandidate(
+            angle=each_angle,
+            file_path=f"{each_angle}.py",
+            line_number=1,
+            mechanism="m",
+            scenario=f"scenario {each_angle}",
+            worktree_path=f"/wt/{each_angle}",
+            leader_socket=f"sock-{each_angle}",
+            advisor_session_id=f"adv-{each_angle}",
+            reviewed_head=head,
+        )
+        for each_angle in ALL_MEDIUM_FINDER_ANGLES
+    ]
+
+
+def test_a_finder_reporting_several_candidates_is_not_a_identity_clash() -> None:
+    head = "abc123"
+    all_finders = _one_candidate_per_angle(head)
+    first = all_finders[0]
+    second_from_first_finder = FinderCandidate(
+        angle=first.angle,
+        file_path="second.py",
+        line_number=9,
+        mechanism="m",
+        scenario="a second finding from the same finder",
+        worktree_path=first.worktree_path,
+        leader_socket=first.leader_socket,
+        advisor_session_id=first.advisor_session_id,
+        reviewed_head=head,
+    )
+    all_finders.append(second_from_first_finder)
+    all_keys = [
+        (each.file_path, each.line_number, each.mechanism) for each in all_finders
+    ]
+    batch = run_medium_review(
+        target_head=head,
+        diff_base="base",
+        all_finder_candidates=all_finders,
+        verdict_by_key={each_key: VERDICT_CONFIRMED for each_key in all_keys},
+        severity_by_key={each_key: "medium" for each_key in all_keys},
+        live_head=head,
+    )
+    assert batch.is_rejected is False
+    assert batch.rejection_reason is None
+    assert len(batch.all_retained_findings) == len(all_finders)
+
+
+def test_two_finders_sharing_one_socket_reject_the_batch() -> None:
+    head = "abc123"
+    all_finders = _one_candidate_per_angle(head)
+    first = all_finders[0]
+    second = all_finders[1]
+    all_finders[1] = FinderCandidate(
+        angle=second.angle,
+        file_path=second.file_path,
+        line_number=second.line_number,
+        mechanism=second.mechanism,
+        scenario=second.scenario,
+        worktree_path=second.worktree_path,
+        leader_socket=first.leader_socket,
+        advisor_session_id=second.advisor_session_id,
+        reviewed_head=head,
+    )
+    batch = run_medium_review(
+        target_head=head,
+        diff_base="base",
+        all_finder_candidates=all_finders,
+        verdict_by_key={},
+        severity_by_key={},
+        live_head=head,
+    )
+    assert batch.is_rejected is True
+    assert batch.rejection_reason == "non_unique_finder_identity"
+
+
 def test_head_drift_rejects_batch() -> None:
     head = "h1"
     all_finders = [

package/skills/grokify/SKILL.md

@@ -43,7 +43,7 @@ The user types `/grokify`, alone or with guidance.
 
 - **Bind once, first:** charter + findings + constraints + plan piped from a temp file into `claude -p --model fable --effort high --output-format json`; parse and save `session_id` from the JSON reply.
 - **Consult:** brief piped into `claude -p --resume <session_id> --model fable --effort high --output-format json`.
-- **ConsultB** If fable is unavailable, use opus with max effort: `claude -p --resume <session_id> --model opus --effort max --output-format json`.
+- **ConsultB** If fable is unavailable, use opus with xhigh effort: `claude -p --resume <session_id> --model opus --effort xhigh --output-format json`.
 - **Signals:** every advisor reply opens with exactly one of ENDORSE, CORRECTION, PLAN, or STOP. CORRECTION and PLAN are actions to take, with a report-back in the next consult on that topic. STOP halts that line of work and surfaces it to the user. When the CLI is unreachable, Grok stops and says so — it never self-endorses in the advisor's place.
 - **Cadence, mandatory:** after planning and before any edit; per phase before implementation (TDD red + approach) and after (diff, tests, acceptance evidence); before every `git commit` and `git push`; on every user-facing fork before asking; on any twice-repeated failure or stall.
 

package/skills/grokify/templates/handoff-template.md

@@ -43,7 +43,7 @@ CONFIRM THESE WITH THE USER FIRST, VIA ASKUSERQUESTION, BEFORE EMBEDDING]
    append the full Established findings, Hard constraints, and Plan sections of this
    document to the same file.
 2. Bind: `claude -p --model fable --effort high --output-format json < <charter-file>`
-2a. If 2 fails, replace fable with opus, effort high to max.
+2a. If 2 fails, replace fable with opus, effort high to xhigh.
 3. The JSON output is an array of events, not one object. Take `session_id` from any
    event; the reply text is the `type == "result"` event's `.result` field. Persist
    `session_id`, the repo root, and the cwd to a state file at once.
@@ -56,7 +56,7 @@ CONFIRM THESE WITH THE USER FIRST, VIA ASKUSERQUESTION, BEFORE EMBEDDING]
    session, not a model failure.
 
 **Consult (every time):** write the brief to a temp file, then
-`claude -p --resume <session_id> --model fable (or opus) --effort high (max for opus) --output-format json < <brief-file>`.
+`claude -p --resume <session_id> --model fable (or opus) --effort high (xhigh for opus) --output-format json < <brief-file>`.
 Act on the reply's opening signal: ENDORSE — proceed. CORRECTION — apply it first;
 your next consult on that topic opens with what happened. PLAN — adopt it; same
 report-back rule. STOP — halt that line of work and surface it to the user. Never

package/skills/orchestrator/SKILL.md

@@ -193,7 +193,7 @@ Touch only: <files or globs>
 Done when: <one mechanical check — a command, a test, a diff scope>
 Return: status, artifact paths, blockers — nothing else.
 
-<host-matched Advisor block from advisor-protocol.md, advisor name filled in>
+<Advisor block assembled per _shared/advisor/reference/advisor-block.md — advisor name filled in>
 ```
 
 - **Size the task by its done-check.** The right task is the largest
@@ -218,9 +218,10 @@ Return: status, artifact paths, blockers — nothing else.
   table picks the definition, and `clean-coder` already holds the code
   discipline. The ticket adds the task, the pointers, and the Advisor
   block only.
-- **The Advisor block is the one pasted paragraph.** It is host-matched
-  at bind time and written to be self-contained (the protocol's Advisor
-  block section) — paste it; do not point at it.
+- **The Advisor block is pasted, assembled text.** Assemble it at bind
+  time from the parts in
+  [`_shared/advisor/reference/advisor-block.md`](../../_shared/advisor/reference/advisor-block.md)
+  and paste the assembled text itself into the ticket.
 
 ## Workflow Agent Routing
 

package/skills/plan-to-pr/scripts/create_packet.py

@@ -8,10 +8,10 @@ import subprocess
 import sys
 from pathlib import Path
 
-if str(Path(__file__).parent) not in sys.path:
-    sys.path.insert(0, str(Path(__file__).parent))
-
-from config.constants import (
+_scripts_directory = str(Path(__file__).resolve().parent)
+if _scripts_directory not in sys.path:
+    sys.path.insert(0, _scripts_directory)
+from load_skill_constants import (
     PACKET_CREATION_ERROR_EXIT_CODE,
     PACKET_JSON_INDENT_LEVEL,
     SLUG_PATTERN,

package/skills/plan-to-pr/scripts/load_skill_constants.py

@@ -0,0 +1,41 @@
+"""Load plan-to-pr skill constants without colliding with repo-root config.
+
+Repo pytest sets ``pythonpath = .``, so a bare ``from config.constants import …``
+can bind the monorepo root ``config`` package instead of this skill's
+``scripts/config/constants.py``. Load the skill file under a unique module name
+and re-export its public names for script imports.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_skill_constants_module() -> ModuleType:
+    """Return the skill-local constants module, loading it once per process."""
+    skill_constants_module_name = "plan_to_pr_scripts_config_constants"
+    skill_constants_path = Path(__file__).resolve().parent / "config" / "constants.py"
+    existing_module = sys.modules.get(skill_constants_module_name)
+    if existing_module is not None:
+        return existing_module
+    module_spec = importlib.util.spec_from_file_location(
+        skill_constants_module_name, skill_constants_path
+    )
+    if module_spec is None or module_spec.loader is None:
+        raise ImportError(
+            f"unable to load plan-to-pr skill constants from {skill_constants_path}"
+        )
+    loaded_module = importlib.util.module_from_spec(module_spec)
+    sys.modules[skill_constants_module_name] = loaded_module
+    module_spec.loader.exec_module(loaded_module)
+    return loaded_module
+
+
+_skill_constants = _load_skill_constants_module()
+for each_constant_name, each_constant_binding in _skill_constants.__dict__.items():
+    if each_constant_name.startswith("_"):
+        continue
+    globals()[each_constant_name] = each_constant_binding

package/skills/plan-to-pr/scripts/validate_packet.py

@@ -9,10 +9,10 @@ import shlex
 import sys
 from pathlib import Path
 
-if str(Path(__file__).parent) not in sys.path:
-    sys.path.insert(0, str(Path(__file__).parent))
-
-from config.constants import (
+_scripts_directory = str(Path(__file__).resolve().parent)
+if _scripts_directory not in sys.path:
+    sys.path.insert(0, _scripts_directory)
+from load_skill_constants import (
     COMMAND_SEPARATOR,
     HANDOFF_ACCEPTANCE_PREFIX,
     HANDOFF_ALLOWED_FILES_PREFIX,

package/skills/plan-to-pr/scripts/validate_protocol.py

@@ -10,7 +10,10 @@ import sys
 from collections.abc import Mapping, Sequence
 from pathlib import Path
 
-from config.constants import (
+_scripts_directory = str(Path(__file__).resolve().parent)
+if _scripts_directory not in sys.path:
+    sys.path.insert(0, _scripts_directory)
+from load_skill_constants import (
     ALL_ALLOWED_RECORD_FIELDS,
     ALL_RECORD_FIELDS,
     ALL_REPAIR_FIELDS,

package/skills/plan-to-pr/scripts/validate_run.py

@@ -8,7 +8,10 @@ import sys
 from collections.abc import Mapping, Sequence
 from pathlib import Path
 
-from config.constants import (
+_scripts_directory = str(Path(__file__).resolve().parent)
+if _scripts_directory not in sys.path:
+    sys.path.insert(0, _scripts_directory)
+from load_skill_constants import (
     COMMIT_RANGE_ARGUMENT_INDEX,
     COMMIT_RANGE_SEPARATOR,
     EXIT_CODE_INVALID_SET,