vera_bench/baseline_runner.py (2)

1-1: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Update the module docstring to reflect all supported baseline languages.

The docstring currently mentions only Python and TypeScript, but the module now supports Python, TypeScript, Aver, and AILANG.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/baseline_runner.py` at line 1, Update the module-level docstring
at the top of the file (the triple-quoted string that currently reads "Execute
Python and TypeScript baseline solutions against test cases.") to list all
supported baseline languages — Python, TypeScript, Aver, and AILANG — so it
accurately reflects current functionality; keep the docstring concise and
descriptive of what the module does and the languages it supports.

---

779-785: ⚠️ Potential issue | 🔴 Critical | ⚡ Quick win

Critical: AILANG should validate all problems, not skip those without test cases.

The current logic excludes AILANG from the special case that runs all problems (including those without test cases). However, run_ailang_baseline has an explicit check-only path (lines 593–647) for problems without test cases, and the documentation claims 24 problems with empty test cases pass check@1.

With the current code, those 24 problems will be skipped entirely, contradicting the documented 100% check@1 rate across all 60 problems.

🐛 Proposed fix to include AILANG in the validate-all-problems path

-    # Aver validates all problems (check even without test_cases)
-    if language == "aver":
+    # Aver and AILANG validate all problems (check even without test_cases)
+    if language in ("aver", "ailang"):
         run_problems = problems
     else:
         run_problems = [p for p in problems if p.get("test_cases")]
         skipped = len(problems) - len(run_problems)
         if skipped:
             console.print(f"[dim]Skipping {skipped} problems with no test cases[/dim]")

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/baseline_runner.py` around lines 779 - 785, The current branch
only preserves all problems when language == "aver", causing AILANG to skip
problems without test cases; update the conditional that sets run_problems so
AILANG is treated the same as AVER (e.g., check language == "aver" or language
== "ailang", or use language in ("aver","ailang")) so run_problems = problems
for AILANG; this is safe because run_ailang_baseline implements an explicit
check-only path for problems without test cases, so include run_ailang_baseline,
run_problems, and the language variable when locating where to change the logic.

solutions/ailang/VB_T3_008_tree_count_leaves.ail (1)

12-12: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_008_tree_count_leaves.ail` at line 12, Add a
POSIX-compliant trailing newline at the end of the file
solutions/ailang/VB_T3_008_tree_count_leaves.ail by editing the file and
inserting a single newline character as the final byte so the file ends with a
newline (ensure no other content changes).

solutions/ailang/VB_T3_006_option_unwrap_or.ail (1)

12-12: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_006_option_unwrap_or.ail` at line 12, The file
solutions/ailang/VB_T3_006_option_unwrap_or.ail is missing a trailing newline;
open VB_T3_006_option_unwrap_or.ail and add a single newline character at the
end of the file (ensure the file ends with '\n') to satisfy POSIX text file
conventions.

solutions/ailang/VB_T3_005_tree_sum.ail (1)

12-12: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_005_tree_sum.ail` at line 12, The file
solutions/ailang/VB_T3_005_tree_sum.ail is missing a trailing newline; open that
file and add a single newline character at the end of the file (ensure the file
ends with '\n') so it conforms to POSIX text file conventions.

solutions/ailang/VB_T3_003_expression_evaluator.ail (1)

13-13: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_003_expression_evaluator.ail` at line 13, Add a single
trailing newline character at the end of the file
VB_T3_003_expression_evaluator.ail (i.e., ensure the file ends with a
newline/EOF marker); update the file save so the final line is terminated to
satisfy POSIX text file conventions.

solutions/ailang/VB_T3_001_list_length.ail (1)

12-12: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end. Whilst not critical for functionality, it's good practice for text files.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_001_list_length.ail` at line 12, The file
VB_T3_001_list_length.ail is missing a trailing newline at EOF; open that file
and add a single POSIX newline character (LF) as the final character so the file
ends with a blank line, then save to ensure the file adheres to POSIX text file
convention.

solutions/ailang/VB_T3_002_tree_depth.ail (1)

14-14: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_002_tree_depth.ail` at line 14, Add a POSIX-compliant
trailing newline to the end of the file
solutions/ailang/VB_T3_002_tree_depth.ail by ensuring the file ends with a
single '\n' character (i.e., place the cursor at the end of the last line and
insert a newline) so the file now terminates with a newline character.

solutions/ailang/VB_T3_007_list_contains.ail (1)

12-12: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_007_list_contains.ail` at line 12, The file
VB_T3_007_list_contains.ail is missing a trailing newline at EOF; fix by editing
VB_T3_007_list_contains.ail and ensure the file ends with a single newline
character (POSIX convention) so the last line is terminated.

solutions/ailang/VB_T3_004_list_sum.ail (1)

12-12: 🧹 Nitpick | 🔵 Trivial | 💤 Low value

Missing trailing newline at end of file.

POSIX text file convention requires a newline at the end.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@solutions/ailang/VB_T3_004_list_sum.ail` at line 12, The file
VB_T3_004_list_sum.ail is missing a trailing newline; open the file and add a
single newline character at the end of the file (ensure the final line ends with
'\n') so it conforms to POSIX text file conventions and tools that expect an EOF
newline.

vera_bench/cli.py (1)

98-103: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Incorrect warning: --skill-md is not ignored for AILANG.

For language == "ailang", the code does use skill_md via load_ailang_prompt(skill_md), so the warning emitted from Line 98 is inaccurate.

Suggested fix

-    if language not in ("vera", "aver"):
+    if language not in ("vera", "aver", "ailang"):
         if skill_md is not None:
             console.print(
                 f"[yellow]Warning: --skill-md is ignored "
                 f"with --language {language}[/yellow]"
             )

Also applies to: 155-163

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/cli.py` around lines 98 - 103, The warning incorrectly treats
--skill-md as ignored for "ailang"; update the conditional(s) so the warning
only fires when language is not one of the supported languages that use skill_md
(include "ailang" alongside "vera" and "aver"). Specifically, change the check
that currently reads if language not in ("vera", "aver") to include "ailang"
(e.g., if language not in ("vera", "aver", "ailang")), and apply the same fix to
the second occurrence handling lines 155-163 so console.print only warns for
truly unsupported languages; references: the language variable, skill_md,
console.print, and load_ailang_prompt.

vera_bench/runner.py (2)

771-779: 🧹 Nitpick | 🔵 Trivial | ⚡ Quick win

Per-test-case failures are swallowed silently.

When ailang run times out (line 771-772) or exits non-zero (line 774-775), the test simply does not increment tests_passed, but nothing is recorded in result["error_message"]. For a problem that fails one test out of many, the JSONL row carries no diagnostic. Consider capturing the first failure's stderr/stdout (truncated) into error_message to make per-problem debugging tractable — analogous to what _evaluate_python_code and _evaluate_typescript_code do on non-zero exits.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/runner.py` around lines 771 - 779, The loop currently swallows
per-test failures; update the handling around the subprocess.TimeoutExpired
branch and the non-zero exit branch (where run_proc is used and
_aver_output_matches is called) to record the first failing test's diagnostics
into result["error_message"] (truncate long output), including stderr and/or
stdout as available, so that timeouts and non-zero exits are logged; model the
behavior used in _evaluate_python_code and _evaluate_typescript_code to build
the error message and ensure you only set result["error_message"] once (for the
first failure) while continuing to count tests_passed correctly when matches
occur.

---

596-617: 🛠️ Refactor suggestion | 🟠 Major | ⚡ Quick win

Missing parameter type hint on _ailang_literal.

value lacks an annotation. As per coding guidelines (vera_bench/**/*.py: Python 3.11+, use type hints everywhere), helpers in this package should be fully annotated. The same applies to _aver_literal at line 878 but that one predates this PR.

📝 Suggested fix

-def _ailang_literal(value) -> str:
+def _ailang_literal(value: object) -> str:
     """Convert a Python value to an AILANG literal expression."""

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/runner.py` around lines 596 - 617, The helper function
_ailang_literal has an un-annotated parameter `value`; add an explicit type hint
(use typing.Any) to the `value` parameter and ensure the function signature
stays `def _ailang_literal(value: Any) -> str:` (import Any from typing if not
already). Also apply the same fix to the related helper `_aver_literal` so both
helpers follow the project's type-hinting guideline.

AILANG_RESULTS.md (1)

74-74: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Reproduction version pin disagrees with the PR objectives.

PR objectives state reproduction requires AILANG v0.21.0 (the release that ships std/bytes.byteAt), but the doc instructs readers to check for >= v0.20.1. A reader on v0.20.1 will hit the VB_T2_013_get_char_code failure described later. Pin the version check to v0.21.0, or update the PR objectives to match the doc — whichever is canonical.

📝 Suggested fix

-ailang --version  # should be >= v0.20.1 (post-2026-05-21 commit)
+ailang --version  # should be >= v0.21.0 (includes std/bytes.byteAt)

Also applies to: 5-5

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@AILANG_RESULTS.md` at line 74, The reproduction version check in
AILANG_RESULTS.md currently instructs readers to run "ailang --version" and
expects ">= v0.20.1", which conflicts with the PR objective that requires AILANG
v0.21.0 (the release that ships std/bytes.byteAt) and causes the
VB_T2_013_get_char_code failure; update the version check text to require ">=
v0.21.0" (or alternatively, adjust the PR objectives to state v0.20.1) so the
document and PR objectives match, and ensure references to std/bytes.byteAt and
VB_T2_013_get_char_code remain consistent.

vera_bench/runner.py (2)

596-617: 🛠️ Refactor suggestion | 🟠 Major | ⚡ Quick win

Type the new AILANG literal helper's input.

value is the only unannotated parameter in this helper, so the new AILANG path still falls short of the repo's typing rule. object is enough if you want to keep the accepted shapes broad. As per coding guidelines, **/*.py: Python 3.11+, use type hints everywhere.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/runner.py` around lines 596 - 617, The function _ailang_literal
has an untyped parameter `value`; add a type hint to satisfy repo typing rules
by annotating it as `value: object` (and keep the return type `-> str`) so
accepted shapes remain broad; update the function signature
`_ailang_literal(value)` to `_ailang_literal(value: object) -> str` and run type
checks.

---

743-748: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Inject import std/io (println) into the test harness AILANG module.

The per-test main() unconditionally calls println(...), but the harness never injects import std/io (println). The prompt correctly instructs LLM to return function-only code (no main), yet when the harness concatenates the LLM output with its injected test main, the resulting module calls undefined println. This causes ailang run to fail even when the entry point itself is correct.

Inject the import conditionally, mirroring the existing module-declaration logic:

Suggested fix

     if not has_module:
         code_without_main = f"module benchmark/solution\n\n{code_without_main}"
+    if "import std/io (println)" not in code_without_main:
+        lines = code_without_main.splitlines()
+        insert_at = 1 if lines and lines[0].strip().startswith("module ") else 0
+        lines[insert_at:insert_at] = ["", "import std/io (println)"]
+        code_without_main = "\n".join(lines)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/runner.py` around lines 743 - 748, The test harness builds
test_main and test_file by concatenating test_main (which calls println) with
code_without_main, but it never injects the required import, causing undefined
println at runtime; update the logic that creates test_file (and/or test_main)
to conditionally prepend or insert "import std/io (println)" into the module
using the same module-declaration detection used elsewhere (e.g., use the
existing module-declaration branching that inspects code_without_main) so that
when a module header exists the import is placed after it, otherwise added at
the top; keep references to test_main, test_file, code_without_main, entry_point
and args_str when implementing the insertion.

vera_bench/cli.py (3)

90-101: 🛠️ Refactor suggestion | 🟠 Major | ⚡ Quick win

Add an explicit -> None to the run command handler.

This changed callback still has no return annotation, which misses the repo's typing rule for Python files. As per coding guidelines, **/*.py: Python 3.11+, use type hints everywhere.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/cli.py` around lines 90 - 101, The run command handler lacks an
explicit return type; update the function signature for run (the CLI handler) to
add a return annotation of -> None so it conforms to the project's typing rule
for Python files; ensure the signature for the existing function def run(model:
str, tier: int | None, problem: str | None, language: str, mode: str, skill_md:
Path | None, output_dir: Path | None, max_tokens: int, keep_temps: bool,
parallel: int) is changed to include -> None and run any static type checks to
confirm no other annotations are missing.

---

167-175: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Don't claim --skill-md is ignored for AILANG.

This branch passes skill_md into load_ailang_prompt() and reports it as the selected source, so the earlier warning becomes false for --language ailang. Please exclude AILANG from that "ignored" path or split the warning logic by language.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/cli.py` around lines 167 - 175, The warning that "--skill-md is
ignored" is incorrect for language == "ailang" because this branch calls
load_ailang_prompt(skill_md) and prints the source; update the warning logic to
exclude AILANG or make it language-specific: detect when language == "ailang"
and do not emit the earlier ignore-warning (or emit a different message), or
split the warning by language so that load_ailang_prompt(skill_md) and the
console.print(f"AILANG prompt: {source} ({content_hash})") accurately reflect
that --skill-md is honored for AILANG.

---

217-241: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Handle AILANG version timeouts separately from a missing binary.

A hung ailang --version currently reports "not found on PATH", which points operators at the wrong fix. Give subprocess.TimeoutExpired its own error message and keep the install hint for FileNotFoundError.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/cli.py` around lines 217 - 241, The current ailang check lumped
FileNotFoundError and subprocess.TimeoutExpired together causing timeouts to be
reported as "not found"; in the language == "ailang" block where subprocess is
imported as _sp and _al_proc is created, split the except into two handlers:
catch FileNotFoundError and log the existing "not found on PATH" / install hint,
and catch _sp.TimeoutExpired separately and log a distinct message indicating
the version command timed out (suggesting a hung/slow ailang) before exiting;
keep all other behavior (console.print messages, SystemExit(1), and setting
ailang_ver) unchanged.

vera_bench/baseline_runner.py (2)

681-693: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Do not count a timed-out ailang run as a passed check.

Because this path skips a separate ailang check, Line 687 has no evidence that parse/type-check finished before the timeout. Returning check_pass=True here can inflate check@1 for hung startup or compile paths.

Suggested fix

     except subprocess.TimeoutExpired:
         return ProblemResult(
             problem_id=problem_id,
             model="baseline",
             language="ailang",
             attempt=1,
-            check_pass=True,
+            check_pass=False,
             run_correct=False,
             tests_total=len(test_cases),
             error_message="ailang run timed out",
             wall_time_s=round(time.monotonic() - start, 2),
             timestamp=_now(),
         )

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/baseline_runner.py` around lines 681 - 693, The except
subprocess.TimeoutExpired handler in baseline_runner.py returns a ProblemResult
claiming check_pass=True even though the separate ailang check never completed;
update the returned ProblemResult from the ailang run timeout path (the except
block) to set check_pass=False (and optionally adjust error_message to indicate
timeout during run/startup) so timeouts do not count toward check@1 for
functions/methods that parse/type-check (e.g., the ProblemResult construction in
the except subprocess.TimeoutExpired block).

---

779-785: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Run check-only AILANG problems instead of skipping them.

run_ailang_baseline() has a dedicated if not test_cases: branch, but Lines 779-785 still filter those problems out for every language except Aver. That means AILANG problems with empty test_cases never contribute to check@1, so the baseline totals are understated.

Suggested fix

-    # Aver validates all problems (check even without test_cases)
-    if language == "aver":
+    # Aver and AILANG both validate problems even without test_cases
+    if language in ("aver", "ailang"):
         run_problems = problems
     else:
         run_problems = [p for p in problems if p.get("test_cases")]

vera_bench/cli.py (1)

97-115: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Warn when --mode is ignored for AILANG.

Line 100 suppresses both warnings for AILANG, but the runner only honours mode for Vera. Passing --mode spec-from-nl with --language ailang is therefore silently ignored.

Suggested fix

-    if language not in ("vera", "aver", "ailang"):
+    if language not in ("vera", "aver", "ailang"):
         if skill_md is not None:
             console.print(
                 f"[yellow]Warning: --skill-md is ignored "
                 f"with --language {language}[/yellow]"
             )
         if mode != "full-spec":
             console.print(
                 f"[yellow]Warning: --mode is ignored "
                 f"with --language {language}[/yellow]"
             )
     if language == "aver" and mode != "full-spec":
         console.print(
             f"[yellow]Warning: --mode {mode} is ignored with --language aver[/yellow]"
         )
+    if language == "ailang" and mode != "full-spec":
+        console.print(
+            f"[yellow]Warning: --mode {mode} is ignored with --language ailang[/yellow]"
+        )

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/cli.py` around lines 97 - 115, The current logic suppresses the
--mode warning for AILANG by lumping it into the same exclusion as skill_md;
split the checks so skill_md remains excluded for languages in
("vera","aver","ailang") but the --mode warning is only suppressed for the one
language that actually honors it (vera). Concretely, keep the skill_md check
using language not in ("vera","aver","ailang") and change the mode check to if
language != "vera" and mode != "full-spec" then console.print a warning that
--mode is ignored with --language {language}; retain the special aver message if
you want a tailored message for "aver". This uses the variables language, mode,
skill_md and console to locate and update the conditions.

vera_bench/baseline_runner.py (1)

778-785: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Do not filter out AILANG's check-only problems.

run_ailang_baseline() has an explicit if not test_cases: path, but run_all_baselines() still drops every empty-test_cases problem unless the language is "aver". For AILANG that means the check-only modules never run, so the baseline JSONL and summary metrics under-report coverage and can miss broken files entirely.

Suggested fix

-    # Aver validates all problems (check even without test_cases)
-    if language == "aver":
+    # Aver and AILANG both validate problems without test_cases.
+    if language in ("aver", "ailang"):
         run_problems = problems
     else:
         run_problems = [p for p in problems if p.get("test_cases")]

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/baseline_runner.py` around lines 778 - 785, The current filtering
in run_all_baselines drops problems with empty test_cases except when language
== "aver", which prevents check-only AILANG problems from being processed;
update the conditional that sets run_problems so it also preserves problems when
language == "ailang" (or generally when the language-specific runner can handle
empty test_cases), ensuring run_ailang_baseline() receives check-only problems;
adjust the branch that computes run_problems and the skipped count so AILANG
problems are not filtered out and any console message remains correct.

vera_bench/cli.py (1)

205-237: ⚠️ Potential issue | 🟠 Major | ⚡ Quick win

Fail fast for AILANG < v0.21.0 (not just missing binaries)
vera_bench/cli.py already runs ailang --version for run(), but it only prints the version; baselines() only checks shutil.which("ailang"). The bundled AILANG baseline solutions/ailang/VB_T2_013_get_char_code.ail uses std/bytes.byteAt (added in AILANG v0.21.0), so older AILANG installs will fail later with unclear errors. Compare the parsed version against the minimum (v0.21.0) and exit early (with a clear message) in both code paths.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@vera_bench/cli.py` around lines 205 - 237, The current AILANG checks only
ensure the binary exists or prints its version; you must fail fast for versions
< 0.21.0. In the block that runs ailang --version (ais in run() where ailang_ver
is set) parse the stdout into a semantic version and exit with a clear error if
parsed version < 0.21.0; likewise update the baselines() path that currently
uses shutil.which("ailang") to also run the same version check (or reuse a
helper like check_ailang_version()) and exit early with a clear message when the
version is too old. Use a reliable version comparison (e.g.,
packaging.version.parse or simple tuple compare) on the ailang_ver variable and
reference the ailang_ver/_al_proc variables and the baselines() and run()
functions to locate where to add the check.