code-coordinator 0.5.572__tar.gz → 0.5.574__tar.gz

{code_coordinator-0.5.572 → code_coordinator-0.5.574}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.572
+Version: 0.5.574
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.572 → code_coordinator-0.5.574}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.572
+Version: 0.5.574
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.572 → code_coordinator-0.5.574}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.572",
+  "tag": "0.5.574",
   "distance": 0,
-  "node": "g33ef2d84241ba2583d47d8288838f7d8729dce83",
+  "node": "g15888500b70e89c6ef17658b665ae3fb70f2b9e6",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.572 → code_coordinator-0.5.574}/coord/bugbash.py

@@ -405,7 +405,17 @@ def _best_match(
         issue_platform = _platform_from_title(title)
         if issue_platform is not None and issue_platform != finding.platform:
             continue
-        score = _title_similarity(finding.title, title)
+        # #3546: score against the TAG-STRIPPED title, not the raw one — the
+        # platform gate above already accounts for the ``[bugbash:<platform>]``
+        # prefix, so scoring the untouched title made its own extra tokens
+        # ("bugbash", the platform name) dilute the Jaccard score against a
+        # short real-world title. "Caption buttons unclickable" (3 words) vs.
+        # "[bugbash:win-native] Caption buttons unclickable" scored only 0.5
+        # — BELOW :data:`DEFAULT_DEDUPE_THRESHOLD` — purely because of the
+        # tag's own 3 extra words, which is exactly the "titles differing
+        # enough to defeat matching" root cause behind vimcode#1656/#1660
+        # being filed as two separate issues for one bug.
+        score = _title_similarity(finding.title, _strip_platform_tag(title))
         if score >= threshold and (best is None or score > best[1]):
             best = (issue, score)
     return best
@@ -416,6 +426,54 @@ def _platform_from_title(title: str) -> str | None:
     return m.group(1) if m else None
 
 
+def _strip_platform_tag(title: str) -> str:
+    """Remove a leading ``[bugbash:<platform>]`` tag (if present) before
+    scoring title similarity — see :func:`_best_match`'s comment for why
+    leaving it in place made the score sensitive to the platform name
+    itself rather than just the bug description."""
+    return re.sub(r"^\[bugbash:[^\]]+\]\s*", "", title)
+
+
+def _dedupe_round_findings(
+    findings: Sequence[Finding],
+    open_issues: list[dict],
+    closed_issues: list[dict],
+    *,
+    threshold: float = DEFAULT_DEDUPE_THRESHOLD,
+) -> list[DedupeResult]:
+    """Dedupe every finding from ONE round, in order, against *open_issues*/
+    *closed_issues* — AND against every finding already decided NEW or
+    REGRESSION earlier in this SAME call (#3546).
+
+    The bugbash run that filed vimcode#1656/#1660/#1669/#1675 as four
+    separate issues for one bug did so partly because two lanes reporting
+    the identical symptom in the SAME round were each deduped only against
+    issues that existed BEFORE the round started — neither lane's finding
+    could see the other's. This function fixes that: a finding is matched
+    not just against *open_issues* but against a running list seeded with
+    every PRIOR finding in *findings* that this same walk already decided
+    was new/a regression, so the second lane's identical report comes back
+    :attr:`DedupeVerdict.DUPLICATE` instead of also being judged new.
+
+    A within-round match's :attr:`DedupeResult.matched_number` is ``None``
+    here — the sibling finding it matches has not actually been filed
+    through ``coord issue create`` yet at dedupe time, so there is no real
+    issue number to report. :func:`run_bugbash`'s filing loop resolves this
+    to the sibling's real number once that sibling is actually filed,
+    rather than leaving every within-round duplicate permanently numberless.
+    """
+    results: list[DedupeResult] = []
+    running_open = list(open_issues)
+    for finding in findings:
+        result = dedupe_finding(finding, running_open, closed_issues, threshold=threshold)
+        results.append(result)
+        if result.verdict is not DedupeVerdict.DUPLICATE:
+            running_open.append(
+                {"number": None, "title": compose_finding_issue_title(finding)}
+            )
+    return results
+
+
 def dedupe_finding(
     finding: Finding,
     open_issues: list[dict],
@@ -548,7 +606,11 @@ def build_exploration_briefing(
         "When done, end your final message with a fenced "
         f"```{FINDINGS_FENCE}``` block containing a JSON array of finding "
         "objects, each with: title, expected, actual, repro, evidence, "
-        "suspected_repo (the app or its UI framework), captures (list of "
+        "suspected_repo (the repo the FIX belongs in — the app, its UI "
+        "framework, e.g. quadraui, OR the coordinator tooling itself, e.g. "
+        "claude-coordinator, if the bug is actually in this bugbash driver "
+        "or its WSL/native bridge rather than in the app under test), "
+        "captures (list of "
         "capture paths/descriptions, may be empty). An empty array means "
         "zero findings this round.",
     ]
@@ -700,6 +762,24 @@ class FilingResult:
     preview_body: str | None = None
 
 
+def finding_target_repo(finding: Finding) -> str:
+    """Which repo a finding's issue should be filed into (#3546 requirement
+    2): :attr:`Finding.suspected_repo` when the worker reported one, else
+    *finding.repo* (the app the lane actually ran against) as the fallback.
+
+    Three coord/win-native-driver/WSL-bridge bugs from the first real
+    vimcode bugbash run were filed (and queued) in vimcode anyway, where no
+    worker could ever fix them, because filing unconditionally targeted
+    *finding.repo*. ``suspected_repo`` already carries the worker's best
+    guess at the actually-at-fault repo (the app itself, its UI framework,
+    or coord's own driver/bridge — see :func:`build_exploration_briefing`)
+    and defaults to *repo* in :func:`_finding_from_entry` when a lane
+    worker doesn't name one explicitly, so this is a one-line fallback, not
+    a guess of its own.
+    """
+    return finding.suspected_repo or finding.repo
+
+
 def file_finding(
     finding: Finding,
     dedupe: DedupeResult,
@@ -720,6 +800,11 @@ def file_finding(
     success, queued through ``coord drive-queue add --machine
     <lane.machine>``.
 
+    Both calls target :func:`finding_target_repo` (#3546) — NOT always
+    *finding.repo* — so a finding whose ``suspected_repo`` names coord's
+    own driver/bridge or the app's UI framework lands where a worker can
+    actually fix it, rather than in the app repo where nobody can.
+
     ``dry_run=True`` skips BOTH calls entirely and returns a preview —
     this is the sole mechanism backing "a dry run files nothing": there is
     no code path from ``dry_run=True`` to the runner being invoked.
@@ -732,6 +817,7 @@ def file_finding(
             filed=False, queued=False, issue_number=dedupe.matched_number,
         )
 
+    target_repo = finding_target_repo(finding)
     title = compose_finding_issue_title(finding)
     body = format_bug_report(
         expected=finding.expected,
@@ -755,7 +841,7 @@ def file_finding(
 
     create_out = runner(
         [
-            "issue", "create", finding.repo,
+            "issue", "create", target_repo,
             "--title", title,
             "--expected", finding.expected,
             "--actual", finding.actual,
@@ -771,7 +857,7 @@ def file_finding(
     issue_number = int(match.group(1))
 
     runner(
-        ["drive-queue", "add", finding.repo, str(issue_number), "--machine", lane.machine]
+        ["drive-queue", "add", target_repo, str(issue_number), "--machine", lane.machine]
     )
 
     return FilingResult(
@@ -811,6 +897,14 @@ class RoundReport:
     filings: list[FilingResult] = field(default_factory=list)
     lane_cost: dict[str, float] = field(default_factory=dict)
     skipped_lanes: list[str] = field(default_factory=list)
+    #: ``{platform: reason}`` for every entry in :attr:`skipped_lanes`
+    #: (#3546) — a skip must be as explainable as a failure or an
+    #: unavailability, never a bare platform name with no reason attached.
+    #: Currently populated with the per-lane cost-cap detail (the only
+    #: engine-level skip reason today); kept as its own dict (rather than
+    #: folded into ``skipped_lanes`` itself) so ``skipped_lanes``'s existing
+    #: ``list[str]`` shape — already read by callers — never has to change.
+    skip_reasons: dict[str, str] = field(default_factory=dict)
     #: Findings this round that were NOT duplicates of an already-tracked
     #: open issue — i.e. what actually moved the round-cap/zero-findings
     #: termination decision. Computed from the SAME dedupe verdicts stored
@@ -886,6 +980,25 @@ class RoundReport:
             set(self.lane_failures) | set(self.unavailable_lanes)
         )
 
+    @property
+    def all_lanes_skipped(self) -> bool:
+        """``True`` when at least one lane was skipped this round (its
+        per-lane cost cap was already blown) AND NOT A SINGLE lane was
+        actually explored (#3546) — i.e. the round asked nothing, got no
+        answer from anyone, yet :attr:`new_count` still reads ``0`` the same
+        way a genuine clean pass does.
+
+        The first real vimcode bugbash run's round 4 skipped every
+        configured lane this way and the CLI still printed
+        ``terminated='zero_findings'`` — a release gate reading that output
+        would conclude "last bugbash clean" about a round that tested
+        nothing at all. Distinct from :attr:`all_explored_lanes_failed` /
+        :attr:`all_explored_lanes_unavailable_or_failed`, both of which
+        require ``explored_lanes`` to be non-empty (a lane that was asked
+        and answered badly) — this property is specifically the "nobody was
+        even asked" case."""
+        return bool(self.skipped_lanes) and not self.explored_lanes
+
 
 @dataclass
 class BugbashReport:
@@ -949,17 +1062,24 @@ def run_bugbash(
 
     Each round: every lane is explored (unless it has already exceeded
     ``cost_cap_per_lane``, in which case it is skipped and recorded in
-    ``skipped_lanes`` — never silently dropped), findings are deduped
-    against a FRESH fetch of open/closed issues (so a finding filed earlier
-    in the SAME run is already visible and won't be re-filed next round),
-    and non-duplicates are filed via :func:`file_finding` — gated by
-    *confirm* for the first ``config.confirm_rounds`` rounds when not a dry
-    run. Termination is checked AFTER filing, from the round's own observed
-    ``new_count``/cost, never inferred from "no exception was raised":
+    ``skipped_lanes``/``skip_reasons`` — never silently dropped), findings
+    are deduped via :func:`_dedupe_round_findings` against a FRESH fetch of
+    open/closed issues MERGED with every issue THIS RUN has already filed
+    (#3546: a finding filed earlier in the same run — this round or an
+    earlier one — must be recognised by its real issue number, not just by
+    whatever a fresh ``gh issue list`` happens to already reflect, and two
+    lanes reporting the same bug in the SAME round must collapse to one
+    filing too), and non-duplicates are filed via :func:`file_finding` —
+    gated by *confirm* for the first ``config.confirm_rounds`` rounds when
+    not a dry run. Termination is checked AFTER filing, from the round's own
+    observed ``new_count``/cost, never inferred from "no exception was
+    raised":
 
     - ``"zero_findings"`` — this round's non-duplicate finding count is 0,
-      AND at least one explored lane actually completed its checklist
-      (neither ``RoundReport.all_explored_lanes_failed`` nor
+      AND at least one lane was actually explored this round (not every
+      lane was skipped on its cost cap — ``RoundReport.all_lanes_skipped``
+      is ``False``), AND that explored lane actually completed its
+      checklist (neither ``RoundReport.all_explored_lanes_failed`` nor
       ``RoundReport.all_explored_lanes_unavailable_or_failed`` is ``True``),
       AND no lane reported a protocol error (``RoundReport
       .protocol_error_lanes`` is empty) — a genuine observed clean pass.
@@ -979,13 +1099,16 @@ def run_bugbash(
       .protocol_error_lanes`` for which lane and why.
     - ``"lanes_unavailable"`` — this round's non-duplicate finding count is
       ALSO 0, no lane came back a dispatch/poll/log failure or a protocol
-      error, but every lane explored this round reported its GUI session/
-      display unavailable (#3510: locked or absent, e.g. a locked dell64) —
-      a different reason from ``"lane_failure"`` (the explorer DID run and
-      DID get a verified answer, it's just "the host is locked", not "I
-      don't know"), and still not a clean pass either, since nothing was
-      actually exercised against the app. Check ``BugbashReport
-      .rounds[-1].unavailable_lanes`` for which host needs unlocking.
+      error, and either (a) every lane explored this round reported its GUI
+      session/display unavailable (#3510: locked or absent, e.g. a locked
+      dell64), or (b) EVERY configured lane was skipped on its cost cap and
+      none was explored at all this round (#3546: a round that asked
+      nothing must never read as a clean pass either) — a different reason
+      from ``"lane_failure"`` (the explorer DID run and DID get a verified
+      answer, or nothing was even asked), and still not a clean pass either,
+      since nothing was actually exercised against the app. Check
+      ``BugbashReport.rounds[-1].unavailable_lanes``/``skip_reasons`` for
+      which host needs unlocking or budget needs raising.
     - ``"cost_cap"`` — cumulative cost has reached ``cost_cap_total``.
     - ``"round_cap"`` — ``config.max_rounds`` rounds ran without either of
       the above firing.
@@ -995,6 +1118,17 @@ def run_bugbash(
     total_cost = 0.0
     rounds: list[RoundReport] = []
     reason = "round_cap"
+    # #3546: every issue THIS RUN has actually filed into config.repo,
+    # across every round so far — consulted alongside each round's FRESH
+    # open-issues fetch so a finding matching an issue this run itself
+    # already created reads as a duplicate by NUMBER, never depending on a
+    # `gh issue list` snapshot having caught up with this process's own
+    # recent write. `run_filed_by_title` is the same data keyed for O(1)
+    # resolution when a within-round duplicate (see
+    # `_dedupe_round_findings`) needs its placeholder `matched_number=None`
+    # upgraded to the sibling's real number once that sibling is filed.
+    run_filed_issues: list[dict] = []
+    run_filed_by_title: dict[str, int] = {}
 
     for round_num in range(1, config.max_rounds + 1):
         report = RoundReport(round_num=round_num)
@@ -1002,6 +1136,10 @@ def run_bugbash(
         for lane in config.lanes:
             if lane_cost[lane.platform] >= config.cost_cap_per_lane:
                 report.skipped_lanes.append(lane.platform)
+                report.skip_reasons[lane.platform] = (
+                    f"cumulative cost {lane_cost[lane.platform]:.2f} already "
+                    f">= per-lane cap {config.cost_cap_per_lane:.2f}"
+                )
                 continue
             outcome = explorer(lane, round_num)
             lane_cost[lane.platform] += outcome.cost
@@ -1032,15 +1170,21 @@ def run_bugbash(
                 # finding disappear and pass the #3488 release gate).
                 report.protocol_error_lanes[lane.platform] = outcome.protocol_error
 
-        open_issues = open_issues_fetcher(config.repo)
+        # #3546: merge the fresh fetch with every issue THIS RUN has already
+        # filed — a finding matching one of this run's own earlier filings
+        # must be recognised by number even if the fresh fetch hasn't (yet)
+        # caught up with this process's own recent write.
+        open_issues = list(open_issues_fetcher(config.repo)) + run_filed_issues
         closed_issues = closed_issues_fetcher(config.repo)
 
         # Dedupe every finding exactly once (one question, one answer) —
         # everything below (the confirm gate's candidate list, new_count,
         # and the actual filing decision) reads off this SAME verdict per
-        # finding rather than re-asking dedupe_finding with a chance to
-        # disagree with itself.
-        dedupes = [dedupe_finding(f, open_issues, closed_issues) for f in report.findings]
+        # finding rather than re-asking dedupe with a chance to disagree
+        # with itself. `_dedupe_round_findings` also catches two lanes
+        # reporting the same bug in THIS round against each other, not just
+        # against issues that existed before the round started.
+        dedupes = _dedupe_round_findings(report.findings, open_issues, closed_issues)
 
         require_confirm = (not config.dry_run) and round_num <= config.confirm_rounds
         candidates = [
@@ -1071,17 +1215,39 @@ def run_bugbash(
                     )
                 )
                 continue
+            if dedupe.verdict is DedupeVerdict.DUPLICATE and dedupe.matched_number is None:
+                # #3546: a within-round duplicate from `_dedupe_round_findings`
+                # — its sibling finding may have already been filed earlier
+                # in THIS loop (in which case its real issue number is now in
+                # `run_filed_by_title`). Resolve it so the report/CLI shows
+                # the real number instead of a permanent "duplicate of
+                # #None".
+                resolved = run_filed_by_title.get(dedupe.matched_title or "")
+                if resolved is not None:
+                    dedupe = DedupeResult(
+                        verdict=dedupe.verdict, matched_number=resolved,
+                        matched_title=dedupe.matched_title, score=dedupe.score,
+                    )
             # An unresolvable lane (finding.platform not in this run's
             # config.lanes) is only a problem when it would actually be
             # queued — file_finding raises in that case, never silently
             # drops the machine target (#2096: a gate must be able to fail).
             result = file_finding(finding, dedupe, lane, runner, dry_run=config.dry_run)
             report.filings.append(result)
+            if result.filed and result.issue_number is not None:
+                # Only track filings that landed in config.repo's own
+                # namespace — a finding routed elsewhere via
+                # `finding_target_repo` (#3546 requirement 2) dedupes
+                # against THAT repo's issues, not this one's.
+                if finding_target_repo(finding) == config.repo:
+                    filed_title = compose_finding_issue_title(finding)
+                    run_filed_issues.append({"number": result.issue_number, "title": filed_title})
+                    run_filed_by_title[filed_title] = result.issue_number
 
         rounds.append(report)
 
         if report.new_count == 0:
-            # #2096/#3517: "zero findings" is only a genuine clean-pass
+            # #2096/#3517/#3546: "zero findings" is only a genuine clean-pass
             # verdict when at least one lane was actually verified to have
             # RUN THE CHECKLIST this round AND every lane that did complete
             # produced a trustworthy report. A round where every explored
@@ -1092,13 +1258,15 @@ def run_bugbash(
             # below since a bad answer is a stronger "don't trust this round"
             # signal than a lane simply being locked out; a round where every
             # explored lane instead reported its session/display unavailable
-            # (#3510 — locked or absent, never a dispatch failure) gets its
-            # own distinct "lanes_unavailable" reason last.
+            # (#3510 — locked or absent, never a dispatch failure), OR every
+            # configured lane was skipped on its cost cap with NONE explored
+            # at all (#3546), gets the same "lanes_unavailable" reason —
+            # neither is a verified clean pass.
             if report.all_explored_lanes_failed:
                 reason = "lane_failure"
             elif report.protocol_error_lanes:
                 reason = "protocol_error"
-            elif report.all_explored_lanes_unavailable_or_failed:
+            elif report.all_explored_lanes_unavailable_or_failed or report.all_lanes_skipped:
                 reason = "lanes_unavailable"
             else:
                 reason = "zero_findings"

{code_coordinator-0.5.572 → code_coordinator-0.5.574}/coord/commands/bugbash.py

@@ -50,6 +50,7 @@ from coord.bugbash import (
     ExploreOutcome,
     build_exploration_briefing,
     discover_lanes,
+    finding_target_repo,
     parse_findings_block,
     run_bugbash,
     subprocess_coord_runner,
@@ -228,6 +229,11 @@ def _print_round(report: BugbashReport) -> None:
             f"{r.new_count} new/regression, {sum(1 for f in r.filings if f.filed)} filed"
             + (f" (lanes skipped: {', '.join(r.skipped_lanes)})" if r.skipped_lanes else "")
         )
+        # #3546: a skip must be as explainable as a lane failure/
+        # unavailability — never a bare platform name with no reason.
+        for platform in r.skipped_lanes:
+            reason = r.skip_reasons.get(platform, "no reason recorded")
+            click.secho(f"  lane SKIPPED ({platform}): {reason}", fg="yellow")
         # #2096: a lane failure must be as visible as a filed finding — never
         # let a fleet-wide dispatch outage hide behind a quiet "0 finding(s)"
         # line that reads identically to a genuinely clean round.
@@ -241,12 +247,18 @@ def _print_round(report: BugbashReport) -> None:
             click.secho(f"  lane PROTOCOL ERROR ({platform}): {note}", fg="red")
         for f in r.filings:
             incomplete = " [INCOMPLETE REPORT]" if f.finding.incomplete else ""
+            # #3546: a finding routed by `suspected_repo` away from the app
+            # repo this round explored must say so here — an operator
+            # scanning "filed+queued: #42" has no way to tell it landed in
+            # coord's own repo rather than the app's without this.
+            target_repo = finding_target_repo(f.finding)
+            routed = f" [{target_repo}]" if target_repo != f.finding.repo else ""
             if f.filed:
-                click.echo(f"  filed+queued: #{f.issue_number} — {f.finding.title}{incomplete}")
+                click.echo(f"  filed+queued: #{f.issue_number}{routed} — {f.finding.title}{incomplete}")
             elif f.verdict.value == "duplicate":
-                click.echo(f"  duplicate of #{f.issue_number}: {f.finding.title}{incomplete}")
+                click.echo(f"  duplicate of #{f.issue_number}{routed}: {f.finding.title}{incomplete}")
             elif f.preview_title is not None:
-                click.echo(f"  would file ({f.verdict.value}): {f.preview_title}{incomplete}")
+                click.echo(f"  would file ({f.verdict.value}){routed}: {f.preview_title}{incomplete}")
 
 
 @click.command(

{code_coordinator-0.5.572 → code_coordinator-0.5.574}/coord/win_native_driver.py

@@ -810,6 +810,79 @@ def _popen_command_and_cwd(command: str, cwd: str) -> tuple[str, str | None]:
     return command, (cwd or None)
 
 
+#: #3544: every kwarg :meth:`Win32Calls.launch`/:meth:`~Win32Calls.launch_in_terminal`
+#: must pass to ``subprocess.Popen`` so the launched ``cmd.exe`` (and whatever
+#: GUI-subsystem grandchild it execs) never inherits this *process's own*
+#: stdin/stdout/stderr handles.
+#:
+#: Without this, a plain ``subprocess.Popen(command, shell=True, cwd=...)``
+#: (no ``stdin=``/``stdout=``/``stderr=``) hands the child Python's own
+#: standard handles unchanged — on Windows that's an inheritance, not a
+#: dup/close-on-exec situation. When this `Win32Calls` lives inside the
+#: `win-native` bridge runner (:data:`coord.win_native_bridge._BRIDGE_RUNNER_SRC`,
+#: a Windows-side ``python -c ...`` whose own stdout is a pipe the WSL-side
+#: ``subprocess.run(capture_output=True)`` is reading), that pipe write-end
+#: handle gets duplicated into the launched GUI exe. A GUI-subsystem process
+#: (``vimcode.exe``) never exits on its own — a human closes the window, or a
+#: spec step does — so it holds that handle open indefinitely. A pipe's
+#: read end only sees EOF once *every* write-end handle is closed; with the
+#: orphaned GUI exe still holding one, the WSL-side read blocks past the
+#: whole bridge script's own completion, for the full
+#: ``bridge_timeout``, even though the bridge runner itself finished and
+#: exited normally. ``Get-Process`` then shows the launched exe still
+#: running, orphaned, after the bridge has already timed out and raised.
+#:
+#: Redirecting all three standard streams to ``DEVNULL`` severs that
+#: inheritance: the child gets its own private, already-closed-on-the-
+#: parent-side handles, never a dup of this process's own pipe — nothing in
+#: this driver ever reads a launched app's stdout/stderr (the whole point
+#: of `win-native` is observing the real OS/window state, not console
+#: text), so there is no output to lose.
+#:
+#: **Mechanism caveat (review finding on #3544, unresolved).** CPython's
+#: own Windows ``subprocess._execute_child`` computes ``bInheritHandles``
+#: as ``int(not close_fds)``, and ``close_fds`` defaults to ``True``
+#: (Python 3.7+) and is never overridden anywhere in this module — so by
+#: that code path alone, a bare ``Popen(command, shell=True, cwd=...)``
+#: with no ``stdin=``/``stdout=``/``stderr=`` should *already* pass
+#: ``bInheritHandles=False`` to ``CreateProcess``, meaning CPython's own
+#: handle-inheritance bookkeeping is probably *not* the actual leak
+#: mechanism. The hang itself is real and reproduced (``Get-Process``
+#: showing the launched exe still running minutes after a timed-out bridge
+#: call — see #3544's repro), but the likelier remaining culprit is
+#: something outside CPython's control for this specific topology: the
+#: bridge runner is itself started from WSL via ``wsl.exe``/interop, not a
+#: plain native parent process, and WSL interop's own console/job-object
+#: handling for the Windows-side process tree it creates can share or
+#: re-parent handles differently than a same-OS parent/child pair would.
+#:
+#: This redirect is still the right thing to do regardless of which exact
+#: mechanism turns out to be responsible: explicit ``DEVNULL`` handles are
+#: a private pair nothing downstream can keep open, so it closes off every
+#: plausible inheritance path at once rather than betting on one theory of
+#: the leak being correct. Treat it as the best available fix, **not** a
+#: hardware-confirmed root-cause diagnosis — it has not been re-run against
+#: the issue's own two repro scripts on a real WSL<->Windows pairing
+#: (dell64). ``tests/test_win_native_driver.py``'s
+#: ``TestLaunchPipeInheritanceRealSubprocess`` is the closest reproduction
+#: available without that hardware: a real (unmocked) OS pipe + subprocess
+#: tree showing a long-lived grandchild can hold a parent's un-redirected
+#: stdout pipe open past the parent's own exit, and that the real
+#: ``Win32Calls.launch`` no longer does so once its grandchild's handles
+#: are redirected.
+#:
+#: ``launch_in_terminal`` already passes ``creationflags=CREATE_NEW_CONSOLE``
+#: for its spawned process, which per Windows' own docs already gives the
+#: child its own console instead of sharing/inheriting the parent's — so
+#: applying this redirect there too is defensive-in-depth, not evidence
+#: that call site was equally exposed to the leak this fix targets.
+_NO_HANDLE_INHERITANCE: dict = {
+    "stdin": subprocess.DEVNULL,
+    "stdout": subprocess.DEVNULL,
+    "stderr": subprocess.DEVNULL,
+}
+
+
 class Win32Calls:
     """The real :class:`WinCalls` implementation — ``ctypes`` for window
     management, input injection, menu/hit-test probing and ``PrintWindow``;
@@ -838,7 +911,9 @@ class Win32Calls:
 
     def launch(self, command: str, cwd: str) -> int:
         full_command, popen_cwd = _popen_command_and_cwd(command, cwd)
-        proc = subprocess.Popen(full_command, shell=True, cwd=popen_cwd)
+        proc = subprocess.Popen(
+            full_command, shell=True, cwd=popen_cwd, **_NO_HANDLE_INHERITANCE,
+        )
         return proc.pid
 
     def launch_in_terminal(self, command: str, cwd: str, terminal_app: str) -> int:
@@ -850,6 +925,7 @@ class Win32Calls:
         full_command, popen_cwd = _popen_command_and_cwd(full_command, cwd)
         proc = subprocess.Popen(
             full_command, shell=True, cwd=popen_cwd, creationflags=create_new_console,
+            **_NO_HANDLE_INHERITANCE,
         )
         return proc.pid