Nineteen of twenty-six tasks beheaded
On 27 July 2026 two tasks stalled and nineteen others never ran. Every rule involved made sense on its own. Together the rules left the run one legal move, and another rule forbade the move. The run was analysing a larg
On 27 July 2026 two tasks stalled and nineteen others never ran. Every rule involved made sense on its own. Together the rules left the run one legal move, and another rule forbade the move.
The run was analysing a large Java codebase with a plan of twenty-six tasks. Early tasks inspected modules. Later tasks depended on the inspections, and sixteen of those were ready to change code.
The model had been pointed at two modules following the Maven layout, modules/name/src/main/java, and assumed every module did the same. Three siblings did not. Four lookups across the whole session came back not found. Four wrong guesses should cost four failed lookups. Here the guesses cost two whole tasks, because of how three other parts of Merlin answered them.
My executor ran each program of operations as one unit and aborted the whole program on a bad path. The correct lookups in the same batch never ran, so every wrong guess took its correct neighbours down too.
My loop detector compared errors by code alone. Three not-found errors on three different paths looked like one error repeated three times. One task was declared stalled on its first error of its own, charged with errors from other paths and from the task before.
Both inspection tasks ended completed but carrying a blocking residue. My scheduler never re-serves a completed task, and the dependents waited for the residue to clear. Nothing was ever going to clear the residue. The run had been handed a transfer to a train no longer running. Nineteen of twenty-six tasks became unreachable, all sixteen code-changing tasks among them.
Then the endgame. The model asked to revise the plan and was refused, because the plan's dependencies were locked. The one step the executor still allowed was an honest incomplete report. The final-answer gate rejected every such report and demanded the unfinished changes continue, changes no scheduler would ever serve. The run died at iteration 36 on the limit for rejected operations. Four departments, each following procedure, and a citizen standing in the lobby with no form left to fill in.
I fixed each link the same day. A bad path now fails only the operation naming the path, and the rest of the batch runs. The loop detector compares the full error, code and message, and charges each error to the operation producing the error. A completed dependency releases its dependents even with a residue, and the residue travels with them as a stated fact: upstream evidence for this task is incomplete. And the final gate demands more work only when some task carrying the work is reachable. When the executor allows only an incomplete report, the gate must accept the report.
The sentence from my record I keep coming back to: one stalled task must cost itself, not the plan's tail.
The test: list the moves your system still allows when a run goes wrong, then check every gate against the list. When one part permits only the move another part forbids, the run has no exit, and no amount of model intelligence finds one.
Source: Spec 002, AC-002-009-08 and AC-002-009-09, and Spec 008, AC-008-003-02 and AC-008-003b-12, all written 27 July 2026. The run's logs have aged out of my log store.
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.