Skip to content

fix: a landing refusal carries the text the next call needs - #150

Merged
rodrigoteamx merged 13 commits into
mainfrom
hp/greenhouse/t-0092-a-landing-refusal-carries-the-next-call
Oct 8, 2026
Merged

rodrigoteamx merged 13 commits into
mainfrom
hp/greenhouse/t-0092-a-landing-refusal-carries-the-next-call

Conversation

@rodrigoteamx

@rodrigoteamx rodrigoteamx commented Oct 8, 2026 •

Copy link
Copy Markdown
Contributor

It came stacked on #149, which stacked on #148; both are in main now. This one's base is main, with main merged in — against it, it changes its own four files.

What

Four refusals of implement and edit are about the text itself. Each now carries the text the next call is written from.

the refusal before now
a body with a syntax error one line: the line number where the parser stopped that, and the proposal's own lines there — the line, the three before it, the one after; the line a bracket was opened on when the parser names one
a body that parses and does not compile (php -l, the check after the parser) what the check printed: a line number inside a sentence that, and the proposal's own lines around the line it names
an edit whose text is not there the find, and the whole file that, and where it stops matching: the line, how the file reads there, how the find reads there — and the file's own lines over that stretch, as the find that matches
an edit whose text is there more than once a count that, and the lines it sits on, with their text

Nothing is taken away: the first sentence of each refusal, the whole text, and diagnostic.result are what they were.

Why

Measured on session ledgers of real residents (greenhouse evidence/1162). The parser names the line where it gave up, not the line of the mistake — a missing semicolon is reported two lines down — and beside the refusal the house tells the builder to repair its proposal with exact find and replace pairs. There was no text to copy a pair from.

  • In one run the builder obeyed: its edit of the recorded proposal did not find its text, the next edit did not either, and no body ever landed — 1,240 of the run's 1,414 seconds.
  • In another it sent the whole file again each time: it landed, about three minutes later each time.
  • Six syntax refusals in five runs; each was answered with a line and no text.

How it was checked

  • 25 tests, 20 of them red before the code. Suite: 877.
  • 42 hand mutants, all killed.
  • Cost. Two of the tests time the answer on a long file. An earlier state of this branch answered a refused edit in 22 s on 8,000 lines; it is 0.8 ms now.
  • Walked without a model on a house built from this branch: the three refusals are provoked, and the proposal the house recorded is then repaired with one exact pair copied from the lines shown. It lands, and the operation it leaves runs.

Not in this change

  • The hint the house puts beside a syntax refusal (app-runtime) is unchanged.
  • Whether a real resident uses the lines shown is not measured yet. Three runs with a resident ran on a house carrying the first three refusals; none of them met one. The compile check refused a body in two of them, which that house did not yet rewrite — it is how that door was found.
  • The compile check's refusal still carries no diagnostic, so the house puts no repair hint beside it and its proposal cannot be repaired by edit.
  • The most frequent refusal in the lab's record is static analysis, not these three.

…plugin's only entity by default, and judged when the code lands (greenhouse evidence/1154)
…on works through

Three real residents out of three, with their operations scaffolded, spent their next fourteen to
seventeen calls to the model finding out how a test gets the repository run() receives; one never
found it and filled no body (greenhouse evidence/1156). The judge's scaffold was a bare TestCase.

When the class judged is an operation of the plugin, its judge now builds the repository its plugin
hands run() — in memory — and shows the call the house makes, with a value for each required input.
It still fails on purpose. What is not an operation, or does not exist yet, gets the judge it always
got, byte for byte.

The generator reads the operation's source and its plugin's entry; it loads nothing.
… them

A resident wrote one judge for its plugin's whole cycle and named it after one operation. That
operation's body was refused three times as «judged red by its own test» and the run ended with it
still a scaffold: the judge called the plugin's other operations, which in that copy of the house
were scaffolds (greenhouse evidence/1156). The refusal showed ten lines of phpunit.

The house wrote those scaffolds and reads that they are unfilled from the sentence they answer
with. A behavior refusal now names the unfilled operations its judge names — by class or by the
operation they declare — and gives the order: fill and promote those, then send the same implement
again. A judge red over no scaffold is told nothing new.
…hat only contain a scaffold's

Four tests written after the code, for hand mutants that survived or that I expected to: the judge
holds one repository and shows a second one missing; a class under Operations/ that is not an
operation gets the bare judge; a name that starts or ends like a scaffold's is another name; a
filled body that quotes another class's scaffold sentence is still filled. glob() already sorts.
…lder's own lines, where an edit stops matching, the lines an ambiguous text sits on

Three refusals are about the text itself, and each said something was wrong without the words to
put it right (greenhouse evidence/1162). In runs with a real resident a body refused for syntax was
answered with one line number — beside the house's hint to repair the proposal with exact find and
replace pairs. In one run the edit of that proposal did not find its text, the next edit did not
either, and no body landed: 1,240 of the run's 1,414 seconds. In another the resident sent the whole
file again each time: it landed, about three minutes later each time.

- Syntax: the refusal shows the proposal's own lines where the parser stopped — that line, the
  three before it and the one after, and the line a bracket was opened on when the parser names one.
  The parser stops after the mistake, not on it. After the gutter each line is the proposal's, byte
  for byte: it is what a find is copied from.
- An edit whose text is not there: where it stops matching — the line, how the text reads there,
  how the find reads there — and the text's own lines over that stretch, handed over as the find
  that matches, only when they sit in the text once. When only spacing parts the two, it says so. A
  later pair is told it was judged against the text the earlier ones left.
- An edit whose text is there more than once: the lines it sits on.
- A body the parser reads and the compile check refuses — a void function that returns a value, a
  method declared twice: the same lines around the line the check names. A resident met that door
  on a house that carried the rest of this: 300 characters, a line number, no text.

Nothing is taken away: the first sentence of each, the whole text, and the finding the diagnostic
carries are what they were. And an answer costs what the stretch it speaks of costs, not what the
file does: two tests time it on a long file.
…sion says of it

PHP 8.3 prints «A void function must not return a value» and 8.4 «A void method must not return a
value». The test quoted the first; it asks now only for what both say. The refusal itself was right
on both: the check's own words travel whole, whatever they are.
@rodrigoteamx
rodrigoteamx changed the base branch from hp/greenhouse/t-0092-a-judges-scaffold-holds-what-it-judges to main October 8, 2026 21:51
@rodrigoteamx
rodrigoteamx merged commit e6e96fa into main Oct 8, 2026
2 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant