claude-dev-env 8.11.0 → 8.12.0

package/.agents/skills/e-code-review/reference/medium.md

@@ -1,198 +1,14 @@
-`medium effort → 3+5 angles → 1-vote verify`
+`minimal prompt → single careful diff pass → ≤15 findings`
 
-You are reviewing for **precision** at medium effort: assign severity carefully
-so a later consumer can select maintainer-action findings. **Collection
-reports every finding** (including `low` and `nit`); do not drop by
-severity during collection. Severity filtering is a separate consumer stage
-after the collection record is complete.
-
-## Phase 0 — Gather the diff
-
-Run `git diff @{upstream}...HEAD` (or `git diff main...HEAD` / `git diff HEAD~1`
+You are reviewing a pull request for bugs. Run `git diff @{upstream}...HEAD` (or `git diff main...HEAD` / `git diff HEAD~1`
 if there's no upstream) to get the unified diff under review. If there are
 uncommitted changes, or the range diff is empty, also run `git diff HEAD` and
 include the working-tree changes in scope — the review often runs before the
-commit. If a target was passed as an argument, review that target instead. A
-target names one or more items, each a PR number, a branch name, a file path, or
-`default-range` — the diff this phase gathers when no target is passed — and it
-may mix those forms. A loop round widens a target by adding a path to whatever
-it started as, and it names `default-range` as an item whenever the round it
-widened was given no target argument, so the original scope stays under review.
-When a target names more than one item, gather each item's diff and take their
-union — a shared hunk counted once, an empty one adding nothing — as the
-target's diff. Treat this diff as the review scope.
-
-## Phase 1 — Find candidates (3 correctness angles + 3 cleanup angles + 1 altitude angle + 1 conventions angle)
-
-Run **8 independent finder angles** via the Agent tool. Each surfaces
-candidate findings with `file`, `line`, a one-line `summary`, and a concrete
-`failure_scenario`. If the Agent tool is not available in your current tool
-set, do not error — perform each angle (and each verification) yourself,
-sequentially, in this context.
-
-### Angle A — line-by-line diff scan
-
-Read every hunk in the diff, line by line. Then Read the enclosing function for
-each hunk — bugs in unchanged lines of a touched function are in scope (the PR
-re-exposes or fails to fix them). For every line ask: what input, state, timing,
-or platform makes this line wrong? Look for inverted/wrong conditions,
-off-by-one, null/undefined deref, missing `await`, falsy-zero checks,
-wrong-variable copy-paste, error swallowed in catch, unescaped regex metachars.
-
-### Angle B — removed-behavior auditor
-
-For every line the diff DELETES or replaces, name the invariant or behavior it
-enforced, then search the new code for where that invariant is re-established.
-If you can't find it, that's a candidate: a removed guard, a dropped error
-path, a narrowed validation, a deleted test that was covering a case.
-
-### Angle C — cross-file tracer
-
-For each function the diff changes, find its callers (Grep for the symbol) and
-check whether the change breaks any call site: a new precondition, a changed
-return shape, a new exception, a timing/ordering dependency. Also check callees:
-does a parallel change in the same PR make a call unsafe?
-
-### Reuse
-
-The angles above hunt for bugs; this one and the next two hunt for cleanup in
-the changed code. Flag new code that re-implements something the codebase
-already has — Grep shared/utility modules and files adjacent to the change,
-and name the existing helper to call instead.
-
-### Simplification
-
-Flag unnecessary complexity the diff adds: redundant or derivable state,
-copy-paste with slight variation, deep nesting, dead code left behind. Name
-the simpler form that does the same job.
-
-### Efficiency
-
-Flag wasted work the diff introduces: redundant computation or repeated I/O,
-independent operations run sequentially, blocking work added to startup or
-hot paths. Also flag long-lived objects built from closures or captured
-environments — they keep the entire enclosing scope alive for the object's
-lifetime (a memory leak when that scope holds large values); prefer a
-class/struct that copies only the fields it needs. Name the cheaper
-alternative.
-
-### Altitude
-
-Check that each change is implemented at the right depth, not as a fragile
-bandaid. Special cases layered on shared infrastructure are a sign the fix
-isn't deep enough — prefer generalizing the underlying mechanism over adding
-special cases.
-
-### Conventions (CLAUDE.md)
-
-Find the CLAUDE.md files that govern the changed code: the user-level
-~/.claude/CLAUDE.md, the repo-root CLAUDE.md, plus any CLAUDE.md or
-CLAUDE.local.md in a directory that is an ancestor of a changed file (a
-directory's CLAUDE.md only applies to files at or below it). Read each one
-that exists, then check the diff for clear violations of the rules they state.
-
-Only flag a violation when you can quote the exact rule and the exact line
-that breaks it — no style preferences, no vague "spirit of the doc"
-inferences. In the finding, name the CLAUDE.md path and quote the rule so the
-report can cite it. If no CLAUDE.md applies, return nothing for this angle.
-
-Cleanup, altitude, and conventions candidates use the same
-`file`/`line`/`summary` shape; in `failure_scenario`, state the concrete
-cost (what is duplicated, wasted, harder to maintain, or which CLAUDE.md rule
-is broken) instead of a crash. Correctness bugs always outrank cleanup,
-altitude, and conventions findings.
-
-Pass every candidate with a nameable failure scenario through — finders that
-silently drop half-believed candidates bypass the verify step and are the
-dominant cause of misses.
-
-## Phase 2 — Verify (1-vote, 3-state)
-
-Dedup candidates that point at the same line/mechanism, keeping the one with
-the most concrete failure scenario. For each remaining candidate, run **one
-verifier** via the Agent tool: give it the diff, the relevant
-file(s), and the candidate, and have it return exactly one of:
-
-- **CONFIRMED** — can name the inputs/state that trigger it and the wrong
-  output or crash. Quote the line.
-- **PLAUSIBLE** — mechanism is present in the code, trigger is uncertain (timing, env,
-  config). State what would confirm it.
-- **REFUTED** — factually wrong (code doesn't say that) or guarded elsewhere.
-  Quote the line that proves it.
-
-Keep candidates where the vote is CONFIRMED or PLAUSIBLE.
-
-## Output
-
-**Collection stage first.** Keep every CONFIRMED or PLAUSIBLE finding in the
-collection record, including `low` and `nit`. Drop only REFUTED candidates.
-Do not drop a finding because its severity is low.
-
-Report this review's results — `{level, findings}` — through the structured
-findings-report call: the mechanism that renders a review's results as a typed
-list in the host UI, ranked most-severe first. Each **retained** entry carries
-every field below. Do not emit a finding that lacks `severity` or `verdict`.
-
-**Severity filter stage (later consumer).** After the collection record is
-complete, a separate consumer may filter by minimum severity for action or
-display. That filter must not rewrite or discard fields on the collection
-record itself.
-
-| Field | Required | Value |
-|---|---|---|
-| `file` | yes | path under review |
-| `line` | yes | 1-based line number |
-| `summary` | yes | full claim |
-| `short_summary` | yes | claim compressed to ≤60 characters, no rationale or consequence clause |
-| `failure_scenario` | yes | concrete trigger and wrong outcome, or concrete cost for cleanup |
-| `category` | yes | short kebab-case slug for the angle (`correctness`, `simplification`, `efficiency`, `reuse`, `altitude`, `conventions`, or a tighter slug like `test-coverage`) |
-| `severity` | yes | one of `blocker`, `high`, `medium`, `low`, `nit` |
-| `verdict` | yes | `CONFIRMED` or `PLAUSIBLE` from Phase 2 |
-
-**Severity rules.** Assign exactly one token from the frozen set above. Use
-`nit` only when all five hold: the change is localized clarity, formatting, or
-a typo; correctness, security, data, and API behavior stay identical; test
-coverage and operability stay identical; dependencies and rollout stay
-identical; the fix is mechanical and bounded. Any other retained finding is
-`low` or higher. Correctness bugs outrank cleanup, altitude, and conventions.
-
-If nothing survives verification, make that call with an empty array. Do not
-also print the findings as text, and do not create or publish an artifact of
-the review — the structured call is the report.
-
-## Applying fixes (--fix)
-
-The `--fix` flag was passed. Follow `reference\fix.md` (relative
-to this skill's folder) for the exact fix, code-rules-gate, and skip-handling
-behavior — it governs which agent applies each fix, how the code-rules gate
-runs, how a skip is logged, and how outcomes get reported. Do not repeat the
-findings as text; follow that document's reporting rules once fixes land.
-
-When `loop` is also set, skip this section.
-
-## If findings are fixed later
-
-Whenever a reported finding is fixed later in this session — the user asks you
-to fix it, or later work fixes it incidentally — follow `reference\fix.md`'s
-reporting rules again: report the same findings through the structured
-findings-report call, each carrying an `outcome`. Do not repeat the findings
-as text. Make that call immediately after the fixes land, before any prose
-summary; the host UI's per-finding status updates only from that call.
-
-## Looping (`loop`)
+commit. If a PR number, branch name, or file path was passed as an argument,
+review that target instead. Treat this diff as the review scope.
 
-The `loop` arg was passed. Follow `reference\loop.md` (relative to this
-skill's folder) for how to re-run Phases 0–2 and Output repeatedly — including
-its exit condition and re-invocation rules. Schedule no fix pass of your own
-here: when `--fix` is also present, `reference\loop.md`'s gate sequence owns the
-round's fixing and loads `reference\fix.md` for the mechanics. Do not treat a
-single pass through this document as complete while `loop` is active; hand
-control to that document, and do not stop at Output.
+Review the diff as a careful senior engineer would: read every hunk, open the surrounding files for context as needed (Read, Grep, git log/blame/show), and hunt for correctness issues — wrong or inverted conditions, off-by-one, null/undefined dereference, missing `await`, dropped error handling, removed guards or validations, broken callers of changed functions, races. Report failure modes and leave style out; every finding needs a concrete scenario in which the code misbehaves.
 
-That hand-off applies when this document is entered directly. When a loop round
-is already running and has handed this document its target, the round owns the
-loop: end at Output with the findings report and return those findings to
-`reference\loop.md`'s gate sequence, rather than handing control to that
-document again from here.
+When you are done, submit at most 15 findings via the ReportFindings tool, filling its fields as defined — for each: the file path and start line, a severity, and a comment that states the issue and the concrete scenario in which the code misbehaves. Quality over quantity: include every issue you believe is a bug, and nothing you don't.
 
-When `loop` was not passed, skip this section.
+After the tool call, also restate the findings in your final reply — one line each, `file:line — summary` — so they stay visible in sessions that do not render tool output.

package/.agents/skills/e-code-review/reference/xhigh.md

@@ -1,7 +1,7 @@
-`xhigh effort → 5+5 angles → 1-vote verify → sweep`
+`xhigh effort → 10 inline angles → dedup (no verify) → sweep → ≤15 findings`
 
 You are reviewing for **recall** at extra-high effort: catch every bug. At
-this level, catching bugs matters more than avoiding false positives — a
+this level, surface a finding even when it may be a false positive. A
 missed bug ships. Err on the side of surfacing.
 
 ## Phase 0 — Gather the diff
@@ -10,23 +10,15 @@ Run `git diff @{upstream}...HEAD` (or `git diff main...HEAD` / `git diff HEAD~1`
 if there's no upstream) to get the unified diff under review. If there are
 uncommitted changes, or the range diff is empty, also run `git diff HEAD` and
 include the working-tree changes in scope — the review often runs before the
-commit. If a target was passed as an argument, review that target instead. A
-target names one or more items, each a PR number, a branch name, a file path, or
-`default-range` — the diff this phase gathers when no target is passed — and it
-may mix those forms. A loop round widens a target by adding a path to whatever
-it started as, and it names `default-range` as an item whenever the round it
-widened was given no target argument, so the original scope stays under review.
-When a target names more than one item, gather each item's diff and take their
-union — a shared hunk counted once, an empty one adding nothing — as the
-target's diff. Treat this diff as the review scope.
-
-## Phase 1 — Find candidates (5 correctness angles + 3 cleanup angles + 1 altitude angle + 1 conventions angle)
-
-Run **10 independent finder angles** via the Agent tool. Each surfaces
-candidate findings. Do NOT let one angle's conclusions suppress another's — if
-two angles flag the same line for different reasons, record both. If the Agent
-tool is not available in your current tool set, do not error — perform each
-angle (and each verification) yourself, sequentially, in this context.
+commit. If a PR number, branch name, or file path was passed as an argument,
+review that target instead. Treat this diff as the review scope.
+
+## Phase 1 — Find candidates (5 correctness angles + 3 cleanup angles + 1 altitude angle + 1 conventions angle, up to 8 each)
+
+Run **10 independent finder angles** in sequence yourself, in THIS context — do NOT spawn subagents for them. Each
+surfaces **up to 8 candidate findings**. Do NOT let one angle's conclusions
+suppress another's — if two angles flag the same line for different reasons,
+record both.
 
 ### Angle A — line-by-line diff scan
 
@@ -39,10 +31,10 @@ wrong-variable copy-paste, error swallowed in catch, unescaped regex metachars.
 
 ### Angle B — removed-behavior auditor
 
-For every line the diff DELETES or replaces, name the invariant or behavior it
+For every line the diff DELETES or rewrites, name the invariant or behavior it
 enforced, then search the new code for where that invariant is re-established.
 If you can't find it, that's a candidate: a removed guard, a dropped error
-path, a narrowed validation, a deleted test that was covering a case.
+path, a narrowed validation, a deleted test that was covering a live case.
 
 ### Angle C — cross-file tracer
 
@@ -63,7 +55,7 @@ timezone/DST drift; float equality. Flag any instance the diff introduces.
 When the PR adds or modifies a type that wraps another (cache, proxy, decorator,
 adapter): check that every method routes to the wrapped instance and not back
 through a registry/session/global — e.g. a caching provider holding a
-`delegate` field that resolves IDs via `session.get(...)` instead of
+`delegate` field that resolves IDs via `session.get(...)` where it should call
 `delegate.get(...)` will re-enter the cache or recurse. Also check that the
 wrapper forwards all the methods the callers use.
 
@@ -92,10 +84,11 @@ alternative.
 
 ### Altitude
 
-Check that each change is implemented at the right depth, not as a fragile
-bandaid. Special cases layered on shared infrastructure are a sign the fix
-isn't deep enough — prefer generalizing the underlying mechanism over adding
-special cases.
+Check that each change fixes the root cause at the right depth. A fix that
+patches a symptom with a fragile bandaid is a finding. Special cases layered on shared
+infrastructure are a sign the fix isn't deep enough — prefer the simpler, more
+general change to the underlying mechanism over adding special cases, and name
+that change.
 
 ### Conventions (CLAUDE.md)
 
@@ -113,31 +106,16 @@ report can cite it. If no CLAUDE.md applies, return nothing for this angle.
 Cleanup, altitude, and conventions candidates use the same
 `file`/`line`/`summary` shape; in `failure_scenario`, state the concrete
 cost (what is duplicated, wasted, harder to maintain, or which CLAUDE.md rule
-is broken) instead of a crash. Correctness bugs always outrank cleanup,
-altitude, and conventions findings.
-
-## Phase 2 — Verify (1-vote, 3-state)
+is broken) in the place a crash would go. Correctness bugs always outrank cleanup,
+altitude, and conventions findings when the output cap forces a cut.
 
-Dedup candidates that point at the same line/mechanism, keeping the one with
-the most concrete failure scenario. For each remaining candidate, run **one
-verifier** via the Agent tool: give it the diff, the relevant
-file(s), and the candidate, and have it return exactly one of:
+## Phase 2 — Dedup only (no verify)
 
-- **CONFIRMED** — can name the inputs/state that trigger it and the wrong
-  output or crash. Quote the line.
-- **PLAUSIBLE** — mechanism is present in the code, trigger is uncertain (timing, env,
-  config). State what would confirm it.
-- **REFUTED** — factually wrong (code doesn't say that) or guarded elsewhere.
-  Quote the line that proves it.
-
-Keep candidates where the vote is CONFIRMED or PLAUSIBLE.
-
-This is recall mode — a single non-REFUTED vote carries the finding. Do NOT
-drop on uncertainty.
+Pool all candidates. Dedup near-duplicates only (same defect, same location, same reason → keep one). Do NOT run verifiers; do NOT re-judge. Sort by severity. Do NOT drop on uncertainty.
 
 ## Phase 3 — Sweep for gaps
 
-Run **one more finder** as a fresh reviewer who has the verified list. Re-read
+Take one more pass (same context — no subagent) as a fresh reviewer who has the deduplicated list. Re-read
 the diff and enclosing functions looking ONLY for defects not already listed.
 Do not re-derive or re-confirm anything already there — the job is gaps. Focus
 on what the first pass tends to miss: moved/extracted code that dropped a guard
@@ -145,56 +123,34 @@ or anchor; second-tier footguns (dataclass default evaluated once, `hash()`
 non-determinism, lock-scope shrink, predicate methods with side effects);
 setup/teardown asymmetry in tests; config defaults flipped.
 
-Surface additional candidates, each naming a defect not already on the list.
-If nothing new, return an empty sweep — do not pad.
+Surface **up to 8 additional candidates**, each naming a defect not already on
+the list. If nothing new, return nothing from this phase — do not pad.
 
 ## Output
 
-Report this review's results — `{level, findings}` — through the structured
-findings-report call: the mechanism that renders a review's results as a typed
-list in the host UI, ranked most-severe first. Each entry has `file`, `line`,
-`summary`, `short_summary` — the claim compressed to ≤60 characters, no
-rationale or consequence clause — `failure_scenario`, and `category` — a short
-kebab-case slug for the angle that produced it (`correctness`,
-`simplification`, `efficiency`, `reuse`, `altitude`, `conventions`, or a more
-specific slug like `test-coverage` when one fits better) — plus `verdict` when
-a verify pass produced one. If nothing survives verification, make that call
-with an empty array. Do not also print the findings as text, and do not create
-or publish an artifact of the review — the structured call is the report.
-
-## Applying fixes (--fix)
+Target **at least 7 findings**. If fewer findings exist, emit what you have — do not invent to hit the floor.
 
-The `--fix` flag was passed. Follow `reference\fix.md` (relative
-to this skill's folder) for the exact fix, code-rules-gate, and skip-handling
-behavior — it governs which agent applies each fix, how the code-rules gate
-runs, how a skip is logged, and how outcomes get reported. Do not repeat the
-findings as text; follow that document's reporting rules once fixes land.
+Call the ReportFindings tool once to report this review's results
+with `{level, findings}`. `findings` is at most 15 entries ranked
+most-severe first; each entry has `file`, `line`, `summary`,
+`short_summary` — the claim compressed to ≤60 characters, no rationale
+or consequence clause — `failure_scenario`, and `category` — a short kebab-case slug for the angle
+that produced it (`correctness`, `simplification`, `efficiency`,
+`reuse`, `altitude`, `conventions`, or a more specific slug like
+`test-coverage` when one fits better) — plus `verdict` when a verify pass
+produced one. If more than 15 survive, keep the 15 most severe. If
+nothing survives, call it with an empty array. Do not also print
+the findings as text, and do not create or publish an artifact of the review -
+the tool call is the report.
 
-When `loop` is also set, skip this section.
 
 ## If findings are fixed later
 
-Whenever a reported finding is fixed later in this session — the user asks you
-to fix it, or later work fixes it incidentally — follow `reference\fix.md`'s
-reporting rules again: report the same findings through the structured
-findings-report call, each carrying an `outcome`. Do not repeat the findings
-as text. Make that call immediately after the fixes land, before any prose
-summary; the host UI's per-finding status updates only from that call.
-
-## Looping (`loop`)
-
-The `loop` arg was passed. Follow `reference\loop.md` (relative to this
-skill's folder) for how to re-run Phases 0–3 and Output repeatedly — including
-its exit condition and re-invocation rules. Schedule no fix pass of your own
-here: when `--fix` is also present, `reference\loop.md`'s gate sequence owns the
-round's fixing and loads `reference\fix.md` for the mechanics. Do not treat a
-single pass through this document as complete while `loop` is active; hand
-control to that document, and do not stop at Output.
-
-That hand-off applies when this document is entered directly. When a loop round
-is already running and has handed this document its target, the round owns the
-loop: end at Output with the findings report and return those findings to
-`reference\loop.md`'s gate sequence, rather than handing control to that
-document again from here.
-
-When `loop` was not passed, skip this section.
+Whenever reported findings get fixed later in this session - the user asks you
+to fix them, or later work fixes them incidentally - you MUST call ReportFindings again with the same findings, each
+carrying an `outcome`: `fixed`, `no_change_needed` (the finding was wrong or
+already handled), or `skipped` (valid but not applied). Do not repeat the
+findings as text.
+Make that call immediately after the fixes land, before any prose summary; the
+host UI's per-finding status updates only from it, and without it the findings
+stay marked unresolved.

package/_shared/pr-loop/scripts/fix_pr_test_proof.py

@@ -5,22 +5,33 @@
     title "docs: ..."                               -> pass, nothing to prove
     title "fix: ..." changing only docs or .github  -> pass, nothing to prove
     title "fix: ..." with no changed Python test    -> fail
+    title "fix: ..." with no changed Python or Node test -> fail
     changed test passes on head, fails on base      -> pass
     changed test passes on both                     -> fail
+    any changed test fails on head                  -> fail
 
-The base run reuses the regression gate's detached worktree: the changed test
+Python tests reuse the regression gate's detached worktree: the changed test
 files are copied onto the base checkout, which runs them with import isolation.
-Python tests only.
+Node tests (``*.test.mjs``, ``*.test.js``, ``*.test.cjs``) run through
+``node --test`` on the head, then on a detached base checkout that holds a copy
+of the changed test files. The fix is proven when at least one language's
+changed tests fail on the base.
 """
 
 import argparse
+import shutil
+import subprocess
 import sys
+import tempfile
+from enum import Enum
 from pathlib import Path
 
 from code_rules_gate_parts import staged_test_regression, staged_test_running
 from code_rules_gate_parts.git_file_sets import paths_from_git_diff
 from code_rules_gate_parts.wrapper_plumb_check import is_test_path
 from pr_loop_shared_constants.fix_pr_test_proof_constants import (
+    ALL_NODE_TEST_COMMAND,
+    ALL_NODE_TEST_SUFFIXES,
     ALL_PRODUCTION_CODE_SUFFIXES,
     CI_CONFIG_DIRECTORY_NAME,
     FAILED_EXIT_CODE,
@@ -29,6 +40,8 @@ from pr_loop_shared_constants.fix_pr_test_proof_constants import (
     NO_BASE_FAILURE_MESSAGE,
     NO_CHANGED_TEST_MESSAGE,
     NO_PRODUCTION_CHANGE_MESSAGE,
+    NODE_BASE_WORKTREE_DIRECTORY_NAME,
+    NODE_BASE_WORKTREE_TEMP_DIRECTORY_PREFIX,
     NOT_A_FIX_MESSAGE,
     PASSED_EXIT_CODE,
     PROVEN_MESSAGE,
@@ -36,6 +49,15 @@ from pr_loop_shared_constants.fix_pr_test_proof_constants import (
 )
 
 
+class ProofVerdict(Enum):
+    """The result of running one language's changed tests on the head and the base."""
+
+    HEAD_FAILED = "head_failed"
+    BASE_UNAVAILABLE = "base_unavailable"
+    PASSES_ON_BASE = "passes_on_base"
+    PROVEN = "proven"
+
+
 def _parse_arguments(all_arguments: list[str]) -> argparse.Namespace:
     parser = argparse.ArgumentParser(prog="fix_pr_test_proof")
     parser.add_argument("--title", required=True)
@@ -72,9 +94,17 @@ def _changed_python_tests(all_changed_paths: list[Path]) -> list[Path]:
     ]
 
 
-def _proof_exit_code(
+def _changed_node_tests(all_changed_paths: list[Path]) -> list[Path]:
+    return [
+        each_path
+        for each_path in all_changed_paths
+        if each_path.name.endswith(ALL_NODE_TEST_SUFFIXES) and each_path.is_file()
+    ]
+
+
+def _python_proof_verdict(
     all_changed_tests: list[Path], repository_root: Path, base_revision: str
-) -> int:
+) -> ProofVerdict:
     all_targets = staged_test_running._pytest_target_paths(all_changed_tests)
     all_tests_by_root = staged_test_running._group_staged_tests_by_root(
         all_targets, repository_root
@@ -87,18 +117,78 @@ def _proof_exit_code(
     for each_group_root, each_outcome in sorted(head_outcomes.items()):
         if each_outcome.exit_code != 0:
             sys.stderr.write(HEAD_FAILURE_MESSAGE.format(group_root=each_group_root) + "\n")
-            return FAILED_EXIT_CODE
+            return ProofVerdict.HEAD_FAILED
     if base_outcomes is None:
         sys.stderr.write(WORKTREE_FAILED_MESSAGE.format(revision=base_revision) + "\n")
-        return FAILED_EXIT_CODE
+        return ProofVerdict.BASE_UNAVAILABLE
     base_failure_count = sum(
         len(each_outcome.failing_identities) for each_outcome in base_outcomes.values()
     )
     if base_failure_count == 0:
-        sys.stderr.write(NO_BASE_FAILURE_MESSAGE.format(revision=base_revision) + "\n")
-        return FAILED_EXIT_CODE
+        return ProofVerdict.PASSES_ON_BASE
     sys.stdout.write(PROVEN_MESSAGE.format(count=base_failure_count) + "\n")
-    return PASSED_EXIT_CODE
+    return ProofVerdict.PROVEN
+
+
+def _node_tests_pass(working_directory: Path, all_relative_tests: list[Path]) -> bool:
+    node_run = subprocess.run(
+        [*ALL_NODE_TEST_COMMAND, *(each_path.as_posix() for each_path in all_relative_tests)],
+        cwd=working_directory,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return node_run.returncode == 0
+
+
+def _copy_tests_onto(
+    base_worktree: Path, repository_root: Path, all_relative_tests: list[Path]
+) -> None:
+    for each_relative_test in all_relative_tests:
+        base_test_path = base_worktree / each_relative_test
+        base_test_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(repository_root / each_relative_test, base_test_path)
+
+
+def _node_proof_verdict(
+    all_changed_tests: list[Path], repository_root: Path, base_revision: str
+) -> ProofVerdict:
+    all_relative_tests = [each_path.relative_to(repository_root) for each_path in all_changed_tests]
+    if not _node_tests_pass(repository_root, all_relative_tests):
+        sys.stderr.write(HEAD_FAILURE_MESSAGE.format(group_root=repository_root) + "\n")
+        return ProofVerdict.HEAD_FAILED
+    with tempfile.TemporaryDirectory(
+        prefix=NODE_BASE_WORKTREE_TEMP_DIRECTORY_PREFIX, ignore_cleanup_errors=True
+    ) as base_parent_text:
+        base_worktree = Path(base_parent_text) / NODE_BASE_WORKTREE_DIRECTORY_NAME
+        if not staged_test_regression._add_baseline_worktree(
+            repository_root, base_worktree, base_revision
+        ):
+            sys.stderr.write(WORKTREE_FAILED_MESSAGE.format(revision=base_revision) + "\n")
+            return ProofVerdict.BASE_UNAVAILABLE
+        try:
+            _copy_tests_onto(base_worktree, repository_root, all_relative_tests)
+            passes_on_base = _node_tests_pass(base_worktree, all_relative_tests)
+        finally:
+            staged_test_regression._remove_baseline_worktree(repository_root, base_worktree)
+    if passes_on_base:
+        return ProofVerdict.PASSES_ON_BASE
+    sys.stdout.write(PROVEN_MESSAGE.format(count=len(all_relative_tests)) + "\n")
+    return ProofVerdict.PROVEN
+
+
+def _proof_exit_code(
+    all_verdicts: list[ProofVerdict], base_revision: str
+) -> int:
+    if any(
+        each_verdict in (ProofVerdict.HEAD_FAILED, ProofVerdict.BASE_UNAVAILABLE)
+        for each_verdict in all_verdicts
+    ):
+        return FAILED_EXIT_CODE
+    if ProofVerdict.PROVEN in all_verdicts:
+        return PASSED_EXIT_CODE
+    sys.stderr.write(NO_BASE_FAILURE_MESSAGE.format(revision=base_revision) + "\n")
+    return FAILED_EXIT_CODE
 
 
 def main(all_arguments: list[str]) -> int:
@@ -121,11 +211,22 @@ def main(all_arguments: list[str]) -> int:
     ):
         sys.stdout.write(NO_PRODUCTION_CHANGE_MESSAGE + "\n")
         return PASSED_EXIT_CODE
-    all_changed_tests = _changed_python_tests(all_changed_paths)
-    if not all_changed_tests:
+    all_changed_python_tests = _changed_python_tests(all_changed_paths)
+    all_changed_node_tests = _changed_node_tests(all_changed_paths)
+    if not all_changed_python_tests and not all_changed_node_tests:
         sys.stderr.write(NO_CHANGED_TEST_MESSAGE + "\n")
         return FAILED_EXIT_CODE
-    return _proof_exit_code(all_changed_tests, repository_root, parsed_arguments.base_revision)
+    base_revision = parsed_arguments.base_revision
+    all_verdicts: list[ProofVerdict] = []
+    if all_changed_python_tests:
+        all_verdicts.append(
+            _python_proof_verdict(all_changed_python_tests, repository_root, base_revision)
+        )
+    if all_changed_node_tests:
+        all_verdicts.append(
+            _node_proof_verdict(all_changed_node_tests, repository_root, base_revision)
+        )
+    return _proof_exit_code(all_verdicts, base_revision)
 
 
 if __name__ == "__main__":

package/_shared/pr-loop/scripts/pr_loop_shared_constants/fix_pr_test_proof_constants.py

@@ -15,6 +15,10 @@ ALL_PRODUCTION_CODE_SUFFIXES: tuple[str, ...] = (
     ".ps1",
     ".sh",
 )
+ALL_NODE_TEST_SUFFIXES: tuple[str, ...] = (".test.mjs", ".test.js", ".test.cjs")
+ALL_NODE_TEST_COMMAND: tuple[str, ...] = ("node", "--test")
+NODE_BASE_WORKTREE_TEMP_DIRECTORY_PREFIX: str = "fix_pr_test_proof_node_base_"
+NODE_BASE_WORKTREE_DIRECTORY_NAME: str = "tree"
 CI_CONFIG_DIRECTORY_NAME: str = ".github"
 PASSED_EXIT_CODE: int = 0
 FAILED_EXIT_CODE: int = 1
@@ -24,7 +28,7 @@ NO_PRODUCTION_CHANGE_MESSAGE: str = (
     "fix_pr_test_proof: the fix changes no production code; nothing to prove."
 )
 NO_CHANGED_TEST_MESSAGE: str = (
-    "fix_pr_test_proof: this fix changes production code and no Python test. "
+    "fix_pr_test_proof: this fix changes production code and no Python or Node test. "
     "Add a test that fails on the base and passes on the head."
 )
 WORKTREE_FAILED_MESSAGE: str = (