Merge pull request 'List larv-review's passes in one place that round_titles and the ladder derive from, and check the pass table against it' (#354) from item-121 into main

This commit was merged in pull request #354.
This commit is contained in:
2026-10-22 20:56:44 +02:00
16 changed files with 107 additions and 36 deletions
+1
View File
@@ -54,6 +54,7 @@
!bin/repo_checks/*.py
!bin/review-replay
!bin/review_folder.py
!bin/review_passes.py
!bin/review_replay/
!bin/review_replay/*.py
!bin/round_titles.py
+2 -1
View File
@@ -101,13 +101,14 @@ import re
import sys
import typing
from round_titles import CAP, PASSES, round_counts
from round_titles import CAP, round_counts
from git_repo import default_branch, git, top
from failure import Failure
from comprehension_history import FLOOR
from larv_review.git import history_changes
from larv_review.ruling_base import measured_commit
from larv_review.agreement import MIN_PAIRS
from review_passes import PASSES
from larv_review.plan import plan_reasons
from larv_review.record import record_ruling, record_scoring, show_agreement, show_places
from review_folder import REPORTS, review_folder
+2 -1
View File
@@ -1,8 +1,9 @@
from model_routing.ladder import climbed, LADDER, position, review_rungs, REVIEWERS, reviewers_rung, ReviewKind, Rung
from model_routing.ladder import climbed, LADDER, position, review_rungs, reviewers_rung, ReviewKind, Rung
from model_routing.route import ESCALATION_MARKER, HIGHEST_ESCAPE_AND_IMPACT, Route
from loop_claude.routing import escalation_rungs
from loop_claude.project.records import HUMAN_RULE_NAMES, RECORD_FILES
from markdown_text import listed, quoted
from review_passes import REVIEWERS
from claude_code.transcript import Typed
# Where the judge may quote an answer from, named as the human and the worker see them; of README.md the judge sees only the premises.
+2 -4
View File
@@ -3,10 +3,10 @@ import dataclasses
import re
import typing
from review_passes import ReviewedPass, REVIEWERS
# How Rung.__str__ spells a rung that names an effort, and Rung.parse reads it back.
WORDING = re.compile(r"(?P<model>\S+) at (?P<effort>\S+) effort")
# A pass an agent under agents/ reviews, named as skills/larv-review/SKILL.md → "Passes" names it in lower case.
ReviewedPass = typing.Literal["architecture", "principles", "overrides", "stability", "product-owner", "prose"]
# What a review launch reviews: such a pass, a comprehension seat or the security pass.
ReviewKind = ReviewedPass | typing.Literal["seat", "security"]
@@ -65,8 +65,6 @@ LADDER = (
WORKER_STEPS = {1: -1, 2: -1, 3: 0, 4: 1}
# The rungs a task's E + I steps a review up from the project's rung; an E + I under 5 steps none.
REVIEW_STEPS = {5: 1, 6: 2, 7: 3, 8: 4}
# Each pass an agent under agents/ reviews, in the order of SKILL.md's pass table, and that agent.
REVIEWERS: dict[ReviewedPass, str] = {"architecture": "systems-architect", "principles": "principles-auditor", "overrides": "override-reviewer", "stability": "stability-reviewer", "product-owner": "product-owner-reviewer", "prose": "prose-reviewer"}
# The rung a pass's replay chose for the projects on a model: docs/decisions.md → `routing: a review pass runs below the project's rung only on a rung that a replay of its rounds shows finding every 🔴 and 🟡 the project's rung finds`.
REPLAYED: dict[tuple[ReviewedPass, str], Rung] = {}
+2 -7
View File
@@ -1,14 +1,14 @@
import pathlib
import sys
import typing
import unittest
import unittest.mock
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from model_routing.ladder import highest, LADDER, lowest_worker_rung, planning_rung, position, project_rung, review_floor, review_rungs, ReviewedPass, REVIEWERS, Rung, stepped_up, worker_rung, WORKER_STEPS
from model_routing.ladder import highest, LADDER, lowest_worker_rung, planning_rung, position, project_rung, review_floor, review_rungs, Rung, stepped_up, worker_rung, WORKER_STEPS
from model_routing import ladder
from todo_table import LEVELS
from review_passes import REVIEWERS
OPUS = Rung("claude-opus-5-5", "medium")
@@ -105,11 +105,6 @@ class Ladder(unittest.TestCase):
def test_keeps_the_seats_and_the_security_pass_on_the_projects_rung_whatever_the_worker_or_e_plus_i(self):
self.assertEqual(review_rungs(OPUS, LADDER[-1], 8), {**dict.fromkeys(REVIEWERS, LADDER[-1]), "seat": OPUS, "security": OPUS})
def test_names_every_kind_of_review_once_each_pass_with_its_agent_under_agents(self):
self.assertEqual(list(REVIEWERS), list(typing.get_args(ReviewedPass)))
agents = pathlib.Path(__file__).resolve().parents[2] / "agents"
self.assertEqual(sorted(REVIEWERS.values()), sorted(path.stem for path in agents.glob("*.md")))
def test_runs_a_replayed_pass_on_its_replays_rung_below_the_workers_where_the_e_plus_i_steps_no_review_up_and_the_worker_runs_no_higher_than_the_project(self):
sonnet, haiku, opus_high = Rung("claude-sonnet-5-5", "high"), LADDER[0], Rung("claude-opus-5-5", "high")
with unittest.mock.patch.dict(ladder.REPLAYED, {("prose", "claude-opus-5-5"): haiku, ("stability", "claude-sonnet-5-5"): haiku}):
+10 -12
View File
@@ -5,27 +5,25 @@ import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from round_titles import PASSES
from model_routing.ladder import REVIEWERS
from review_passes import PASS_AGENTS, PASSES
from repo_checks.test_python_floor import ROOT
from rule_hook.reviewer_rung import SEAT, SECURITY_OPENER
OPENING = re.compile(r"^## Opening\n+```\n([^\n]+?\.)(?: |\n)", re.MULTILINE)
# A row of the pass table whose reviewer is an agent: its pass and that agent.
REVIEWED_ROW = re.compile(r"^\| ([A-Z][a-z-]+) \| ([a-z]+(?:-[a-z]+)*-(?:reviewer|architect|auditor)) \|", re.MULTILINE)
# An agent's name, as opposed to the skill or plugin that reviews a pass.
AGENT_NAME = re.compile(r"[a-z]+(?:-[a-z]+)*")
# A row of the pass table: its pass and its reviewer cell.
PASS_ROW = re.compile(r"^\| (?!Pass \|)([A-Z][a-z -]+?) \| ([^|]+?) \|", re.MULTILINE)
LARV_REVIEW = (ROOT / "skills" / "larv-review" / "SKILL.md").read_text(encoding="utf-8")
PASS_TABLE = LARV_REVIEW.split("## 3. Passes", 1)[1].split("A comment is prose", 1)[0]
class ReviewerLaunches(unittest.TestCase):
"""rule-hook holds a review launch to its rung by recognising it; these fail when what it recognises drifts from what the skills launch."""
"""rule-hook holds a review launch to its rung by recognising it, and `larv-review round-count` counts the passes by name; these fail when what they recognise drifts from what the skills launch."""
def test_the_reviewers_are_the_passes_and_agents_larv_review_s_pass_table_names_in_its_order(self):
passes = LARV_REVIEW.split("## 3. Passes", 1)[1].split("A comment is prose", 1)[0]
self.assertEqual({name.lower(): agent for name, agent in REVIEWED_ROW.findall(passes)}, REVIEWERS)
self.assertEqual([name.lower() for name, _ in REVIEWED_ROW.findall(passes)], list(REVIEWERS))
def test_each_reviewed_pass_is_a_pass_the_round_titles_count(self):
self.assertEqual([name for name in PASSES if name in REVIEWERS], list(REVIEWERS))
def test_the_passes_and_their_agents_are_the_ones_larv_review_s_pass_table_names_in_its_order(self):
rows = [(name.lower(), reviewer if AGENT_NAME.fullmatch(reviewer) else None) for name, reviewer in PASS_ROW.findall(PASS_TABLE)]
self.assertEqual(rows, list(PASS_AGENTS.items()))
def test_the_seat_opening_is_the_sentence_that_opens_every_seat_prompt(self):
opening = OPENING.search((ROOT / "skills" / "comprehension-panel" / "seat-prompts.md").read_text(encoding="utf-8"))
+1 -1
View File
@@ -15,5 +15,5 @@ class Types(unittest.TestCase):
self.assertIsNotNone(floor, "README.md's Install names `Python 3.N or newer`")
if shutil.which("uv") is None:
self.fail("uv on PATH fetches mypy; see README.md's Test line")
ran = subprocess.run(["uv", "tool", "run", "--python", "%d.%d" % floor, "mypy==2.3.1", "--cache-dir=/dev/null", "--check-untyped-defs", "--disallow-untyped-defs", "--exclude", "/test_", "-p", "chunk_preflight", "-p", "claude_code", "-m", "comprehension_history", "-m", "git_repo", "-p", "judge_replay", "-p", "larv_review", "-p", "loop_claude", "-m", "markdown_text", "-p", "metric_bench", "-m", "project_key", "-m", "rank_todo", "-p", "reading_cost", "-p", "review_replay", "-m", "round_titles", "-p", "rule_hook", "-p", "rung_replay", "-p", "score_outcomes", "-m", "settings_filter", "-m", "shell_command", "-m", "statusline", "-p", "subagent_rung", "-m", "todo_table", "-p", "transcript_archive", "-m", "utc_stamp"], capture_output=True, cwd=ROOT / "bin", text=True)
ran = subprocess.run(["uv", "tool", "run", "--python", "%d.%d" % floor, "mypy==2.3.1", "--cache-dir=/dev/null", "--check-untyped-defs", "--disallow-untyped-defs", "--exclude", "/test_", "-p", "chunk_preflight", "-p", "claude_code", "-m", "comprehension_history", "-m", "git_repo", "-p", "judge_replay", "-p", "larv_review", "-p", "loop_claude", "-m", "markdown_text", "-p", "metric_bench", "-m", "project_key", "-m", "rank_todo", "-p", "reading_cost", "-m", "review_passes", "-p", "review_replay", "-m", "round_titles", "-p", "rule_hook", "-p", "rung_replay", "-p", "score_outcomes", "-m", "settings_filter", "-m", "shell_command", "-m", "statusline", "-p", "subagent_rung", "-m", "todo_table", "-p", "transcript_archive", "-m", "utc_stamp"], capture_output=True, cwd=ROOT / "bin", text=True)
self.assertEqual(ran.returncode, 0, ran.stdout + ran.stderr)
+16
View File
@@ -0,0 +1,16 @@
"""The passes of larv-review, as skills/larv-review/SKILL.md → "Passes" lists them."""
import typing
# A pass an agent under agents/ reviews, in lower case. A Literal cannot be built from `PASS_AGENTS`, so test_review_passes holds the two together.
ReviewedPass = typing.Literal["architecture", "principles", "overrides", "stability", "product-owner", "prose"]
# Each pass in the order of SKILL.md's pass table, and the agent under agents/ that reviews it; None where a skill or plugin does. The auto-reviewer is left out: larv-review counts its rounds from its reviews on the PR, not from commit titles.
PASS_AGENTS: dict[str, str | None] = {"architecture": "systems-architect", "principles": "principles-auditor", "full scan": None, "security": None, "overrides": "override-reviewer", "stability": "stability-reviewer", "product-owner": "product-owner-reviewer", "prose": "prose-reviewer"}
PASSES = tuple(PASS_AGENTS)
def _reviewed(name: str) -> typing.TypeGuard[ReviewedPass]:
return name in typing.get_args(ReviewedPass)
# The passes that have an agent. A pass missing from `ReviewedPass` drops out of it, which test_review_passes fails on.
REVIEWERS: dict[ReviewedPass, str] = {name: agent for name, agent in PASS_AGENTS.items() if agent and _reviewed(name)}
+2 -1
View File
@@ -47,9 +47,10 @@ from loop_claude.effects import Effects
from failure import Failure
from rung_replay.search import first_reply, replayed
from claude_code.transcript import first_timestamped_line, read_transcript
from model_routing.ladder import LADDER, project_rung, ReviewedPass, REVIEWERS, Rung
from model_routing.ladder import LADDER, project_rung, Rung
from claude_code.entries import parse_entry, structured_output
from review_folder import REPORTS, review_folder
from review_passes import ReviewedPass, REVIEWERS
TOOL = "review-replay"
USAGE = f"{TOOL} <pass> <model>, <pass> one of {', '.join(REVIEWERS)} and <model> a model on the routing ladder"
+2 -1
View File
@@ -19,7 +19,8 @@ from loop_claude.effects import Effects, system_effects
from failure import Failure
from review_replay import main
from rung_replay.search import Miss, Replay, Tried
from model_routing.ladder import REVIEWERS, Rung
from review_passes import REVIEWERS
from model_routing.ladder import Rung
TOOL = pathlib.Path(__file__).resolve().parents[1] / "review-replay"
REFERENCE = Rung("claude-opus-5-5", "medium")
+2 -1
View File
@@ -1,8 +1,9 @@
"""The titles of larv-review's round commits, `Answer <pass> round <n>: <k> 🔴, <m> 🟡; <summary>`: each pass's round count, and the findings the rounds reported."""
import re
from review_passes import PASSES
CAP = 3
PASSES = ("architecture", "principles", "full scan", "security", "overrides", "stability", "product-owner", "prose")
ROUND = re.compile(r"^Answer (.+?) round ([0-9]+):", re.IGNORECASE)
# What follows a round title's colon: the round's 🔴 and 🟡 counts, then `;` and its summary, if any.
FINDINGS = re.compile(r" ([0-9]+) 🔴, ([0-9]+) 🟡(?:;|$)")
+2 -1
View File
@@ -4,7 +4,8 @@ import typing
from rule_hook.rules import Breach
from rule_hook.call import Call, text
from model_routing.worker_rungs import handed
from model_routing.ladder import position, review_rungs, REVIEWERS, ReviewKind, Rung
from model_routing.ladder import position, review_rungs, ReviewKind, Rung
from review_passes import REVIEWERS
# The pass each agent under agents/ reviews.
PASS_OF = {agent: kind for kind, agent in REVIEWERS.items()}
+18
View File
@@ -0,0 +1,18 @@
import pathlib
import sys
import typing
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
from review_passes import PASS_AGENTS, PASSES, ReviewedPass, REVIEWERS
class ReviewPasses(unittest.TestCase):
def test_names_each_pass_that_has_an_agent_once_in_the_literal_and_in_the_list(self):
self.assertEqual(list(REVIEWERS), list(typing.get_args(ReviewedPass)))
self.assertEqual(list(REVIEWERS), [name for name in PASSES if PASS_AGENTS[name]])
def test_names_each_agent_under_agents(self):
agents = pathlib.Path(__file__).resolve().parents[1] / "agents"
self.assertEqual(sorted(REVIEWERS.values()), sorted(path.stem for path in agents.glob("*.md")))
+30
View File
@@ -2486,3 +2486,33 @@ Inherited architect, decided by:
- Navigation: `skills/larv-review/SKILL.md:86` "What a round reviews": a named paragraph beside Re-entry, where a reader asking what round 2 looked at searches
- Locality: `.gitattributes:1` the settings filter: committed behaviour depends on an untracked per-machine git setting, and README's Install and Update steps work only in order
- Self-sufficiency: `bin/settings_filter.py:2` module docstring: the script stands alone, but cannot say it is inert unless Install's git config line ran
## 2026-10-22T18:56:17Z, PR #354 at 7042a75, against 6f58a0e5c25f37026c50b1dde77612464be26803
Ruling: better
| Seat | Navigation | Locality | Shape | Self-sufficiency | Overall |
|---|---|---|---|---|---|
| Mid A | better | better | same | better | better |
| Inherited architect | better | better | same | better | better |
Mid A, decided by:
- Navigation, Locality: `bin/review_passes.py:7` `PASS_AGENTS`: the pass names lived in two files, one of them the routing ladder where nobody would look; one module named for its contents holds both now
- Navigation, Self-sufficiency: `bin/loop_claude/loop/main.py:53` `Routing: the worker's rung`: the 70-line routing paragraph is now headed parts a reader jumps to
- Navigation, Self-sufficiency: `bin/transcript_archive/__init__.py:1` "transcript_archive": the archive's file layout sits with the code that writes it, in place of loop-claude's help
- Locality: `bin/larv_review/plan.py:32` `landed_towards`: the next release is asked of `chunk_pick`, so the rule is written once
- Self-sufficiency: `bin/shell_command.py:33` `segments`: the new docstring lists each shell form it does not parse
- Self-sufficiency: `bin/git_repo.py:3` "git_repo": the module docstring says every tool starts git through it
Inherited architect, decided by:
- Navigation, Locality: `bin/review_passes.py:7` `PASS_AGENTS`: two unlinked pass lists became one table in a module named for it, so adding a pass is a single edit
- Locality: `bin/larv_review/plan.py:32` `landed_towards`: it reuses `chunk_pick`'s rule in place of its own, so the scoring-run trigger and chunk-preflight cannot disagree about the next release
- Locality: `bin/larv_review/ruling.py:38` `surplus`: the surplus-seat check is a named predicate called where the ruling is recorded, not hidden in `votes`
- Navigation: `bin/loop_claude/loop/main.py:53` `Routing: the worker's rung`: seven headed sections replace one 50-line routing paragraph
- Self-sufficiency: `bin/shell_command.py:33` `segments`: the docstring answers why rule-hook missed a git call
- Self-sufficiency: `bin/rule_hook/override_log.py:36` `this_chunks`: the case list maps each commit shape to its one-line return
- Self-sufficiency: `bin/larv_review/main.py:34` "larv-review --help": the help no longer states when work has landed, and points to `plan.py` instead
- Locality: `bin/score_outcomes/main.py:134` `read_outcomes`: whether a commit joins the chunk above depends on the previous iteration's state, with a positional `Chunk` tuple
- Locality: `bin/todo_table.py:137` `NoItemsTable`: every caller must test it before `Failure`, and swapping the checks silently changes the message
+9
View File
@@ -778,3 +778,12 @@ Read most (opens and searches):
## Reading cost, chunk 796f17403d2e, finished 2026-10-22T17:58:21Z
122986 new input tokens before the first commit.
## Reading cost, chunk a91c10247935, finished 2026-10-22T18:13:46Z
183925 new input tokens before the first commit.
Read most (opens and searches):
- `skills/larv-review/SKILL.md` 3
- `rules/todo-items.md` 2
+6 -6
View File
@@ -6,13 +6,12 @@
`Bar = 0.1`
`Next ID = 216`
`Next ID = 217`
## Items
| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 121 | 0.4.0 | | | **List larv-review's passes in one place that `round_titles.PASSES`, `ladder.ReviewedPass` and `ladder.REVIEWERS` derive from, and check larv-review §3's table against it.** | 2 | 1 | 3 | 4 | 3 | code health by 9 | 40.4 |
| 213 | 0.4.0 | | | **Compute the next release, and whether work has landed towards it, in one function that both `chunk_pick.standing` and `larv_review/plan.py`'s `scoring_run_due` call.** | 3 | 2 | 3 | 6 | 3 | code health by 9 | 40.4 |
| 137 | 0.4.0 | | | **Archive a chunk's route as a record loop-claude reads back field by field, in place of the `Worker:` prose `ROUTED` parses, and name `stepped` and the judge's `bundled` by what they do.** | 4 | 2 | 3 | 7 | 4 | code health by 9, 1.4 by 9 | 32.9 |
| 211 | 0.4.0 | | | **State each routing rule once, in the docstring of the code that enforces it, and cut `loop-claude --help`'s routing paragraph to what the human running the loop needs.** | 2 | 2 | 1 | 3 | 4 | code health by 9, 1.4 by 9 | 32.9 |
@@ -22,6 +21,7 @@
| 210 | 0.4.0 | | | **Hold the escalation mark in one module that states that one trigger buys one step, so a reader changes it without opening four files.** | 3 | 2 | 3 | 6 | 5 | code health by 9 | 16.2 |
| 190 | 0.4.0 | | | **Rewrite the `docs/decisions.md` entries `todo.md: one table …`, `loop-claude: a judge decides …` and `loop-claude: before it opens claude …` as the current state, so a reader no longer replays superseded paragraphs to learn what holds.** | 2 | 2 | 1 | 3 | 3 | code health by 3, 1.4 by 2 | 15.5 |
| 82 | 0.4.0 | | principle | **Sort `AGENTS.md`'s decision titles and `docs/decisions.md`'s entries by title.** | 2 | 2 | 1 | 3 | 4 | code health by 4, 1.4 by 4 | 14.6 |
| 216 | 0.4.0 | | | **Make larv-review's round count agree with itself on the auto-reviewer: either title its round commits so `round-count` counts them as a pass, or have SKILL.md say they carry no `Answer <pass> round` title.** | 1 | 2 | 3 | 4 | 2 | code health by 2 | 12.0 |
| 170 | 0.4.0 | | decision | **Re-tune `WORKER_STEPS` and `REVIEW_STEPS` once 10 chunks have shipped under them, from how well L, E and I order their review rounds and 🔴 findings.** | 2 | 2 | 3 | 5 | 2 | 1.1 by 3, 1.4 by 5 | 10.9 |
| 125 | 0.4.0 | | decision | **Give "record", "outcome" and "places" one meaning each across `bin/`, and rename `bin/larv_review/git.py` by what it holds.** | 3 | 1 | 3 | 5 | 5 | code health by 5, 1.4 by 3 | 10.2 |
| 198 | 0.4.0 | | decision | **Count, per finished chunk, the findings that arose from misreading code that had already shipped, so code health's counter-signal shows.** | 3 | 2 | 2 | 5 | 5 | code health by 3, 1.1 by 2 | 6.2 |
@@ -77,10 +77,6 @@
## Details
### 121. List larv-review's passes in one place that `round_titles.PASSES`, `ladder.ReviewedPass` and `ladder.REVIEWERS` derive from, and check larv-review §3's table against it.
Release 0.3.0's inherited architect (PR #324 rerun at c713910) named `bin/round_titles.py:5` `PASSES`: "the pass list lives in four places, PASSES, ladder.ReviewedPass, REVIEWERS and SKILL.md's table, kept in sync by hand". That lowers Locality: adding a pass means editing four places. PR #257's run found that `PASSES` repeats the pass list in `skills/larv-review/SKILL.md:33`, with no check tying the two. It leaves out the auto-reviewer, whose rounds `SKILL.md:68` counts by hand. A test under `bin/repo_checks/` can hold the table to the list. Make `PASSES` easier to read.
### 213. Compute the next release, and whether work has landed towards it, in one function that both `chunk_pick.standing` and `larv_review/plan.py`'s `scoring_run_due` call.
Release 0.3.0's scoring runs named `bin/chunk_pick.py:97` `standing` at three seats (first run: PR #324 at c713910; rerun: PR #324 rerun at c713910). Inherited architect, first run: "'next release' is computed two ways, here and in larv_review/plan.py's scoring_run_due, which may diverge after a rename". Junior A, rerun: "two separate notions of the next release and of work having landed". This lowers Locality: changing what the next release is means changing both places, which may diverge. The seats also found `standing` itself hard: "five inputs, three of which may be Failure, produce five outcomes, the order of the Failure checks carrying meaning" (Maintainability senior, rerun), and `chunk_pick.Finished` "shares its name with judge.Finished" (Junior A, first run). Rename `chunk_pick.Finished`. Make `standing` and `scoring_run_due` easier to read.
@@ -117,6 +113,10 @@ Found by the prose review of PR #312, which judged both entries to read as amend
"Deterministic order", in `principles/technical-principles.md`, raised by the principles audit of PR #224: their order carries no meaning, so two chunks adding a decision conflict at the end, and a reader cannot find a title by scanning.
### 216. Make larv-review's round count agree with itself on the auto-reviewer: either title its round commits so `round-count` counts them as a pass, or have SKILL.md say they carry no `Answer <pass> round` title.
`skills/larv-review/SKILL.md` §3 "Round cap" makes the external auto-reviewer a pass of its own and each review it posts a round, and says each round closes with a commit titled `Answer <pass> round <n>: <k> 🔴, <m> 🟡; …`. It also says the auto-reviewer's count is the number of its reviews on the PR. `larv-review round-count` (`bin/larv_review/main.py` `round_count`) answers an `Answer auto-reviewer round <n>:` commit with "auto-reviewer: <n>, not a pass: check the commit title", because `bin/review_passes.py` `PASSES`, the list `bin/repo_checks/test_reviewer_launches.py` holds SKILL.md's table to, leaves it out on purpose. A worker who follows the skill therefore gets a warning. Found by round 2 of PR #354's principles pass (item 121).
### 170. Re-tune `WORKER_STEPS` and `REVIEW_STEPS` once 10 chunks have shipped under them, from how well L, E and I order their review rounds and 🔴 findings.
`docs/decisions.md` → `routing: one ladder…` calls the steps lilleman approved on 2026-10-16 a first guess. Once 10 chunks that each shipped one item scored with L, E and I have merged, read `score-outcomes`' rank correlations for L, E and I and the routed-chunks table of `routing-figures.md`, and propose new steps to lilleman, whose call they are. Only chunks merged since PR #339 set today's steps count: 7 so far, those of items 117, 126, 131, 122, 207, 130 and 154. Start this item when there are 10.