Default

Decide whether the merged-main CPU-capped artifact or the Claude Fable emergency artifact owns url:buildtest after the second same-night replacement. No further route action is safe until ownership is explicit.

ContainerNursery queue causes are reproduced and corrected on pull request 492; fresh checks are pending before the ordered merge campaign resumes.

The working-directory correction is pushed and passes locally and remotely, but fresh branch run 0edec199 had two other code-path timeouts. No queue entry was created, nothing was published, and Steps 2–5 remain untouched.

buildtest.kotlin.build went from 20.5s page loads to a full outage (port 443 refusing) and back to healthy (200 in 0.10s, queue draining). Eight fixes are deployed and verified in production but not yet merged to main. The unifying root cause of droplet leakage, fleet-count divergence and admission starvation is a single never-reopened SJVM sandbox connection to url://digitalocean-droplets/: one stalled RPC invalidates it for all concurrent callers, and every reconciliation path runs over it, so 'could not observe' becomes 'observed absence'. The fix already exists in-org in NetLabManagerServer/DropletClient.kt and is a port. Next: land that port, fix DeletionWorker throughput (~1 droplet per 35-60s against a 57-deep backlog, blocking shards), and ship BuildTestEmbedded PR 454 before any further coordinator restart.

Supervisor action is required: PR 457 remains open after queue remote run 8cf670f7 failed 15 of 1261 tests while queue GitHub Actions passed all 1261.

PR 457 was evicted after its queue kotlin.build run finished 89 passed and 11 failed across relay, connection, dial, gossip, and scoring tests. The prior eviction test was included but was not the sole failure; a supervisor must address the suite-wide load-sensitive result before merging and publishing.

NetLab API 0.0.19 is merged and published. Both downstream PRs are open; NLMS is green, while BTE passed every phase-E/phase-D scenario but its overall check is blocked by a reproduced deployed-scheduler timeout wave affecting unrelated tests. Awaiting supervisor review and direction; neither PR is enqueued or merged.

Two CockroachDbEmbedded checks ended without a repository test failure: one after a BuildTestServer restart and one after waiting for admission with no backing droplet for 59 minutes. The queue contract permits indefinite pending, but the GitHub check caller still applies its elapsed timeout.

Four upstream releases merged and published (protocol through 0.0.424, resolver 0.0.679), including a real defect where joinNetwork's async announcements were absent from isGossipIdle so the public awaitGossipIdle barrier could return before work was enqueued. The resolver bump pull request 892 remains open and BEHIND main: kotlin.build (remote) passes 1228/1228 but the GitHub-hosted bld-build check fails on stressTestOnPeerRegisteredWithRelayObservationBeforeRegistry, a writer alive at the unchanged 60-second join. Four fix attempts have failed that check, including one from a second actor now pushing to the same branch. Three hypotheses were refuted by measurement and are documented so they are not retried, notably that bumping protocol to the already-published 0.0.427 makes it ~20.5% slower, not faster. Local timing under-predicts that runner by 4-5x and must not be used as the gate. Downstream: two server pull requests, a command-line-tool pull request, one owner design decision, and the remaining workstream milestones.

All five follow-on items are resolved as engineering work: UrlResolver 856 (six reconnect regression tests, zero production changes) is rebased onto current main, adapted to the deliberately-changed dispatch ordering of the stabilization batch, hardened against shard-load observation races (latch waits at unchanged bounds), and proven green in every execution ��� isolated, under concurrent load, full bld-build suite, and every buildtest run. The post-merge review of UrlProtocol 430 found one residual High interleaving gap (issue 424 retitled, evidence posted); the two wip/pr430 branches were verified NOT superseded and retained; and netlab non-recovery was proven at request-ID granularity (whole provisioning chain still on protocol 0.0.400; fix published as 0.0.429 but undeployed). The one open item: the PR was evicted from the merge queue four times, every time by a different rotating pre-existing flake (never its own tests); re-enqueue budget deliberately exhausted. Unblock by approving the four-service netlab-chain redeploy on >=0.0.429, running a flaky-test campaign over the rotating queue killers (start with testUrlProtocol2GossipAndRpcUseInjectedInMemoryNetwork), or authorizing further queue attempts.

No published resolver through 0.0.680 implements the abstract GossipHandler method required by protocol 0.0.427. Update UrlResolver, test it against 0.0.427, and publish a compatible release before the ContainerNursery pin verification can continue.

Merged-main backend jar is live on url:buildtest: with the exact expected hash and all in-flight runs preserved, but startup logged exception stack traces and the required f3ed0075 test-results endpoint remains HTTP 503/500, so the four-gate deployment result is not successful.

Campaign over the open-handoff backlog. 22 pull requests merged, 6 closed with evidence, 8 challenges filed. The remaining work is one dependency chain: a transport fix that stops completed responses being discarded is green on its branch but has been evicted from the merge queue THREE times on the identical commit, with the combined build failing 1, then 11, then 15 tests across unrelated subsystems while GitHub Actions passed every time ��� the evidence points at a degraded build host, not the change. Its two dependents, the protocol publication, and a verified review fix are all staged and unpushed behind it. Separately, 23 owner pull requests are green behind a workspace test-harness fix that is partially applied.

UrlResolver full-suite GitHub Actions failed three attempts at one commit with three different single-test failures; matching route-state and same-tier relay fixes are in the linked open PR, and further reruns are not diagnosis.

The reported duplicate baby-sleep.md in the left nav is fully resolved in production (storage duplicate repaired; the shadowed file was the user's real 4885-char document, the visible one a 37-char stub). Both code fixes are merged: the name-addressed listing now reports each name once, and the fat JAR now bundles its full dependency closure (it had been missing 28 transitive artifacts since PR #49, making every built JAR fail to start). Blocked on deploying that merged code: newly built Cloud Run revisions fail the startup TCP probe emitting zero application logs, while the same JAR binds its port in 15s locally. Traffic is safely on healthy revision 00005 and users are unaffected.

PR 873 is rebased and remote CI is green, but GitHub Actions twice failed on the linked persistent-RPC/NetLab stream-loss blocker; PRs 882, 866, and 827 remain untouched by strict ordering.

PR 893 was rebased and three exact-head corrections were tested, but both fixed reproducer bars still fail. Work stopped because the written six-by-three concurrency criterion conflicts with the checked-in all-18-at-once starvation harness, and changing it would weaken the test without explicit direction.

The non-resolver build-log API cleanup is complete: BuildTestApi 0.0.55, BuildTestEmbedded 0.0.61402, kotlin-build-ci, and BuildTestServerService changes are merged. The daemon OOM remediation remains gated by an unpublished UrlResolver exact-once relay fix.

Six defects found in the Handoff service's GitHub mirror. Five are fixed, merged and deployed (four deterministic drop paths plus a retry-recovery defect deployed 2026-07-30). The sixth ��� sandboxed connections being closed while child-object reads are still in flight ��� is fixed and open at UrlResolver pull request 897, isolated onto current main and green locally, but cannot merge because UrlResolver's main is itself failing four network-lab/relay tests that provision real droplets on a host sitting at load 54 with a 92%-full disk. Production currently does not reconcile: the sync is stuck in its startup seed phase with the exact connection-closed signature that pull request fixes.

Choose whether to recover the historical manager transport artifacts or authorize a coordinated manager/worker transport upgrade. No deployment should proceed until one basis is selected and verified.

The user requested a third investigation round on [SimpleFileSystemDurableEmbedded](https://github.com/CodexCoder21Organization/SimpleFileSystemDurableEmbedded), with memory as a strict test-before-fix gate:

Four prior BuildTest failure groups landed. Still open: SimpleFileSystemServiceCli pull request 13 remains toolchain-gated and not ready, and the raw-NUL producer in the remote event-stream path is still unidentified; the merged consumer guard does not fix that source.

Five fixes merged. Three open: a quadratic peer-eviction regression in UrlProtocol (fix complete, local suite 1212/1212, but its performance test must be rewritten to be hardware-independent before landing), a ContainerNursery ordering fix where a live container became replaceable before its stop began (verified 15/15 locally, CI not yet run on the latest head), and a UrlResolver registration-ordering fix that is gated on the peer-eviction fix being published. An earlier claim that the merge queue was blocked org-wide by a build-runner defect has been retracted and must not be acted on.

PR 870 review commit a427b7c5b is pushed and locally verified, but its complete 1,206-test remote run failed only on three external NetLab artifact-upload connection failures. The designated orchestrator must own the allowed rerequest; PR 863 remains untouched until PR 870 is green. PR 874 duplicates/substantially subsumes both retention fixes and should not land alongside them.

Acute buildtest admission stall root-caused+relieved (sandbox proxy never reopened; droplet-backend restart) and durable fix opened (BuildTestServerService PR 267). Keystone relay-flake fix (UrlResolver 893) verified 10/10, captured on wip branch, needs push+land. Everything routes through buildtest CI which is degraded by an unbounded ~1GB projection-scan on a RAM-bound host; durable remedy is claude-fable-deploy-lane's upstream BuildTestEmbedded scan-bounding fix (not yet merged). 894/895 downstream of 893; 447 round-2 needs Opus (codex filter-blocked).

Re-homed from the HardwareControlFabric onboarding handoff because the owning layer is UrlProtocol, not HCF. When peer A resolves a freshly-registered peer B's peer-scoped alias, A's candidate set for B contains only /p2p-circuit/ relay routes and B's reachable direct address is never learned, so every dial fails. Two hermetic in-process UrlProtocol2 reproducers already exist on UrlResolver branch reproduce-hcf-circuit-only-onboarding (head 83984307). The previous fix attempt was red on CI in 3 of 5 repos and caused two production outages, including a ~40 minute one at droplet load 119; all 5 PRs are now closed and unmerged, branches intact. Hard guardrail: code plus hermetic tests only, no production deploys, a human drives any prod touch, and any fix must ship with comprehensive end-to-end tests of the propagation path.

Three-day merge campaign ~95% done: 819/801/821/680/826 and the full secondary train merged; false-lease-death, /bypass, heartbeat-crash, transport-storm and queue-timeout root causes fixed and deployed. Remaining: UrlResolver 822 (kotlin.build green; bld-build fails 1135/1137 on two tests gained from merged 826 ��� suspected interaction with its relay-registration single-flight commit; exact drop-or-fix plan inside), supporting PRs 834/838, and the deferred keystone/fabric/W3Wallet backlog (three fabric consumer PRs are green and enqueueable right now). Blocked: codex gpt-5.6-sol usage limit until 2026-07-28 17:02 UTC.

Six PRs merged (the NetworkProvider seam, exact-peer APIs, and Phase 4 steps 1-2 including the three 1024-node deterministic gossip scenarios). Three open PRs are code-complete and verified but cannot land: PR 422 (replay-determinism fix, all checks green) sits behind unrelated merge-queue entries; PR 416 (peer score records plus an eviction-performance and a health-check fix) was evicted twice by a known load-sensitive keepalive test tracked in UrlProtocol issue 423; resolver PR 852 (a one-line pin fix that unblocks ALL resolver PRs) has burned three CI runs on three distinct infrastructure failures. Remaining to graduation: land those three, wire peer scores into allocation and publish a protocol version above 0.0.409, then add resolver-side scenarios and an in-process storm reproduction.

Resolver test correction is pushed and verified locally under genuine concurrency; full buildtest is green. GitHub Actions passed 1,227/1,228 and hit the known unbounded hosted-NetLab admission failure. Resolver 0.0.825 remains unpublished, so both Server PRs remain unchanged. Blocked on approval and implementation of one cross-CI NetLab suite lease; nothing is merge-ready.

All engineering is done and verified: W3Wallet PR 100 merged; protocol 0.0.429 (outbox transport fix) and resolver 0.0.705 (adds the host-RPC collection-return regression fix, UrlResolver PR 901) published with byte-level verification; NetLabManagerServer PR 128 and NetLabWorkerServer PR 63 move both services onto that exact pair with targeted tests green, including the worker round-trip test that fails on 0.0.704 and passes on 0.0.705; UrlResolver PRs 659/865/868 are rebased and code-clean, red only on the known netlab-infrastructure family. The single remaining gate is the coordinated netlab-manager+worker redeploy (explicit owner approval required); after it: re-run CI, merge 865/868/901, enqueue pre-approved 659, re-dispatch the 7-suite netlab-e2e, and resolve the transport-basis decision handoff as option 2.

Original user request (verbatim intent): *"Looks like some kind of infrastructure error is happening, we need to resolve it. Use gpt 5.6-sol to do the heavy lifting."* — with explicit authorization to *"build locally, publish, merge and deploy."* Later, on seeing CI thrash, the user directed: *"we should build locally and deploy to unblock ourselves."*

The emergency-lane mission is complete: UrlResolver PR 835 merged 2026-07-25T23:42:51Z on a genuinely green gate after both blocking intermittent failures were root-caused and fixed (a per-address dial cooldown silencing explicit reconnects; a node recording the wrong relay after failover). buildtest.kotlin.build is healthy. Two follow-ups remain: UrlProtocol PR 421 (protocol 0.0.410, all checks green, awaiting merge then publish) hardens the relay-identity fix at the two remaining sites an adversarial review found unpatched, and UrlResolver PR 849 has CI failures whose leading hypothesis is a stale build cache, not a code defect.

9 of 12 PRs merged. This session: UrlResolver 892 respin complete+verified at protocol 0.0.428/resolver 0.0.825 (unpushed pending one test classification, lane in flight); resolver large-pull fix implemented with count-asserted fail-first tests; Server 19 root cause measured at a validated CI-equivalent rig; Cli 13 repinned+locally verified. NetLab 124/126 review-rejected. Blocking gate: buildtest admission feedback loop root-caused (twice today, evidence in PlanRepository), durable fix = BuildTestEmbedded PR 440 (green, DIRTY) ��� owner must authorize rebase/merge/deploy + drain-first restart; four CI runs died with zero tests executed.

2026-07-27: 9 PRs merged (UrlProtocol half complete + 0.0.413/0.0.414 published; both browser-test defects fixed). Resolver gate failing unrelated PRs on a shared netlab service fault; the resolver defect it exposed is ROOT-CAUSED and FIXED in #878 (reviewed, signed off, parked out of the queue with #876/#877/#862 to avoid burning queue time). Causation from #878 to the CI failures is NOT established. Browser assertion still unverified and its expected text is probably stale vs the merged fix ��� detail inside.

The merged HandoffWui listener-before-backend change was built and deployed on 2026-07-29, but the external cold request still received zero bytes for 15 seconds because ContainerNursery/JVM launch delayed Jetty by about 24 seconds. The deployment was worse than the measured 0.0.3 baseline and was rolled back successfully; production is healthy on 0.0.3 with unchanged route configuration. Next work belongs in a reliable ContainerNursery lazy-start reproducer and owning-layer fix; keep-warm is not allowed.

Drive three older PlanRepository handoffs to genuine completion by delegating the heavy lifting to parallel codex gpt-5.6-sol lanes, per the user's standing request to "drive [the 2026-07-20 handoff] to completion." The user pre-approved publishing and merging **for this workstream's own PRs**; every PR targets `main`/`master` directly. The chain, in order:

Original user request (verbatim intent): **"Drive ALL O(N²) growth issues in the CodexCoder21Organization url:// gossip/discovery stack to final resolution (resolve/eliminate, not mitigate),"** delegating the heavy lifting (implementation, review, verification) to codex gpt-5.6-sol, parallelized across agents.

PR 30 is open and clean at fcf2187 with all four standard checks green. The one authorized hosted NetLab run proved basic NAT, daemon restart, and browser JVM NAT pass after the assertion repair, but failed on a NetLab upload connection closure and an unresolved relay-unavailable body mismatch whose bytes were not retained. The branch now downloads that body on future failures. Local NetLab was unavailable. Recommendation: close as blocked; do not merge on current evidence.

WUI end LANDED: BuildTestWui#145 merged (a5708fa, queue run 217/0) after #148 fixed the merge-queue blocker. That blocker was NOT a wedged url://screenshottest/ (the service was healthy throughout) but goldenScreenshots uploading the whole ~130 MiB test classpath per run against a 300s budget; it now ships ~15 MiB. SJVM end (sandboxjvm#97) also merged but UNRELEASED at 0.0.49 - the UrlResolver pin-bump landmine is still live. Still open: acceptance criterion (b), the client exception's cause, which is resolver-lane work.

2026-07-19 buildtest.kotlin.build outage cleanup is nearly done: /runs is reliable and the root causes are fixed/merged (gossip+lock #803, reaper #348). Two PRs remain open on UrlResolver: the gossip pre-join-retry fix (#809, reviewed+passing, CI running) which fixes the flaky bld-build gate, and the refcnt regression-test (#807, CLEAN, evicted 4x by that flake). Land #809, then rebase+merge #807 (version-bump conflict expected), then reconcile two stale consumer PRs. NOTE: codex is usage-limited until ~Jul 25.

buildtest /runs was unreliable because the WUI OOM-looped on a 128MB heap under droplet load; interim fix bumped it to 2GB (holds 10/10 at 75 droplets but still OOMs a few times/30min). Root cause: each per-droplet url:// call runs in an interpreted SJVM sandbox and can re-fetch ~2.4MB of client-stub bytecode per connection, so heap+CPU scale with droplet count. Fix: cache/reuse each droplet's connection+bytecode, reduce lease-poll frequency, then revert the heap.

resolver 0.0.640 evicts departed peers' forwarded-discovery rows (fixing the unbounded map that GC-thrashed every url:// node and took buildtest down). Live on prod but PRs unmerged (BuildTestWui #132, ContainerNursery #528) and fail-first tests + comprehensiveness/adversarial/final reviews were all skipped for incident speed ��� this handoff requires completing them and driving to merge.

Durable follow-up to the 2026-07-19 buildtest gossip-storm incident. The resolver's forwardedDiscoveredServices table is keyed by (destinationPeerId, serviceIdentifier, providerPeerId) ��� inherently O(N��) in mesh nodes. The immediate fix (resolver 0.0.640) only evicts dead peers + caps at 50k; this handoff's goal is to redesign discovery/forwarding state to be O(#services) per node, never O(peer-pairs), and to audit/eliminate all other N�� structures in UrlResolver/UrlProtocol.

Core awaitTerminal() mission complete (3 PRs merged). Remaining: land UrlResolver PR 737 (all failures were netlab-infra flakes; a real flaky test was root-cause-fixed in commit 74a8efc9; merge pre-approved; bld-build verdict pending on head f0e110374), rebase+land PR 866 (the retention fix, head cb37f9e98), roll the fixed UrlResolver into the netlab manager via ContainerNursery (5-step checklist inside; manager currently embeds pre-fix 0.0.670), then re-request checks on PR 850 (head fb88b56bd) and merge, then complete this handoff. The netlab manager was restarted 2026-07-27 ~02:20 UTC for a clean-heap CI window and stayed healthy through a 2h run.

Get **UrlResolver** (https://github.com/CodexCoder21Organization/UrlResolver) `main` **consistently green**. The strategy is the `fix-flakey-test` discipline: reproduce each intermittently-failing test locally under CPU-pressure amplification (≥50% reproduction gate), root-cause it, fix the underlying code/oracle, and merge — delegating all implementation/verification to **codex `gpt-5.6-sol`** lanes. Merging is pre-authorized for this workstream; **each fix merges as its own PR when it goes green** (the user force-merged the large consolidated PR earlier, so remaining flakes each become a separate PR). Prior related handoff (grain of salt, largely superseded): [2026-07-15-urlresolver-saturation-flake-noise-handshake-residual.md](https://github.com/CodexCoder21Organization/PlanRepository/blob/main/handoffs/2026-07-15-urlresolver-saturation-flake-noise-handshake-residual.md).

Standing request (verbatim intent): *"keep working (flakey test skill) and merging until UrlResolver goes consistently green. Ensure codex does an adversarial review of each change before we merge."* Then, mid-effort: *"let's split it now. Create a PR and link it to me. Create a handoff for the remaining work/issues."*

Fix flaky `testDeeplyNestedMapReturnIsRejectedNotStackOverflow`, where the required full depth-limit rejection lost a race against the sandbox's unchanged five-second SJVM invocation deadline on slow runners. The work had to reproduce the timeout under load, profile the owning layer, fix upstream if appropriate, preserve the exact assertion and all timeouts, verify under the reproducing profile, publish/bump any upstream fix, and take the UrlResolver PR through green CI and merge.

Fix the flaky main test `testActiveQueryDiscoveredServiceIsEvictableByTtlCleanup`, which failed identically in three CI runs when a direct on-demand lookup returned no service. The required workflow was reproduce-first: reach at least a 50% failure rate over at least ten attempts under an isolated, CPU-contended profile; determine from that reproducer whether the test races provider readiness or the product active-query path fails under scheduler pressure; then fix only the owning layer, preserve discovery plus TTL eviction, verify the requested stress/unconstrained/sibling gates, create a PR, and watch it through the pre-authorized merge.

Autonomous-loop shepherding of a batch of **UrlResolver** PRs to green/merge-ready. Mid-session the user asked, verbatim: **"Did you create a PR which fixes the testBytecodeFetch flake?"** — expanding the mission to **creating and landing a de-flake PR** for `testBytecodeFetchAggregatesRelayFailureDetails` (now **[#767](https://github.com/CodexCoder21Organization/UrlResolver/pull/767)**, green), which was the highest-frequency flake blocking the whole `foundation.url:resolver` pipeline. The user is now actively merging the batch. **Nothing is merged by the agent without explicit user approval** (handoffs excepted); this doc is NOT authorization to merge code PRs.

Original request: *"Looks like there are some flakes on the main branch? We need to use our flakey test skill to resolve: https://github.com/CodexCoder21Organization/UrlResolver/runs/86599526915"*, expanded via `/goal` to: *"ensure all flakes are fixed (including proposing PRs for fixing the underlying infrastructure if that's the problem). Ensure your PR to resolve the flakes is consistently green, and then merge them, ensure they get merged."* **Merging is pre-authorized** for this flake-fix train.

Original user request (verbatim intent): **"https://github.com/CodexCoder21Organization/UrlResolver/pull/752 is red — ensure it goes green and gets merged."** The merge was explicitly **user-authorized**.

Live re-verification on 2026-07-30 found the command, withdrawal, resilience, and CI-root-fix work finished; the old relay branch was partly superseded, but stable-peer address refresh and confirmed-relay-only announcements still need focused current-main tests and fixes. The handoff remains open with exact branches, SHAs, evidence links, and next steps.

"The kompile-cli release, dependency cleanup, publication, and UrlProtocol rollout are complete. UrlResolver's consolidated rollout PR remains open and approved for merge; its latest full build exposed one deterministic marshaling defect plus separate NetLab capacity failures. A rebased, unverified stack-safe implementation checkpoint is preserved on a remote branch."

Original request (verbatim intent): *"drive [the 2026-07-05 handoff] to completion."* That handoff's one unfinished, owned item is **UrlResolver PR #659**, a pure-cleanup PR removing two leftovers from the earlier #656 merge:

**Written:** 2026-07-05. **UPDATED 2026-07-12 ~16:45 UTC** (§2/§3 rewritten — the code is done and pushed; the ONLY blocker is buildtest infrastructure, not the PR). **Every state snapshot below was verified at update time — RE-VERIFY before acting.** PRs merge, queues shuffle, prod restarts. `gh pr view <num> --repo CodexCoder21Organization/UrlResolver --json state,mergeStateStatus,statusCheckRollup,mergedAt` is authoritative; never trust this doc over a fresh query.

Original request: *"Now that #650 merged, is there anything about [UrlResolver #647] worth salvaging (tests, etc.)?"* → salvage it into a PR → *"ensure #653 gets merged"* → then investigate the non-DO CI flakes. **Merging #653 is user-approved** (directive: "ensure 653 gets merged"). 0 reviews required.

The UrlResolver PR train from the original memory audit is down to one open PR: https://github.com/CodexCoder21Organization/UrlResolver/pull/616, a test-only ByteArray marshaling-coverage PR that is CLEAN/MERGEABLE with both head checks green and has never had one of its own tests fail across roughly ten validation runs. It has been evicted from the merge queue nine-plus times, every time by infrastructure: a WebCron/DropletService gate that vetoes all droplet creation, an UrlProtocol response-drop-under-backpressure defect (issue 424, still open), a BuildTestEmbedded SSH-abort defect (issue 399, now FIXED and closed via PR 415 on 2026-07-29), a sibling lane redeploying ContainerNursery mid-validation, and a rotating family of load-sensitive netlab tests. Highest-leverage next step is not another retry: BuildTestEmbedded main is at 0.0.61302 while the deployed BuildTestServerService still pins 0.0.61206, so publish + pin-bump + redeploy would land ~15 merged coordinator fixes into the service that keeps evicting it. Suite health has measurably improved - three of the last ten UrlResolver runs came back 1229/0 clean - so a patient retry is now roughly a 1-in-3 proposition. Whether to retry or admin-merge is the user's call. Also outstanding: rebase and PR the salvaged wire-encoding tests on branch pr671-tests-on-main (now diverged from main), and the UrlProtocol 424 fix (100 percent reproducer already pushed).

Original request (verbatim intent): a user looking at buildtest run `d41cb83e` asked *"if tests run 4-at-a-time, how do we ever get 1 running + 1 pending?"* It expanded, in order, into:

This continues the handoff [`handoffs/2026-06-30-cn-477-httpclient-reuse-flake-fixed-and-urlfacade-p2p-entropy-flake.md`](2026-06-30-cn-477-httpclient-reuse-flake-fixed-and-urlfacade-p2p-entropy-flake.md), whose §4 left an open decision. User request this session (verbatim): *"Pull any latest changes into your skills repository (if any upstream) and then let's drive [that handoff] to completion."* When asked which fix approach to take, the user chose **approach B: fix the owning crypto libraries upstream** (not a downstream mitigation).

Investigate and fix, end-to-end and in production, the **GithubWatchman → `url://lambdaserver/functions/{id}` callback failures** (first observed as `"Stream closed"`, later `NoSuchMethodError: lambdaserver/LambdaServiceClientImpl.invoke(List)Object`). Ensure the fixes merge, publish, and are deployed so the callbacks actually succeed. Mid-thread the user added the higher-priority directive: