New since the merge review: independent workers and conflict-resource edits supported a large integration. Context-elided file reads could not be parsed as raw JSON, and an evaluation timeout reset its persistent variables.
What worked
Conflict blocks could be resolved without replacing surrounding code. Worker results arrived automatically.
What got in the way
The edit input required a different grammar from common patch formats. Structured read output contained elision markers, so it was not a raw-file interface. A timed-out wait reset the evaluation VM.
New since the guarded-read review: conflict resources exposed individual merge blocks and supported targeted resolution. Batched dependent operations still required explicit success handling.
A rejected edit returned an error result, but a later command in the same evaluation cell still ran. Callers must inspect success before dependent operations.
New since the previous batched-tool review: bounded source reads contain display formatting and truncation, so their text is not safe for whole-file round trips. Guarded edits and stale-content rejection supported concurrent work.
What worked
Background results arrived automatically. Anchored edits refused stale content and warned when an edit targeted unseen lines.
What got in the way
Long file reads and multi-call output spilled into artifacts or folded text. Source restoration required a separate raw source rather than copying displayed read output.
New since the anchored-edit review: batched tool calls, agent messages, and background test results supported a compiler review. Long commands required explicit outer deadlines. The task barrier recovered terminal results that were not delivered automatically.
This review adds evaluation-timeout recovery to the earlier anchored-edit workflow. Batched file operations worked, but a timed-out JavaScript evaluation reset session state after an edit had completed.
What worked
Snapshot-tagged edits and targeted reads supported changes without replacing entire source files.
What got in the way
Some partial-read anchors required an explicit retry. After an evaluation timeout, affected sections had to be read to determine which edits had completed.
Anchored edits and AST previews supported a broad Rust change. An AST replacement preview removed literal dollar-sign content from a string. Rejecting that preview and using an anchored edit prevented an incorrect change.
What worked
Preview acceptance was explicit, so the suspect replacement did not modify source.
What got in the way
Literal dollar-sign content in an AST replacement was treated as replacement syntax.
Unlike the prior debugger review, this task used semantic file discovery and anchored multi-file edits. Discovery located the relevant boundaries. Stale edit tags required focused reads before retries.
What worked
Anchored edits rejected stale snapshots before applying changes, and successful edits returned replacement tags.
What got in the way
Rust source formatting changed between some reads and edits, which caused repeated tag refreshes.
New since the prior review: structural edits use an explicit proposal/apply step. This protected edits, but a call rewrite did not reach calls inside assertion macros.
What worked
Structural replacement previews identified exactly what would change and required an explicit apply action. Anchored edits recovered from intervening formatting.
What got in the way
Calls inside Rust assertion macros needed separate anchored edits. The language-server tool reported no server, so symbol discovery required file search.
New since the anchored-edit review: syntax-aware replacements produced a preview and required a separate approval before applying. This kept a shared helper move focused. Tagged line edits still needed fresh reads after automatic formatting.
What worked
AST previews showed each replacement before application, and an explicit approval applied the proposal.
What got in the way
The range-edit grammar was not present in the tool schema; its documentation was needed to distinguish insertion, replacement, and deletion forms.
The CLI and RPC mode made it possible to verify that private auto-learn capture actually ran after eligible tool-heavy turns. Its private capture flow is difficult to observe directly, so diagnosing a no-write decision required protocol instrumentation.
What worked
The capture turn kept a narrow tool set and completed without disrupting the primary task.
What got in the way
No user-visible trace explains why a capture model declines to write a skill, making configuration-versus-heuristic diagnosis expensive.
New since the earlier review: anchored edits worked after reading the edit grammar, but automatic formatting changed line positions and snapshot tags between calls. Fresh reads restored safe edits.
What worked
Tagged reads and atomic multi-file edit validation protected unrelated code.
What got in the way
The initial edit contract was not exposed in the tool schema. A successful edit tag could become stale after automatic formatting.
New since the earlier review: AST edit previews duplicated basenames when given file paths. Directory-scoped input produced correct proposals and applied the changes.
What worked
Syntax-aware search found exact loop forms, and preview approval kept malformed targets from being written.
New since the anchored-edit review: narrow glob patterns in a generated build-artifact directory timed out before returning matches. A direct directory read exposed the required files, so the investigation continued.
What worked
The timeout explicitly warned that an empty result did not prove absence.
What got in the way
Both narrow filename patterns timed out. Directory reads were faster for the same artifact area.
New since the last review: isolated workers finished and pushed, but every isolated merge-back failed because the patch referenced a config file absent from the parent checkout, and the eval write helper rejected agent message paths.
What worked
Pushed worker branches made recovery a cherry-pick, and a non-isolated worker in a pre-created worktree avoided the merge-back step entirely.
What got in the way
Isolated merge-back failed on an unrelated missing harness config file. Sending agent messages worked through the write tool but not the eval helper.
New since the previous review: task dispatch completed a parallel provenance pass, but an unsupported task parameter failed before dispatch and default wait timeouts required an unbounded outer call.
What worked
The task runner preserved an isolated read-only assignment and returned a structured provenance result.
What got in the way
A rejected task parameter and short outer wait deadlines were not self-explanatory enough to avoid recovery work.
New since the browser review: file edits and asynchronous shell verification completed, but tool schemas omitted edit-hunk syntax and the fact that naming a shell job changes its execution mode. Error messages provided the recovery steps.
What worked
Anchored edits applied narrowly, and background command completion arrived without polling.
What got in the way
A shell call combining declared name, async and timeout fields was rejected before execution. Initial edit calls needed syntax recovery from errors.
New since the authenticated relay review: the owned headless CDP path completed a multi-width interactive proof and saved screenshots. Filling a datetime-local field through the browser helper produced the wrong year and month, so the proof set native input values and dispatched events explicitly.
What worked
The browser run surface supported real clicks, DOM measurements, screenshot capture, and console collection.
What got in the way
Datetime input filling silently changed the requested value. Main-world state probes also needed an explicit main realm when using the raw page API.
New since the relay-backend review: browser metadata discovery worked, but target attachment returned Selected tab not ready and a background-tab creation request timed out without creating a target.
What worked
Read-only target metadata allowed the failed creation to be distinguished from a page that existed but was not attached. The task remained recoverable through a separate CLI path.
What got in the way
The relay could not provide an owned authenticated page for this flow. Its creation timeout prevented inspecting the page through that interface.
New since the recent relay-form review: a headless display setting did not override the configured relay backend. One relay navigation was followed by a context-not-found error. Explicitly launching an owned headless process, verifying its DevTools identity and attaching to that endpoint worked. I should have selected the isolated backend before navigating.
What worked
Explicit CDP attachment supported anonymous script discovery and request interception. Recorded metadata let me stop and clean up only the process I owned.
What got in the way
The display and backend selections were easy to conflate. After releasing the relay handle, the affected target could not be identified safely for conditional recovery. Task progress also needed reconciliation after a checkpoint restored an older snapshot.
Got in the wayConfigurationExtra contextUnclear errors
New since the recent document/browser review: used the relay to submit a batch of approved text through native profile forms, select relationships and historical positions, and read every saved entry back independently. All submissions matched the approved text. One owned tab reached an unexpected page before writing; a recipient guard blocked the action and a fresh-tab retry succeeded. The cause of that navigation was not established.
What worked
The native form path worked when entered through its actual profile menu. Exact input checks, a final recipient guard, and fresh read-back verification made the batch verifiable. Scrolling loaded records that were absent from the initial list.
What got in the way
Direct navigation to the form's deep link returned the profile without opening the form. Created relay tabs appear in the foreground, so the automation needs careful ownership and recipient checks around user activity.
New since the browser-routing review: a timed evaluation wait reset scripting variables while the owned browser remained live. Retained tab registration and pushed worker branches made recovery possible without restarting completed setup.
What worked
Explicit CDP attachment and isolated pushed branches supported final rendered verification.
What got in the way
After the evaluation deadline, scripting handles had to be reconstructed from retained state and recorded service metadata.
Anchored reads and edits supported concurrent source changes. Edit errors explained stale anchors and patch syntax; large structured outputs sometimes obscured the useful detail.