+ Wjpa0t$Rt^RIHt^RIt^RIt^RIt^RIt^RIt^RI H t ^RI H t H t Ht.RgOtRht]!0Rim4t0RjmtRRltRRlt]P,R 8HtR tR R ltR RltRRltRtRtRtRRltRRlt RRlt!RRlt"RRlt#RRlt$R R!/t%Rkt&R"R#R$R#R%R&R'R&R(]PNR)R*R+R,R-R,R.R#R/R0/ t(R1R2lt)/t*R3]+R4&R5R6lt,RlR7R8llt-R9R:lt.RlR;R<llt/]P`!R=]Pb4t2]P`!R>]Pb4t3]P`!R?]Pb4t4R@t5^t6RAt7RBt8RlRCRDllt9RERFlt:RGRHlt;RIRJltRORPlt?RQR/RRRSllt@RTRUltARVRWltBRXRYRZRR[RR\R]R^R/R_R`lltCRaRbltDRcRdltERZR/ReRflltFR#)muWindows subprocess compatibility helpers. * ``["npm", ...]`` — on Windows ``npm`` is ``npm.cmd``, a batch shim; ``Popen`` fails with WinError 193 because CreateProcessW can't run a ``.cmd`` without ``shell=True``/PATHEXT. * ``start_new_session=True`` — POSIX ``os.setsid()`` detach; silently ignored on Windows, whose equivalent is the ``CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW`` creationflags bundle. ) annotationsN)Path)MappingNoReturnSequencecV^8dQhRR/#)returnr)formats"QC:\Users\johnn\AppData\Local\hermes\hermes-agent\hermes_cli\_subprocess_compat.py __annotate__r <s(c  ^RIHpV!4R#))stop_for_relaunchN)hermes_cli._old_updaterr)cmdkwargsrs&, r runr<s 9rc V^8dQhRRRR/#)rargs Sequence[str]r list[str]r )r s"r r r Cs-Irc:\V4p^pV\V48d~W,pV\9d V^, pK.VPR4'd V^, pKPV\9d1VRV^,\\ 4,W^,R,#V#V#)azCopy of subcommand-first git *args* (no leading ``"git"``) with :data:`NO_DRIVER_DIFF_FLAGS` inserted right after a diff-rendering subcommand; other subcommands are returned unchanged. Pair with :func:`noninteractive_git_env`: the env layer disables fsmonitor/hooks/pager/editor/ credential sinks, this closes the one class (attacker-named attribute drivers) env cannot reach. -N)listlen_GIT_VALUE_OPTS startswith_DIFF_RENDERING_SUBCOMMANDSNO_DRIVER_DIFF_FLAGS)routitoks& r harden_git_argvr%Cs t*C A c#h,f / ! FA  >>#   FA  - -wQ<$';"<VPRR4pV'dV\P,V,MTVR&V#)uRe-add the ambient ``PYTHONPATH`` to a child environment that a ``build_subprocess_env``-style factory already built. No-boot-through-venv: the boot interpreter is the pm STORE python, whose imports arrive via ``PYTHONPATH=;/site-packages`` (it has no editable install). The subprocess-env factories strip Hermes-owned PYTHONPATH entries so agent-run children on DIFFERENT interpreter versions never load the backend's C extensions — but a child that re-execs THIS interpreter (``sys.executable -m hermes_cli.main``) runs on the same version and needs those entries back. Prepending keeps the launcher's repo-first ordering intact. PYTHONPATH)r8osenvirongetpathsep)r6mergedambientexistings& r restore_ambient_pythonpathrC}sX#YFjjnn\*G::lB//7Gbjj 8 +W | Mrc$V^8dQhRRRRRR/#)rnamer*argvrr rr )r s"r r r s!%%s%-%I%rcL\P!V4pT;'gT.VO#)u1Resolve a Node-ecosystem command name (``npm``, ``npx``, ``yarn``…) to an absolute-path argv. On Windows these ship as ``.cmd`` batch shims that CreateProcessW won't execute by bare name; ``shutil.which`` resolves via PATHEXT to a fully-qualified path whose extension routes it through ``cmd.exe /c``. )shutilwhich)rErFresolveds&& r resolve_node_commandrKs(||D!H    $t $$riiicV^8dQhRR/#rr intr )r s"r r r sVVcVrcV\'g^#\\,\,#)ulWin32 creationflags detaching a child from the parent console/group; 0 elsewhere. Pair with the default ``start_new_session=False`` (POSIX uses ``start_new_session=True``). CREATE_NEW_PROCESS_GROUP stops Ctrl+C propagating; CREATE_NO_WINDOW gives the child a hidden console descendants (git, gh, cmd, node, …) inherit so they don't flash — deliberately replacing the old DETACHED_PROCESS approach, which re-created the per-descendant console-flash bug (#54220/#56747) at every spawn; CREATE_BREAKAWAY_FROM_JOB escapes Electron/Tauri job objects. A job that forbids breakaway yields PermissionError from Popen — callers catch OSError and fall back to :func:`windows_detach_flags_without_breakaway`. Rationale: This both detaches it from the parent's console lifetime (closing the launching terminal doesn't CTRL_CLOSE it) AND gives every console-subsystem descendant (git, gh, cmd, node, …) a console to inherit, so they don't allocate visible flashing ones. This deliberately replaces the old ``DETACHED_PROCESS`` approach: MSDN specifies CREATE_NO_WINDOW is *ignored* when combined with DETACHED_PROCESS, and a truly console-less daemon re-creates the per-descendant console-flash bug (#54220/#56747) at every spawn — see the note on ``_DETACHED_PROCESS`` above. Electron (Desktop app) and Tauri (bootstrap installer) wrap their children in job objects; without breakaway, those children die when the parent process exits even though they have their own console. This was the missing flag that made the post-update gateway respawn watcher silently die alongside the Tauri updater after the Electron Desktop's update flow finished. )r1_CREATE_NEW_PROCESS_GROUP_CREATE_NO_WINDOW_CREATE_BREAKAWAY_FROM_JOBr rr windows_detach_flagsrSs, : $'8 8;U UUrcV^8dQhRR/#rMr )r s"r r r s999rc@\'g^#\\,#)zS:func:`windows_detach_flags` minus ``CREATE_BREAKAWAY_FROM_JOB``; 0 on non-Windows.)r1rPrQr rr &windows_detach_flags_without_breakawayrVs : $'8 88rcV^8dQhRR/#rMr )r s"r r r s22C2rc*\'d\#^#)aHWin32 creationflags hiding the child's console without detaching it; 0 elsewhere. For short-lived synchronous helpers (``taskkill``, ``where``, version probes): no flash, but the child stays in the parent's process group and job so Ctrl+C and job teardown still propagate. Stdio is inherited, so ``capture_output=True`` works. )r1rQr rr windows_hide_flagsrYs!+ 11rcV^8dQhRR/#rr r8r )r s"r r r s\\d\rc\\P4pRVR&RVR&R\PRVR\ 4/#)u``subprocess.run`` kwargs for the updater's network git calls. GitHub answers anonymous fetches with HTTP 401 during outages (and for unreachable repos); git then prompts ``Username for 'https://github.com':`` on the inherited terminal and the update sits there forever. Disable the prompt so the fetch fails fast into ``_classify_fetch_failure``. Only the *prompt* is disabled — a configured credential helper / askpass still runs, so a private-fork origin keeps authenticating non-interactively. Lives here, dependency-free, because the update hand-off's bootstrap interpreter runs the treeless conversion before any dependency exists. 0GIT_TERMINAL_PROMPTNeverGCM_INTERACTIVEstdinr6 creationflags)r8r<r= subprocessDEVNULLrY)r6s r no_prompt_git_kwargsresG rzz C!$C$C Z''_FXFZ [[rcV^8dQhRR/#rr Noner )r s"r r r s  t rc\'gR#^RIp\VR4'dRRlpWnR#R# \dR#i;i)uStub ``platform._syscmd_ver`` on Windows so it never flashes a console. No-op elsewhere. ``platform.win32_ver()`` shells out ``cmd /c ver`` without CREATE_NO_WINDOW, so a windowless parent (pythonw gateway, kanban workers) flashes a cmd window whenever a dependency touches ``platform.uname()`` at import. With the stub, ``win32_ver()`` takes its documented fallback to ``sys.getwindowsversion()`` — same data, in-process. Call before heavy imports. N _syscmd_verc WV3#Nr )systemreleaseversionsupported_platformss&&&&r _quiet_syscmd_ver8suppress_platform_ver_console.._quiet_syscmd_vers //r)r;r;r;)r&win16dos)r1platformhasattrrj Exception)rurqs r suppress_platform_ver_consolerxsG :   8] + + 0$5 ,    s!5 AAcV^8dQhRR/#r[r )r s"r r r s''T'rc:\'d R\4/#RR/#)zPopen kwargs detaching a child on Windows, or ``start_new_session=True`` on POSIX. Bare ``start_new_session=True`` is accepted but has no effect on Windows: the child stays attached to the parent console and dies when it closes. rbstart_new_sessionT)r1rSr rr windows_detach_popen_kwargsr| s# z!5!788  &&rGIT_NO_LAZY_FETCH1zcredential.helperr;z core.askPasszcore.fsmonitorfalsezcore.untrackedCachezcore.hooksPathz core.pagercatz core.editortruezsequence.editorz diff.externalzcore.sshCommandzssh -o BatchMode=yesc V^8dQhRRRR/#)rr6r7r tupler )r s"r r r 2s#4rcVPRR4pVPR4;'g!\PPVR4pVPR4;'gRVPR4;'g!\PPVR4\PPVR R 43p.pVF3pVP \P !V4P 4K5 VPR4VPR4VPR 4WPR4VPR 4.VO5# \dTP R 4Ki;i)zEverything that decides which files ``git config --system/--global`` reads, plus the global candidates' mtimes so an edit to ``~/.gitconfig`` is picked up without a restart.HOMEr;XDG_CONFIG_HOMEz.configGIT_CONFIG_SYSTEMz/etc/gitconfigGIT_CONFIG_GLOBALz .gitconfiggitconfigNGIT_CONFIG_NOSYSTEMPATH)r>r<pathjoinr3stat st_mtime_nsOSError)r6homexdg candidatesstampsrs& r _safe_directory_cache_keyr2s, 7762 D ''# $ E E T9(EC #$88(8 #$HH T<(H  S%*J F MM"''$-33 4 #$cgg.A&BCGGLaDb gg'(#''&/ rr8r_GIT_CONFIG_INJECT_PREFIXESpoprcrrdrYrSubprocessError returncodestdoutr2extend) r cache_keycachedr6keyvaluesscopeprocrecordss & r _user_safe_directoriesrKsW&*(3I " & &y 1F F| x.CCy ) )S^^>%{ expose_pm_git..s!N:3 v8Ms* *r)sysrurexistshermes_platform.resolverrpm.pathsrcommandresolveis_relative_torrr6nextitemsr<r=)rrrfoundrr6rs& r expose_pm_gitrs ||wtL'9F'B&J&J&L&L7# 5 ! ) )E T%(^++-<.sMPV 4'gK?VP7V 4VPV 4\V4\@8dR #V PCR^4^,R,pVV9gKVP7V4VPV4K \EVR,4pVU u.uFqR3NK up VU u.uFqR3NK up ,p\GV4F$wpwrWRVV, 2&WRVV, 2&K& \V\V4,4VR&V#uup iuup i)!a8Harden internal git for one repository, including named clean/smudge/process filters. The static environment can pin fixed config keys such as core.fsmonitor and core.hooksPath, but a repository chooses filter driver names through .gitattributes. Discover the effective filter command keys for this checkout and append empty command overrides plus required=false to the already-isolated config block. Discovery is bounded and fail-closed: if filter discovery cannot be trusted, callers skip the automatic git operation instead of running with only partial hardening. r-Crz --includesz --show-originrz --get-regexprr6Nr:rNr:Nr zfile:GIT_DIR GIT_WORK_TREEz rev-parsez--show-toplevelz z--filez --name-onlyc3L"TFp\PV4xK R#5irl) _INCLUDE_KEY fullmatch)rrEs& r r.noninteractive_repo_git_env..@s>|%%d++s"$TF.z .requiredrr;rrr)rr)$rbounded_probe_runr*_DISCOVERY_KEYS_REGEXPrsetrr2zip partition_INCLUDE_IF_KEYrr3rrr is_absoluter>rstripparentr<r expanduserrris_file_MAX_INCLUDE_TARGETSaddanyrstrip_FILTER_COMMAND_KEY_MAX_FILTER_KEYSrsplitrNr)rrr6rnamestargetstoplevelfieldsoriginentryr_r origin_pathtoptargetproberkeysrequiredseenraw required_keystartroffsets&& r noninteractive_repo_git_envrs ! &C  c#h,~  !s D  |tf4EG H [[  t $FVD\6$<8 - ((-- LL    ))6#g,-01 &&((wwy!!SWW_%=%='c#h M^(_01s<;#..A"5 1 1& 9:"0K$$rww'9'9%'@@IIK  FMMOO ~~3w<3G#G F! HhF ]D.Zp q3  =E,,F: ""4( 3>>333>> > > UK9NDHUDiikcTk)<)F)Fs)K)K    C t9' 'zz#q)!,{: t # HH\ " OOL ) &' (E&*+dsrd+.R#W~.RRI )) 4 25oefn- ./49/ 01!5"%#i."89C J ,.Rs  Q1 Qc V^8dQhRRRR/#rpidrNr boolr )r s"r r r _src >\RV R2RR7;_uu_4pVP4P4pRRR4\X4^8;'d V^,R8H# +'giL2;i \d\ P !RRR R \T4.R R RR ^R R7pTP^8H;'d*TPP4PR4u# \dR #i;i\\\3dR #i;i)zWZombie via ``/proc//stat`` field 3, or ``ps -o state=`` without /proc (macOS/BSD).z/proc/z/statr)rNZpsz-ozstate=z-pTrF)rrrrrr)openreadr2rFileNotFoundErrorrcrr*rrrrrw IndexErrorPermissionErrorr)rfh stat_fieldsrs& r posix_is_zombier)_s F3%u% 8 8B'')//+K9;!#== A#(==9 8   tXtSX6#$\]A <<1$II)9)D)DS)I I       1   s^A7A$A7 A7$ A4 /A77 DAC0)C0-D0 D;D?DDDDc V^8dQhRRRR/#rr )r s"r r r ts#$rc^RIpVPPpVPVPnVP VPnVP VPnRRrCR^reVP W4,RV4pV'gVP4V8H#VPV^4V8HVPV4# TPT4i;i \\3dR#i;i)zGpsutil-free Windows liveness probe via OpenProcess/WaitForSingleObject.NiiiF) ctypeswindllkernel32c_void_p OpenProcessrestypec_uintWaitForSingleObject GetLastError CloseHandlerAttributeError)rr,r.!PROCESS_QUERY_LIMITED_INFORMATION SYNCHRONIZE WAIT_TIMEOUTERROR_ACCESS_DENIEDhandles& r win32_pid_existsr<ts==))'-$/5}}$$,(. %9?;,6)%%&G&UW\^ab((*.AA A )//:lJ   (H  ( ^ $s*B$C$(C<C$C!!C$$C98C9c V^8dQhRRRR/#rr )r s"r r r s34rc\V4p\'d \V4#\V4'dR#\P !V^4R# \ dR#\dR#i;i)aStdlib-only "is this PID alive" check that never signals the target (zombies report dead). For code that must run without the dependency environment: the detached gateway restart watcher is started by whatever interpreter the updater runs on (the bare store Python after the package-manager handoff), so it cannot import ``gateway.status`` (``utils`` pulls in ``ruamel``). ``gateway.status._pid_exists`` prefers psutil and falls back to this. FT)rNr1r<r)r<killr%r)rs&r pid_exists_stdlibr@sa c(Cz$$s Q   sA A,A,'A,+A,c V^8dQhRRRR/#)rrrNr int | Noner )r s"r r r sSZrcD^RIHpV!V4# \dR#i;i)z@The repository's stable process-start fingerprint, if available.)get_process_start_timeN)gateway.statusrDrw)rrDs& r _process_start_timerFs'9%c** s  c V^8dQhRRRR/#)rrr*r rr )r s"r r r sGGSGTGrc\;QJd?R\P!RVP444F 'gK R# R#!R\P!RVP4444#)uTrue when *text* names Hermes at a path-segment / token boundary. A bare ``"hermes" in text`` substring test would also match unrelated processes whose paths merely contain the letters (``...\shermesa\...``) — the false-positive class this prevents. c3D"TFpVPR4xK R#5i)hermesN)rJz.hermes)r)rtokens& r r%_text_names_hermes..s'GE5 566Es z[\\/\s=,;\"']+TF)rrer2lower)rs&r _text_names_hermesrOsk 3GHH%6 EG33G3G3GHH%6 EG GGrc V^8dQhRRRR/#rr )r s"r r r s  C D rc^RIpVPV4pRPVP4;'g.4pVP 4;'gRp\ V RV 24# \ dR#i;i)z8Best-effort check that *pid* currently runs Hermes code.N r;F)psutilProcessrcmdlineexerOrw)rrSprocessr executables& r _process_command_is_hermesrYsp..%((7??,223[[]((b !WIQzl";<< s6A*A*A** A98A9expected_start_timec$V^8dQhRRRRRR/#)rrrNrZrBr rr )r s"r r r s!sJ$rcn\V\4'd\V\4'gV^8:dR#\'gVfR#\ V4V8H#\ V4pTfR#Te Y!8wdR#\ T4# \ dR#i;i \ dR#i;i \ dR#i;i)a1Whether it is safe to use ``taskkill`` for *pid*. The PID must be valid, currently exist, and identify a Hermes process. When the caller captured a start-time fingerprint before the destructive action, the live process must still have the same ``(pid, start_time)`` identity. Any ambiguity fails closed. FT) isinstancerNrr1rFrwrY)rrZcurrent_start_times&$ r pid_is_hermesr_s c3  :c4#8#8C1H :  & &s+/BB B05!&+=+T)#..    s6 B B6 B% BB B"!B"% B43B4c V^8dQhRRRR/#rrsubprocess.Popenr rhr )r s"r r r s  ,  rc^RIHpV!VP4TP 4R# \d\ T4R#i;i \ dR#i;i)u-Best-effort terminate *proc* and its descendants on both platforms; never raises. ``proc.kill()`` alone only terminates the direct child. This is cleanup on an already-failing path whose contract is to fail open, so every failure (access denied, already reaped) is swallowed rather than escaping the caller's ``except``. On Windows a suspended descendant (e.g. ``git.exe``) can survive holding duplicates of the captured pipe handles, which keeps the pipes from reaching EOF and leaks two reader threads + the process per fired timeout — ``taskkill /T /F`` takes the whole tree down so the bounded drain that follows can actually reach EOF. On POSIX the same class exists: killing the launcher leaves descendants (credential helpers, ``git-remote-https``, hook children) running and holding the pipe write ends. Callers spawn the child in its own process group (``process_group=0``, Python ≥3.11), so when — and only when — the child leads its own group (``pgid == pid``), the entire group is signalled with ``os.killpg``. The ownership check means a fallback spawn that shares our group can never cause us to kill unrelated processes. Ported from openai/codex#36793 ("Terminate timed-out Git process trees"); generalized for the shell-hook runner via openai/codex#37527 ("Terminate timed-out hook process trees"). )kill_process_treeN)agent.deadlinerdrrw_legacy_kill_process_treer?r)r_deadline_kill_trees& r rdrdsS$KDHH%   !$'    s -A AA AAc V^8dQhRRRR/#rar )r s"r r r s$4rc >\'gV^RIp\P!VP4pW P8Xd!\P !W!P 4VP4\'dk\P!RRRR\VP4.\P\P\P^R\4R7R#R# \dLi;i \dLi;i \dR#i;i)zULocal tree-kill fallback when agent.deadline is unavailable (partial install, cycle).Ntaskkillz/Tz/Fz/PIDF)rstderrrarrrb)r1signalr<getpgidrkillpgSIGKILLrwr?rrcrr*rdrY)r_signalpgids& r rfrfs :  $::dhh'Dxx $0  z  NNJdFCMJ","4"4Z=O=O!+!3!3Qe);)= ?            s7AC+#C<A'D + C98C9< D  D  DDrrr6rraise_on_spawn_failureFinputc8V^8dQhRRRRRRRRR R R R R RRR/#)rrFrrfloatrr*r6rrzstr | os.PathLike[str] | Nonerrrrsz str | Noner z'subprocess.CompletedProcess[str] | Noner )r s"r r r s\1T1T 1T%*1T471T !1T/L1T!1T2<1T- 1TrcL\'d R\4/MR^/pRp^RIHp T !\ V43R\ P R\ P RVf\ PM\ P RR R R R TR Ve \V4MRRV/VBwrT PYaR7wr\T4\ P!\ T4T PY4# \dT'dhR#i;i \d\T4\T ^4R#i;i)u?Deadlock-safe ``subprocess.run(argv, capture_output=True, timeout=…)`` for fail-open probes. ``input`` is written to the child's stdin (closed afterwards); without it stdin is ``DEVNULL``. Returns a ``CompletedProcess`` when the child finished within *timeout* (any exit code), or ``None`` on spawn failure or timeout. With ``raise_on_spawn_failure=True`` the ``Popen`` exception propagates instead, so callers that treat a *timeout* as a verdict can still tell "our own probe never started" apart from "the child hung". Why not ``subprocess.run``: on Windows, ``run()``'s post-timeout cleanup calls an *unbounded* ``communicate()`` after killing the direct child. Killing it can leave a descendant (``git.exe`` under a launcher shim, ``conhost.exe`` under wmic/powershell) holding duplicates of the captured stdout/stderr handles, so the pipes never reach EOF and the reader-thread join blocks forever. The wmic / ``Get-CimInstance Win32_Process`` gateway scan hit exactly this during ``hermes update`` on slow-WMI machines (#87134); the git probes hit it first (#68609 / #66037). rb process_groupN) spawn_serverrrkrarTrrrr6r)rsr)r1rY"hermes_cli.local_runtime.processesrxrrcPIPErdr8rw communicate _close_jobkill_and_drainCompletedProcessr) rFrrr6rrrrs _popen_kwargsjobrxrrrks &$$$$$$ r rrsG*FPZ?,>,@AVeghUiM C D JR)R7AR(- *$$:??RR!(R17R!_S $ R=@ RDQ R )))GsO  & &tDz4??F SS  !   3tQ s*A7C"C="C:5C:9C:="D#"D#c$V^8dQhRRRRRR/#)rrrbsecondsrur z tuple | Noner )r s"r r r Rs"  ) E l rc\V4VPVR7# \\\P 3dR;Tn;TnTnR#i;i)a\Tree-kill *proc* (:func:`kill_process_tree`), then read what its pipes still hold for at most *seconds*: ``(stdout, stderr)``, or ``None`` when a descendant the kill missed still holds them. Those pipes are left to ``communicate()``'s reader threads, never closed (closing a pipe a thread is reading blocks; a ``with Popen`` exit would close them).)rN) rdr{r ValueErrorrcrrarrk)rrs&&r r}r}RsY d00 Z!;!; <155 5T[4;s5AAcV^8dQhRR/#rgr )r s"r r r _s  t rcXVfR#VP4R# \dR#i;irl)closerw)rs&r r|r|_s* {     s  ))c(V^8dQhRRRRRRRR/#) rrFrrrur6rr r*r )r s"r r r hs*))M)u)C[)gj)rc\Y/T;'g \4C\CR7pVeVP^8wdR#VP;'gRP 4#)ulRun a short ``git`` probe and return stripped stdout, or ``""`` on ANY failure. On Windows ``run()``'s post-timeout cleanup calls an unbounded ``communicate()``; a suspended descendant git.exe holding the pipe handles then blocks forever. Here: bounded ``communicate``, tree-kill plus a 1s drain, then abandon the pipes; on POSIX the probe gets its own process group so cleanup also takes down credential/remote helpers. Security (GHSA-7x36-8jrh-v4pw): these probes run automatically against whatever directory the session sits in, before any tool call or trust prompt, and an index refresh executes the repo-configured ``core.fsmonitor`` program. Every probe therefore runs under :func:`noninteractive_git_env`; diff-rendering callers additionally pass :data:`NO_DRIVER_DIFF_FLAGS` (attribute-scoped drivers can't be disabled via env). Killing the PATH-resolved launcher can leave a suspended descendant ``git.exe`` holding duplicates of the captured stdout/stderr handles, so the pipes never reach EOF and the reader-thread join blocks forever. On the Desktop agent-build path (``_start_agent_build → _session_info → branch() → run_git``) that turned an optional branch label into ``agent initialization timed out`` (issues #68609 / #66037). The normal-path spawn contract mirrors the previous ``run`` call byte-for-byte: PIPE/PIPE/DEVNULL, ``text`` with UTF-8 ``errors="replace"`` decoding, and the hidden-window ``creationflags`` on Windows only. On POSIX the probe is additionally placed in its own process group (``process_group=0``, Python ≥3.11) so timeout cleanup can take down descendants — credential helpers, ``git-remote-https``, hook children — with the launcher instead of orphaning them (see :func:`kill_process_tree`; port of openai/codex#36793). ``process_group`` only changes which group the child belongs to; it does not detach the terminal or alter the fast path. rr;)rrNO_LAZY_FETCH_ENVrrr)rFrr6results&$$ r bounded_git_proberhsX4t:tc>]>]E[E]:tbs:t uF ~**a/ MM  R & & ((r)FILTER_DISCOVERY_FAILEDr1r!rrrrrrr@r_rKrCrr4rxrSrVr|rY)z --no-ext-diffz --no-textconv>logdiffshowblame>r-c --git-dir --exec-path --namespace --work-tree)rrrl)G__conditional_annotations____doc__ __future__rr<rMrHrcrpathlibrtypingrrr__all__r! frozensetr rrr%rur1_WINDOWS_GATEWAY_BREAKAWAY_ENVr4rCrKrPrQrRrSrVrYrerxr|rrrrrr__annotations__rrrrcompile IGNORECASErrrrrrrrr)r<r@rFrOrYr_rdrfrr}r|r)rs@r rs&#  .. <:((HIY.\\W $ "=:.%' (V692\& .' )#. GBg7bjj%6vR -$,13-22j  ":<~jj!JBMMZ **5r}}Ezz7G d7\~*2,G < @81T:C1T$(1TOS1T$)1T?C1Th  )^b))r