fix(write-to-file): tear down per-task stream state on parse failure and dispose (split 5/6 of #1066, unit U6b) - #2434

Unit U6b of the split of #1066. Plan: #1937 (comment) . Chain map: #1989.

Depends on #1932 (unit U6a, head d71db6a, tree cbd6105bd86f276bd90ff02218928056f0573dc6, branch p1066/u6-execute-error-path-cleanup, refreshed again by lane s3-1395 on 2026-11-12 -- before that refresh the dependency head was d52c161 and both coordinates had been refreshed by lane u9-1917 on the same day, the predecessor replayed from e80d192 onto main tip efc22ed and this branch replayed from 6221bfb onto it with its unit blobs byte-identical, each push lease-pinned to a fresh ls-remote read). This branch is stacked on that head and must merge after it, in the merge order named on #1932: U3 #1931, U4 #1929, U5 #1930, U6a #1932, U6b, then U7 #1928.

Read this delta against its own base

While #1932 is open, GitHub shows this pull against main as the cumulative chain view: 474 counted executable lines, 172 selectors and 430 instrumented mutants against main tip efc22ed, which after the refresh is also the merge-base of both heads with main. That number is the chain, not this unit, and I report it as advisory. The gate-relevant delta of this unit is measured against its own base, the U6a head:

The two rows above were re-priced on 2026-11-12 by lane u9-1917, at lead's commission, against the head this branch now carries after this lane refreshed it: p1066/u6b-tool-stream-teardown = 725b8a3 (tree 4f2ee3d9f1813835b38f4bd385a8bc15d25bc557), whose own parent is the refreshed U6a head d52c161 (tree ff020f7a4a16521b6db6e148fbed73ffbb48651f) on p1066/u6-execute-error-path-cleanup. The refresh replayed this branch's own commit onto the head the transport reported for the branch its body names as its predecessor, read from ls-remote rather than from any body, and replayed that predecessor onto main tip efc22ed in front of it; no content moved, because all eight blobs this unit carries are byte-identical across the replay, read off 6221bfb and off 725b8a3 - WriteToFileTool.ts e429d1f35feff596d7a5ffda01cd44234f54dc12, writeToFileTool.spec.ts 25d6e407bc1cd037ed80f28cf592e7458bfac15c, writeToFileTool-partial-state-cleanup.spec.ts 6fd8ba202f7701e2509b25c7e3655bb093f9a80c, BaseTool.ts 827011fba0d538e248dcc732346d6c0adfc83ee8, ClineProvider.ts aa4cab38ed43dadd959f99f7ca162034502c01b4, DiffViewProvider.ts e5c41ea53fa5bc90b0f7a0b249645b310cdfda20, removeClineFromStack-delegation.spec.ts e032f74dc48bd5de46ea568bbbe79639a318b0a6 and src/eslint-suppressions.json 1f419bc2b2476860bd19cfd55b09bc12e436876a - which is why both rows keep the numbers the earlier correction printed and only the base and head coordinates move. Each push was lease-pinned to this lane's own fresh ls-remote read of the ref it replaced (unit U6b to 6221bfb, unit U6a to e80d192), ran with the husky hooks enabled and nothing skipped with --no-verify, and was read back off the transport afterwards. The rows the earlier correction replaced priced 27465f8, which has been replaced four times now, each successor a fresh child of the then-current U6a head rather than a descendant of its predecessor, read off each commit's own parent: 27465f8 gave way to f673949, whose parent is e6a1551, then 4f78a81, whose parent is 0774d46, then 6221bfb, whose parent was the U6a head e80d192, and then this lane's replay of that same commit onto d52c161. None of those superseded coordinates is an ancestor of anything these branches carry. Lines and selectors come from selectFromGit of scripts/stryker-diff.mjs at blob 7dfe0006d2d5, byte-identical at every head named here including main tip efc22ed, with the pricing worktree checked out at the priced head; efc22ed is now the merge-base of both refreshed heads with main, so the chain row measures what GitHub renders for this pull while #1932 is open. Mutants are the instrumenter line of a Stryker 10 --force --dryRunOnly preflight over the identical selector list, cwd /src against that head's own committed stryker.config.mjs (blob 7d85640377ba at every head named here), with STRYKER_VITEST_CONFIG=vitest.core.config.ts and STRYKER_IN_PLACE=false, run against the test files vitest related reported for that head (1 for the provider unit, 109 for the tool-side shape being replaced, 111 for the tool-side shape that ships at both of its heads) and, for the replaced shapes, once more with lane f0-1528's plumbing, STRYKER_VITEST_RELATED=true with STRYKER_TEST_FILES=[], which returned the same 182, 248 and 430 for the three shapes, so a count is not moved by the test-file plumbing because instrumentation happens before any test runs. Re-measured at the refreshed head with the same instrument: 266 lines, 102 selectors and 248 instrumented mutants against d52c161, and 474, 172 and 430 for the chain top against efc22ed, so no number in either row moved. Selection advisories were 0 in every run reported on this line. What cannot be measured here: unit U6b yields a mutant count and not a mutation score, because its preflight's initial test run over the 111 related test files timed out at Stryker's 300 second dry-run timeout on a lockfile-matched install of its own (pnpm install --frozen-lockfile in a worktree that had no node_modules, not a junction into a shared donor); the provider unit, measured on the same footing, did complete and reports 130 killed, 2 timed out, 44 survived and 6 not covered out of its 182, which is a breakdown this lane did not have before and does not belong to this unit. The gates of the head this branch now carries, on that footing, read eslint --max-warnings=0 --prune-suppressions exit 0 over the seven changed files with no suppression count moved (the prune rewrote the indentation of src/eslint-suppressions.json and was reverted so the committed copy stayed byte-identical), 116 passing and 5 skipped across writeToFileTool.spec.ts, writeToFileTool-partial-state-cleanup.spec.ts and removeClineFromStack-delegation.spec.ts, tsc --noEmit -p tsconfig.json exit 0 and knip --treat-config-hints-as-errors exit 0. Controls, same instrument and same method at the priced-out head, reproduce both replaced rows exactly: 243 lines, 95 selectors and 227 instrumented mutants for 3c5036a -> 27465f8, and 450, 163 and 410 for 53cb5b5 -> 27465f8. Against the caps: the unit shape 266 of 500 lines and 248 of 400 mutants, and the cumulative shape 474 of 500 lines against 500 but 430 mutants against 400, so the chain view a merge after #1932 renders sits 26 lines inside the line cap and 30 instrumented mutants outside the mutant cap, which is the figure the merge order above leans on. Two statements further down keep the figures of the shape that was priced out, because this correction touches the table, the sentences that quote it and the dependency head in the line above, and nothing else: the density sentence quotes 2.52 instrumented mutants per selector, 410 over 163, on 450 of 500 lines, where the chain now measures 2.50 per selector, 430 over 172, on 474 of 500 lines, and the gates section below reports its measurements at head 27465f8, which this table no longer prices. Nothing on this line is a CI reading.

Both halves sit under the caps (500 lines, 400 mutants) and the split is exactly additive: 208 + 266 = 474 lines, 70 + 102 = 172 selectors, 182 + 248 = 430 mutants. Figures are my measurement: the stock selector of the repo instrument scripts/stryker-diff.mjs (blob 7dfe0006d2d5) over the unit delta with the pricing worktree checked out at the priced head, plus a local Stryker 10 fast dry run (--force --dryRunOnly) on that identical selector list. Instrumented mutant counts are counts, not mutation scores: the Stryker 10 vitest runner does not resolve related tests in this repo, so each local run ends with No tests were executed, and CI runs its own mutation-diff leg. Why the split exists at all: the parent shape that ships once both halves merge, main -> 6221bfb, carries 2.50 instrumented mutants per selector (430 over 172) and so sits 30 mutants over the 400 mutant cap at 474 of 500 lines; the parent shape this chain replaced carried 2.52 per selector (410 over 163) and hit that cap at 450 of 500 lines, and that reading belongs to head 27465f8, which no branch ref of the fork carries. #2385 sat at 3.55 mutants per selector on 527 lines and crossed the line cap instead.

What this unit carries

• src/core/tools/BaseTool.ts -- a protected onParameterParseFailure seam (40 added lines) that lets a tool tear its own per-task state down when parameter parsing rejects, instead of leaving half-streamed state behind. This file belongs here rather than on fix(editor): release abandoned diff streams and owned placeholders (split 5/6 of #1066, unit U6a) #1932 because its blob at the old U6 head 1eabeca (827011fba0d5) is byte identical to the same file at U7 fix(write-to-file): clean partial state on missing-param and rooignore denial + integrate the #1066 split series (6/6 + FINAL) #1928 head 94f0925; keeping it out of fix(editor): release abandoned diff streams and owned placeholders (split 5/6 of #1066, unit U6a) #1932 is what brought that pull under the mutant cap.
• src/core/tools/WriteToFileTool.ts -- per-task partial stream state in a taskPartialStreamState map keyed per task, with getPartialStreamFailureKey, getTaskPartialStreamState, hasPathStabilizedForTask, isPartialStreamStillLive, resetTaskPartialState, clearTaskState, resetDiffViewAfterWrite, discardUnapprovedStreamBeforeReset, discardOwnedPlaceholderBeforeReset, reportPlaceholderStranded, finalizePartialToolAskAfterFailure, reportRevertFailure and cleanupFailedPartialStream (646 added lines at the head 6221bfb this pull carries now; 598 at head 27465f8, the head the corrected row above replaces), so a parse failure, a failed stream or a dispose releases the partial file, the placeholder and the open ask on every exit path.
• src/core/webview/ClineProvider.ts -- 6 added lines at the removeClineFromStack teardown (the hunk sits at line 732 of the merged file) hand the provider dispose path to the tool clearTaskState. Its blob at the old head, d4db11ff5dfe, is on no other unit branch head, so carrying it here keeps it in the chain.
• Tests: writeToFileTool.spec.ts grows from 19 it() blocks at the unit base e80d192 to 79 at 6221bfb (77 at head 27465f8), and it still reads 79 at the head this pull now carries, a1d9d24, counted the same way -- line openings of it(); bare occurrences of the characters it() read 80 at both heads, and the commit pushed today opens no new test, a new spec src/core/tools/tests/writeToFileTool-partial-state-cleanup.spec.ts adds 13 it() blocks at that head (11 at 27465f8, where the six cases named in parentheses were all present: release and deregister, no-op for a task that never streamed, log-and-continue on a failed diff reset, discard-while-recovery-state-exists, rollback hazard plus retained streaming error, silent when cleanup restored the editor), and src/tests/removeClineFromStack-delegation.spec.ts adds 1.
• src/eslint-suppressions.json -- the no-explicit-any count for writeToFileTool.spec.ts drops from 5 to 3 instead of being renewed, per the never-increase guidance in AGENTS.md; the file is otherwise byte-identical to HEAD.

Gates, as I measured them

All my measurement, on a junctioned worktree against a lockfile-matched install at main tip 53cb5b5, pnpm 10.8.1 on node 25.9.0 against a declared node 22.23.4, so pnpm prints an Unsupported engine warning on every run. Nothing here is CI-verified and no unit is reported green by me.

• Typecheck from the package directory (tsc --noEmit -p tsconfig.json, cwd src): exit 0, 0 errors at head 27465f8 and 0 errors again at the head 6221bfb this pull carries now.
• Repo-wide pnpm run format:check (prettier --check .): exit 0 at head 27465f8 and again at the head 6221bfb this pull carries now.
• Lint from the package directory (pnpm --dir src exec eslint --max-warnings=0 --no-warn-ignored over the six changed code files): exit 0 at head 27465f8 and at the head 6221bfb this pull carries now. At the head that ships I also ran eslint --prune-suppressions: 265 suppression entries before and 265 after, no file count changed, and I reverted the rewrite to the 30,910 B copy with sha256 beginning f264e5968e78ff75 that the head being replaced carried.
• The focused specs that carry the moved files (vitest run --globals core/tools/tests/writeToFileTool.spec.ts, core/tools/tests/writeToFileTool-partial-state-cleanup.spec.ts and tests/removeClineFromStack-delegation.spec.ts, cwd src): 3 files, 112 passed and 5 skipped of 117 at head 27465f8; at the head 6221bfb this pull carries now I ran the same specs in the two groups my run supports and recorded 92 passed and 5 skipped in 2 files for the writeToFileTool pair, and 143 passed for the provider spec together with the delegation spec.
• knip: exit 1 with 23 report lines at head 27465f8, and exit 1 with the same 23 lines at main tip; delta 0 added, 0 removed. Derived rather than inherited, and none of the findings name a file in this pull.
• The root aggregate pnpm run check-types exited 1 at head 27465f8 and identically at main tip on this host, because turbo prints Global config path not found once the root tsc leg has passed with 0 error lines; host state, not a delta of this unit. At the head 6221bfb this pull carries now I recorded the webview-ui check-types leg exiting 0 in the same gate run.
• Hooks enabled, never --no-verify: the commit ran lint-staged for real (per-package eslint --max-warnings=0, then prettier --write). For the push, the runner slot .husky/_/pre-push in this shared checkout holds the git-lfs stub rather than the husky dispatcher, so the check-types body of the hook did not run; I ran that command myself at head 27465f8 and recorded the result above.

CI

I have not read any CI state for 27465f8, and nothing in this body claims CI verification for it. For context on the posture the chain is being executed under: a red compile leg is not what CI reported for #1932 today -- another lane's on-disk posture read (2026-11-11T23:21:22Z at head 1eabeca, 22 contexts) names one failing check, webview-visual (check id 122373017189, an advisory visual leg), while compile, knip, e2e-mock, platform-unit-test on both runners, Build test VSIX and check-translations were green in that read. The ruleset for these branches lists seven required contexts, not six.

Re-cut at the head this pull now carries: the rows that move, the legs at that head, and the footing of every number

This section is the re-cut lane s3-1395 made on 2026-11-12 at lead's commission. Only coordinates and rows that move are replaced. The two rows it replaces were priced by lane u9-1917 on 2026-11-12 against 725b8a3 -- 266 lines, 102 selectors and 248 instrumented mutants against d52c161, and 474, 172 and 430 against efc22ed -- and those coordinates stay on the record in that lane's own sentences above, which are left standing as history rather than retracted. Likewise every sentence above that says "the head this pull carries now" and names 6221bfb or 27465f8: those measurements were taken at the heads they name, they are not re-pointed here, and the live coordinates are the ones in this section.

What moved, and what this lane ran locally

The branch p1066/u6b-tool-stream-teardown moved 725b8a3 to a1d9d24 (tree f6ab07444cd8ab740f065f204bedd3c84ae4652b, parent 725b8a3), one commit, subject "test(write-to-file): stream the preview before asserting the denial cleanup", one file, 11 insertions and no deletions, in src/core/tools/tests/writeToFileTool.spec.ts, blob 25d6e407bc1cd037ed80f28cf592e7458bfac15c to 5de5fb57ff76b8c2a1cc2f9491d22af4d90c5dbe. The push was lease-pinned to this lane's own fresh ls-remote read of the ref it replaced, ran with the husky hooks enabled and no --no-verify, and the head was read back off the transport afterwards.

The commit opens no new test. It re-cuts one: the deny-after-partial case at writeToFileTool.spec.ts:1130 of the file it replaces. Its first isPartial delta only records the path in hasPathStabilizedForTask(); a second matching delta is needed before open() and update() run, so the test now streams twice and pins expect(mockCline.diffViewProvider.open).toHaveBeenCalled() and expect(mockCline.diffViewProvider.update).toHaveBeenCalled() before the denial, then pins the order through invocationCallOrder: open before discardUnapprovedStream before reset. Until this change the denial-cleanup assertions could be satisfied by a diff view that was never opened, which is the hole the row named "stream the preview before asserting the denial cleanup" was raised for. Locally, on a worktree checked out at the new head with node_modules junction-linked to a donor install: vitest run core/tools/tests/writeToFileTool.spec.ts reported 79 passed and 5 skipped in 1 file; eslint --max-warnings=0 over the touched file exits 0; prettier --check exits 0; the commit does not touch src/eslint-suppressions.json, so no suppression count moved with it. knip, compile, e2e-mock, the two platform matrices, mutation killing and codecov were not run locally by this lane, and nothing in this section claims them.

A stacking fact measured rather than inherited: this branch's parent is 725b8a3, which is stacked on d52c161 -- the head unit U6a carried before today -- while #1932 now carries d71db6a, so this branch trails its dependency by that commit. The two ways of closing that gap do not behave the same way. A linear replay collides: git cherry-pick a1d9d24 onto d71db6a exits 1 with "CONFLICT (content): Merge conflict in src/core/tools/tests/writeToFileTool.spec.ts" and "error: could not apply a1d9d24... test(write-to-file): stream the preview before asserting the denial cleanup". A three-way merge does not: git merge-tree --write-tree d71db6a a1d9d24 exits 0 with tree 29b4eebe68ebcbd09af9a3accdd9734eae00b451, recorded as commit 9f56ef0b83d5ba7b2696e37c6e21d4c4a7fb64ff with parents d71db6a and a1d9d24. The cause is visible in blobs: writeToFileTool.spec.ts is 7cb9d015857469f1406834476af00bcc0511688f at the merge base and at the head #1932 carries, this unit rewrote it to 25d6e407bc1cd037ed80f28cf592e7458bfac15c and its new commit moved it to 5de5fb57ff76b8c2a1cc2f9491d22af4d90c5dbe, so patch application against a lineage that never carried this unit's rewrite collides where a merge with the shared base does not. The declared merge order -- U3 #1931, U4 #1929, U5 #1930, U6a #1932, U6b, then U7 #1928 -- is what makes the chain resolve without a replay.

Prices at the head that exists now

Two shapes, priced with the committed instrument on its own footing. Nothing moved in any column from the rows this replaces, and the identity is measured rather than assumed: test paths sit outside both caps by EXCLUDED_PATH_SEGMENTS and the commit pushed today touches a spec file only.

The chain top that ships once #1932 merges -- the clean three-way merge of the two new heads, tree 29b4eebe68ebcbd09af9a3accdd9734eae00b451, recorded with main tip efc22ed as its only parent so the reading stays head-to-base -- measures 474 lines, 172 selectors and 430 instrumented mutants, the same three numbers as this pull's cumulative row, because unit U6a's commit today touches a spec only. Additivity is exact: 208 + 266 = 474 lines, 70 + 102 = 172 selectors, 182 + 248 = 430 mutants. Against the caps (500 changed executable lines, 400 instrumented mutants): the unit shape sits at 266 of 500 lines and 248 of 400 mutants; the cumulative shape sits at 474 of 500 lines, 26 lines inside the line cap, and at 430 instrumented mutants, 30 mutants outside the mutant cap. The instrument states that breach in its own words: its preflight throws "extension generated 430 mutants in preflight (limit 400). Split the PR or obtain a maintainer-reviewed narrow exclusion." and its runManifest turns the throw into an advisory row rather than a score. Density at the cumulative shape is 430 / 172 = 2.50 mutants per selector; at this unit 248 / 102 = 2.43.

Footing, with the deviations named

Lines and selectors are the committed instrument's own selection code -- selectFromGit and buildManifest of scripts/stryker-diff.mjs, blob 7dfe0006d2d5c7e4d2282f65f68b8ed5f16866bc, which git reports byte-identical at a1d9d24, at d71db6a, at 9f56ef0b83d5ba7b2696e37c6e21d4c4a7fb64ff and at main tip efc22ed -- run with the pricing worktree checked out at the priced head, advisories 0 in every shape. Mutants are the instrumenter line of a Stryker 10 --force --dryRunOnly preflight over the identical selector list, cwd /src against that head's own committed stryker.config.mjs (blob 7d85640377bad7be6f4b8e6c46d5145dd9f5fe4d, byte-identical at every head named here) with the six-variable environment the committed runStryker builds: STRYKER_VITEST_CONFIG=../vitest.core.config.ts, STRYKER_REPORT_DIR=, STRYKER_TEMP_DIR=, STRYKER_IN_PLACE=false, STRYKER_VITEST_RELATED=false, STRYKER_TEST_FILES=[]. Three deviations, named rather than smoothed: the executable is node_modules/@stryker-mutator/core/bin/stryker.js run through the pinned node binary rather than the node_modules/.bin/stryker shim, because in this install that shim exists only as stryker, stryker.CMD and stryker.ps1 and Node will not spawn those without a shell; the killing stage is stubbed, runMutation having been injected into the exported runManifest, so this lane ran preflight only and has executed no mutant against a test at any head at any shape; and the pricing installs are junction-linked to a donor node_modules rather than lockfile-matched to each head, which is a footing difference this lane cannot price out.

The preflight exits non-zero in every shape and the instrumenter line prints before any test runs, which is the line the committed instrument itself reads ("Instrumented N source file(s) with M mutant(s)"). Both failures are quoted as they came back. With the six-variable environment stryker dies inside its child-process-proxy and the run ends with a stack trace at node .../@stryker-mutator/core/dist/src/child-proxy/child-process-proxy.js:123:33 and "Node.js v22.23.4". On an earlier run without that environment it reached the test phase and printed "INFO DryRunExecutor Note: running the dry-run only", then "ERROR DryRunExecutor Initial test run timed out!" and "ERROR Something went wrong in the initial test run", the initial test run being capped at Stryker's own 300000 ms. A first attempt also passed --timeoutOnlyForInitialTestRun 25000, which stryker refused with "error: unknown option '--timeoutOnlyForInitialTestRun'"; no number quoted here comes from that attempt. These are counts of what instrumentation produced. They are not mutation scores and they carry no verdict, and the run that reports "Passed" in this lane's receipts means only that the committed adjudicator had nothing to fail on an empty stub report.

What the mutation leg actually prices, because it changes how a width movement must be read

.github/workflows/mutation-testing.yml, blob fd2a00747a063fe52e9b2eeeef26cc971dc0f068 and byte-identical at both new heads, computes BASE_SHA as HEAD_SHA^1 with HEAD_SHA taken from github.sha, and on a pull request github.sha is GitHub's synthetic merge commit, so the priced shape is the merged candidate against its merge base rather than this pull's own commit. The instrument behaves the same on its own terms: resolvePullRequestBase returns head^1 for a head with two parents. Measured on the chain candidate built from the two new heads -- commit 9f56ef0b83d5ba7b2696e37c6e21d4c4a7fb64ff, tree 29b4eebe68ebcbd09af9a3accdd9734eae00b451, parents d71db6a and a1d9d24, git merge-tree exit 0 -- the instrument takes base d71db6a and prices 266 lines, 102 selectors and 248 instrumented mutants: only what the second parent adds. For this pull specifically the candidate and the branch head coincide, because the branch's lineage already reaches main tip, so the shape CI prices is efc22ed to a1d9d24 at 474 lines and 430 instrumented mutants: the chain's width, not this commit's. A width movement in the mutation-diff leg is therefore not a behaviour verdict on this commit.

Legs at a1d9d24, each named by job and run

Read through the anonymous commit checks door, github.com///commit//checks, captured with on-disk mtime 2026-11-12T11:03:55.356Z (the filesystem reports mtimes in UTC; the door sent no rate-limit header, so no server-side stamp came back with the capture). The capture is 281,388 bytes with digest sha256-16 6d6e6fa9c138f6e9. That door spends nothing from this lane's authenticated request budget and it is not the checks API: it returns only the check heads a browser is shown, and every status below is the door's own row label quoted verbatim, not this lane's verdict.

The six legs this chain treats as required, named apart from everything else: check-translations, job 131133220821, run 43203656919, "This job succeeded". knip, job 131133220999, run 43203656919, "This job succeeded". compile, job 131133220813, run 43203656919, "This job succeeded". e2e-mock, job 131133221251, run 43203656852, "This job succeeded". platform-unit-test (ubuntu-latest), job 131133220942, run 43203656919, "This job succeeded". platform-unit-test (windows-latest), job 131133221362, run 43203656919, "This job succeeded". The door labels those rows; this lane reports the labels and does not call any leg passed.

The advisory leg, kept apart from the six: mutation-diff, job 131133220247, run 43203656945, door label "This job succeeded". Its annotation bodies are unread, so what it printed about surviving or uncovered mutants at this head is still unread, and its footing is the merged candidate named above.

Other rows the same door shows at this head, none of them a required leg by this chain's naming: CodeRabbit "This check passed" (run 43203656945); codecov/patch "In progress"; codecov/patch/webview-patch "This check passed" (run 43204592861); CodeQL "This check passed" (run 43203782893); dependency-review job 131133220396; invisible-chars job 131133220834; Build test VSIX job 131133220741; extension-host-visual job 131133220865 run 43203656864; webview-visual job 131133220276 run 43203656864; theme-fixtures job 131133220643 run 43203656864; Analyze (javascript-typescript) job 131133220238 run 43203656829; validate-release job 131133220831 run 43203656813; and 28 reconcile rows (Zoo Code / reconcile PR review state (2434) and Zoo Code / resolve PRs to reconcile) all labelled "This job succeeded", newest run 43204973528. Which contexts the branch ruleset actually requires is a ruleset read this lane did not take; the six above are the ones this chain's directives name, printed apart from the advisory leg and from every other row.

Review state at this head, and what this lane's write proved

Read through the review-side door with one field-limited GraphQL query at 2026-11-12T10:58:26Z against this head: 12 of 12 review threads in one page, 47 of 47 comment nodes inside them, and 42 of 42 review objects in the same capture (5 CHANGES_REQUESTED and 19 COMMENTED from coderabbitai, 18 COMMENTED from easonLiangWorldedtech), read in both page directions and unioned by node id so nothing counted twice. The pull reads OPEN, reviewDecision CHANGES_REQUESTED, mergeable MERGEABLE, mergeStateStatus BLOCKED; the requested-reviewers connection reports totalCount 3. Threads: 5 resolved, which is one more than the read taken before this push, 7 open, 1 carrying isOutdated true (wM62cD9k at src/core/tools/WriteToFileTool.ts:518, resolved and outdated). The resolve that landed is this lane's attempt on wM62d3ns (src/core/tools/tests/writeToFileTool.spec.ts:1133), now isResolved true with resolvedBy coderabbitai[bot] and commentsTotal 5 where the earlier read recorded 3. Of the eight thread-root replies this lane attempted on this pull between 2026-11-12T10:49:33Z and 10:49:42Z, six are proven present -- on wM62cD9X, wM62cD9d, wM62cD9n, wM62d3ns, wM62d3ny and wM62d3n3 -- and two are proven absent: wM62eTyl at src/integrations/editor/tests/DiffViewProvider.spec.ts:1790 and wM62eTyn at src/integrations/editor/DiffViewProvider.ts:763, both still carrying commentsTotal 1. Across the two pulls of this unit that is six replies landed and six proven absent out of twelve attempted, and the two figures are kept apart. The batch's own response was HTTP 504 with a 0-byte body, so the send reported nothing about what it applied; this read, not the response, is what proves presence and absence. No line coordinate moved on the threads sampled in both reads: originalLine reads 1642 on wM62cD9X, 1133 on wM62d3ns, 1790 on wM62eTyl and 763 on wM62eTyn in each, because the review side pins a comment to the position it was written at instead of re-tracking it; the only coordinate-shaped movement is isOutdated. Re-posting the two absent replies is a further leg, unfunded by this leg's ceiling.

Fields this door does not hand back are named as unread rather than as absent: the review bodies and comment bodies were not asked for, so CodeRabbit's checklist and assessment rows behind sign-in, the mutation-diff annotation bodies, CODEOWNERS as GitHub resolves it, and the state reasons behind BLOCKED all remain unread.