yj :UdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z ejdkZddlmZmZmZddlmZddlmZmZddlmZmZmZmZdd lmZdd l m!Z!ej"e#Z$ed z Z%d Z&d Z'dZ(dZ)dZ*dZ+dZ,dZ-dZ.da/ee0e1d<e j2Z3da4dZ5dZ6dZ7dZ8de9fdZ:de0fdZ;de0fdZd!e=de0fd"Z?d#e9de=fd$Z@eGd%d&ZAGd'd(ZBeBZCd#eDde=fd)ZEd*eFde=fd+ZGd*eFdd,fd-ZHdd.lImJZJmKZKd/d0d1d2gd3d4d5d2d6d7d2d8d7d9d:d;d<d9d=d7d9d>d;d<d?d@gdAdBZLdCeFdeFfdDZMdEZNeJjOd/dFeLeNdGHdS)Ia Process Registry -- In-memory registry for managed background processes. Tracks processes spawned via terminal(background=true), providing: - Output buffering (rolling 200KB window) - Status polling and log retrieval - Blocking wait with interrupt support - Process killing - Crash recovery via JSON checkpoint file - Session-scoped tracking for gateway reset protection Background processes execute THROUGH the environment interface -- nothing runs on the host machine unless TERMINAL_ENV=local. For Docker, Singularity, Modal, Daytona, and SSH backends, the command runs inside the sandbox. Usage: from tools.process_registry import process_registry # Spawn a background process (called from terminal_tool) session = process_registry.spawn(env, "pytest -v", task_id="task_123") # Poll for status result = process_registry.poll(session.id) # Block until done result = process_registry.wait(session.id, timeout=300) # Kill it process_registry.kill(session.id) N)PathWindows) _find_shell_resolve_safe_cwd_sanitize_subprocess_env)windows_hide_flags) dataclassfield)AnyDictListOptional)get_hermes_home)redact_sensitive_textzprocesses.jsoni@ i@iQ _SYSTEMD_SCOPE_AVAILABLEgN@ii@lreturncd}tjdd}|r^d} t|dzdz}|tkr|}d}n#t $rYnwxYw|s$t d|tdzg} td  d  D]}| d r| d d d}td|z dz d }|r/t|}|tkr||nn#t t f$rYnwxYw ttjdttjdz} t%t&t)t| dz} || n#t t t*f$rYnwxYw|rt%|nt,} |rt%|| n| S)aUReturn a finite per-worker cgroup limit without widening host risk. The proposed local-memory-guard environment override is honored when it tightens the safe bound, so this isolation composes with PR #57121 instead of inventing a second knob. An oversized override cannot widen host risk. Otherwise retain the tighter of the gateway's current cgroup-v2 ``memory.max`` and half of physical RAM, capped at 4 GiB. This keeps the sibling worker outside the gateway cgroup while ensuring the worker cannot consume memory up to the enclosing user slice or host limit. NTERMINAL_LOCAL_MEMORY_MAX_MBFiTzbIgnoring invalid TERMINAL_LOCAL_MEMORY_MAX_MB=%r; expected an integer representing at least %d MiBiz/proc/self/cgrouputf-8encodingz0::z::/z/sys/fs/cgroupz memory.max SC_PHYS_PAGES SC_PAGE_SIZE)osgetenvstripint_MIN_WORKER_MEMORY_MAX_BYTES ValueErrorloggerwarningr read_text splitlines startswith partitionlstripisdigitappendOSErrorsysconfmin_WORKER_MEMORY_MAX_CAP_BYTESmax TypeError _DEFAULT_WORKER_MEMORY_MAX_BYTES) override_boundoverrideoverride_validparsed candidateslinerelative raw_limit cgroup_limitphysical_bytesphysical_bound safe_bounds >$//299#>>)**X5 D)W)--eegg$$&&8#&y>>L#'CCC")),777  Z        RZ8899C J~ & &= =   ( ,n.A B B   .)))) Z +     %/TZ4TJ.< L3~z * * **Ls7$A A! A! C;F FF!BH%%H?>H?ct}tj}|durdS|dur|tz tkrdSt 5t}tj}|dur ddddS|dur!|tz tkr ddddSd}t s ddl}|d}|rdtj dtj j dd}tj|d d d d |d ddddt!ddddgdd}|jdk}|sNt$d|j|jpdddn2#t.$r%}t$d|Yd}~nd}~wwxYw|atja|cdddS#1swxYwYdS)uReturn True if ``systemd-run --user --scope`` can create a cgroup. Cached after the first probe. ``shutil.which`` alone is insufficient: in system-service deployments (and containers) the user D-Bus session bus that ``systemd-run --user`` needs may be absent even though the binary is on PATH, causing every spawn to fail with ``Failed to connect to user bus``. We do a cheap no-op probe (``systemd-run --user --scope --unit=… -- /bin/true``) and remember the outcome. TFNr systemd-runzhermes-probe-scope----user--scope--quiet--unit --collect --propertyMemoryAccounting=yes MemoryMax=OOMPolicy=kill--z /bin/truercapture_outputtimeoutz3systemd-run --user --scope probe failed (rc=%s): %srreplacez*systemd-run --user --scope probe error: %s)rtime monotonic_SYSTEMD_SCOPE_PROBED_AT"_SYSTEMD_SCOPE_FAILURE_TTL_SECONDS_SYSTEMD_SCOPE_PROBE_LOCK _IS_WINDOWSshutilwhichr#getpiduuiduuid4hex subprocessrunrF returncoder)debugstderrdecoder% Exception)cachednow availabler`binary probe_unitresultexcs rE!_systemd_run_user_scope_availablerts&F .  C ~~t% * *-O O Ou #22)n T>> 22222222 eOO..01122222222 ! P P m44"\ry{{![![TZ\\EUVXWXVXEY![![J'^"Hi$j'(*@(*S7O7Q7Q*S*S(*: ' (, !   F!' 1Q 6I$ Q"-#]1c99 '#egg  P P P I3OOOOOOOO P$- #'>#3#3 e222222222222222222sI G.G GC"FG F0 F+&G+F00GGGc"tjddkrdS ddlm}ddlm}|o |dtjkS#t$r&}t d|Yd }~dSd }~wwxYw) aReturn whether this process is in a supervised Hermes gateway runtime. Both supervisor markers and ``_HERMES_GATEWAY`` are inherited by every descendant, and importing ``gateway.run`` also sets the latter. Require this process to own the live gateway PID file as well. That keeps transient systemd scopes limited to the gateway itself instead of terminal children or unrelated interactive CLIs in the same supervised process tree. _HERMES_GATEWAY1Fr)is_gateway_supervisor_process)get_running_pid) cleanup_stalez8Could not verify supervised gateway process identity: %sN) r#environgetgateway.restartrxgateway.statusryrbrlr)ri)rxryrss rE_is_supervised_gateway_processrs z~~'((C//u AAAAAA222222 * ) + + De444 C   OQTUUUuuuuus6A B(B  B shell_argv unit_suffixcddl}|d}||Sd|}t}|dddd|d d d d d |d d dg|S)adWrap *shell_argv* in a ``systemd-run --user --scope`` invocation. The resulting cgroup gets its own memory accounting so an OOM in the worker does not kill the gateway cgroup (#70716). ``--collect`` makes the transient scope self-clean after exit; ``--unit`` gives it a recognisable name for ``systemctl --user status`` / journalctl. rNrHhermes-worker-rKrLrMrNrOrPrQrRrSrT)r`rarF)rrr`rp unit_name memory_maxs rE_build_systemd_scope_argvrsMMM \\- ( (F ~...I)++J!Z!!    rXrcddl}|d}|dS tj|dd|gdd }|jdkr|jpd d }|tfd dDrdSt d||j|dSdS#t$r'}t d||Yd}~dSd}~wwxYw)u)Stop a transient systemd user scope by unit name. This reaps the *entire* cgroup — catching double-forked descendants that survive a plain PID signal because they were reparented to init inside the scope (issue #70716, reviewer gap #2). ``systemctl --user stop`` sends SIGTERM to every process in the unit's cgroup and escalates to SIGKILL after the unit's ``TimeoutStopSec``. Returns True if the unit was successfully stopped (or was already gone), False if ``systemctl`` is unavailable or the stop command failed. rN systemctlFrKstopTrrUrXrYerrorsc3 K|]}|vV dSN).0marker stderr_lowers rE z%_stop_systemd_unit..Rs<,&rX)z not loadedz not foundzdoes not existz&systemctl --user stop %s exited %d: %sz#systemctl --user stop %s failed: %s) r`rarfrgrhrjrkr%loweranyr)rirl)rr`rprrrjrsrs @rE_stop_systemd_unitr8sNMMM \\+ & &F ~u Xvy 1      ! !m*s22)2DDJJLLF!<<>>LK t LL86,    5t  :IsKKKuuuuusBC &"C C=C88C=secondsctdt|}|dkr|dSt|d\}}|dkr|d|dSt|d\}}|d|dS)Nr<szm zh m)r6r&divmod)rrminssecshourss rEformat_uptime_shortrcs As7||A2vvwww2JD$ byy!!$!!!!r""KE4  t   rXceZdZUdZeed<eed<dZeed<dZeed<dZe e ed<dZ e e j ed <dZeed <dZe eed <d Zeed <dZe e ed<dZeed<dZe e ed<dZeed<dZeed<dZeed<eZe ed<dZeed<dZeed<dZeed<dZeed<dZ eed<dZ!eed<dZ"eed<dZ#eed<dZ$eed<d Z%e ed!<dZ&eed"<e'e(#Z)e*eed$<e'd d%Z+e ed&<e'd d%Z,e ed'<e'dd%Z-eed(<e'd d%Z.eed)<e'd d%Z/eed*<e'dd%Z0eed+<e'd d%Z1e ed,<e'e2j3d-Z4e2j3ed.<e'e2j5#Z6e2j5ed/<e'dd%Z7e e2j8ed0<e'dd%Z9eed1<dS)2ProcessSessionz3A tracked background process with output buffering.idcommandrtask_id session_keyNpidprocessenv_refcwdr started_athost_start_timeFexited exit_codecompletion_reasontermination_source output_buffermax_output_charsdetachedhost pid_scope systemd_unitwatcher_platformwatcher_chat_idwatcher_user_idwatcher_user_namewatcher_thread_idwatcher_message_idrwatcher_intervalnotify_on_complete)default_factorywatch_patterns)defaultrepr _watch_hits_watch_suppressed_watch_disabled_watch_last_emit_at_watch_cooldown_until_watch_strike_candidate_watch_consecutive_strikes)rr_completion_event_lock_reader_thread_pty):__name__ __module__ __qualname____doc__str__annotations__rrrrr&rrfPopenrr rrfloatrrboolrrrrMAX_OUTPUT_CHARSrrrrrrrrrrrrr listrr rrrrrrr threadingEventrLockrrThreadrrrXrErrnsh== GGG LLLGSKC#*.GXj& '...GSC#J%)OXc])))FD#Ix}###%s%%%    M3,c,,,HdIsL#cOSOSss    c$$$$ %d ; ; ;NDI;;;uQU333K333"U15999s999!E%e<<AAA16t%1P1P1PNHY-.PPPd///D#/////rXrceZdZdZdZdZededefdZde dedd fd Z de d edd fd Z d e de fdZedeede fdZedeedeefdZedeedeede fdZdee dee fdZede fdZede fdZedYdedeedd fdZededefdZ dZdedededed ed!e de fd"Z d[dededededed$ede fd%Zde fd&Zde ded'ed(ed)ef d*Zde fd+Z de fd,Z!d-ede fd.Z"d-ede fd/Z#d0d1d-ed2e de fd3Z$ d\d0d1ded2e dd4fd5Z%d-edee fd6Z&d]d8Z'd-edefd9Z(d^d-ed;ed zdZ*d?d0d@d-edAedBe defdCZ+d-edDedefdEZ,d_d-edDedefdFZ-d-edefdGZ.d-edefdHZ/defdIZ0d`dedede1fdJZ2dede fdKZ3 dYdedLee de fdMZ4de fdNZ5dede6efdOZ7dedAedefdPZ8 dYe6dQddRdeedSe6dAedBe def dTZ9dUZ: dYdVee;ed S)aProcessRegistrya$ In-memory registry of running and finished background processes. Thread-safe. Accessed from: - Executor threads (terminal_tool, process tool handlers) - Gateway asyncio loop (watcher tasks, session reset checks) - Cleanup thread (sandbox reaping coordination) )z'bash: cannot set terminal process groupz"bash: no job control in this shellzno job control in this shellz!cannot set terminal process groupz)tcsetattr: Inappropriate ioctl for deviceci|_i|_tj|_g|_ddl}||_ ddl m }||jn2#t$r%}t d|Yd}~nd}~wwxYwt|_t|_tj|_d|_d|_d|_d|_d|_d|_dS)Nr)restore_undelivered_completionsz2Could not restore async delegation completions: %sr)_running _finishedrrrpending_watchersqueueQueuecompletion_queuetools.async_delegationrrlr)r*set_completion_consumed_poll_observed_global_watch_lock_global_watch_window_start_global_watch_window_hits_global_watch_tripped_until$_global_watch_suppressed_during_trip on_outputon_close)self _queue_modrrss rE__init__zProcessRegistry.__init__s&35 46^%% 79 #"""2<2B2B2D2D V N N N N N N + +D,A B B B B V V V NNOQT U U U U U U U U V*-!$'55 #,."2"214'./&25(9:1  s A## B-B  Btextrc|dratfdtjDr<dr%tfdtjD.s,cc%EU1X-ccccccrXr)splitrr_SHELL_NOISE_SUBSTRINGSpopjoin)rrs @rE_clean_shell_noisez"ProcessRegistry._clean_shell_noises 4   cccc?;bccccc  IIaLLL cccc?;bccccc yyrXsessionchunkNc\|j}||sdS |||dS#t$rYdSwxYw)zForward a freshly-read chunk to the live-output sink, if one is set. Called from reader threads; never raise into the read loop.N)rrl)rrrsinks rE _emit_outputzProcessRegistry._emit_outputsX~ |sdSt j}d}|j5|jri||jkr^|xj t|z c_ |j s7d|_ |xj dz c_ |j tkrd|_d|_d}d} nR|jr|j sd|_ d|_ ||_|t z|_|xjdz c_|j } d|_ d} dddn #1swxYwY| rv|rr|j|j|j|jd|j |j|j|j|j|j|jd|jdtd t d d dSd |dd } t| dkr | dddz} ||sdS|j|j|j|jd|| | |j|j|j|j|j|jd dS)uzScan new output for watch patterns and queue notifications. Called from reader threads with new_text being the freshly-read chunk. Per-session rate limit: at most ONE watch-match notification per WATCH_MIN_INTERVAL_SECONDS. Any match arriving inside the cooldown window is dropped and counts as ONE strike for that window. After WATCH_STRIKE_LIMIT consecutive strike windows, watch_patterns is disabled for this session and the session is promoted to notify_on_complete semantics — one notification when the process actually exits, no more mid-process spam. NFTrwatch_disabledz$Watch patterns disabled for process u — z7 consecutive rate-limit windows triggered (min spacing zms). Falling back to notify_on_complete semantics; you'll get exactly one notification when the process exits.) session_idrrtype suppressedplatformchat_iduser_id user_name thread_id message_idmessageriz ...(truncated) watch_match) rrrr patternoutputr r r r rrr)rrrr,r1rstriprZrrrlenrrWATCH_STRIKE_LIMITrrWATCH_MIN_INTERVAL_SECONDSrrputrrrrrrrrrr_global_watch_admit) rrr matched_linesmatched_patternr>patrnshould_disable return_earlyr rs rE_check_watch_patternsz%ProcessRegistry._check_watch_patternss% )@  F >  F ''))  D-  $;;!((777&.*-E    Fikk ]% %% % , %w7T1T1T))S-?-??))6 .6:G366!;669=OOO26/6:2)-# 1;#;;:;G627//2+036P0P-##q(##$6 ,-)$ K% %% %% %% %% %% %% %% %% %% %% %% %% %% %% %N   %))")*#*#6&,")"; ' 8&6&6!(!:!(!:")"<LwzLL-LL(BLLL++( F="-.. v;;  ETE]%77F'',,  F !!!*".!&$0.. 2 2!4# #      sCEE#&E#rnc |j5|jrJ||jkr?|j}d|_d|_||_d|_|dkrdddd|d|ddddddd }nd}nd}|jr ||jkr|xjd z c_d }d}ni||jz t kr||_d|_|jt kr$|tz|_|xjd z c_|}d }n|xjd z c_d}d }dddn #1swxYwY||j ||>|j dddd d t dt dtddddddd |S)a1Return True if this watch_match event is allowed through the global breaker. Semantics: - If we're currently in a cooldown period, drop the event and count it. - Otherwise, slide the rolling window and check the global cap. - If the cap is exceeded, trip the breaker for WATCH_GLOBAL_COOLDOWN_SECONDS and emit ONE summary event so the agent/user sees "N notifications were suppressed" instead of getting them individually. - When the cooldown ends, emit a release summary and reset counters. rrrwatch_overflow_releasedz%Watch-pattern notifications resumed. z1 match event(s) were suppressed during the flood.) rrrr r rr r r rrNrFTwatch_overflow_trippedzWatch-pattern overflow: >z notifications in zCs across all processes. Suppressing further watch_match events for s.) rrrr rr r r rr) rrrrrWATCH_GLOBAL_WINDOW_SECONDSWATCH_GLOBAL_MAX_PER_WINDOWWATCH_GLOBAL_COOLDOWN_SECONDSrr)rrnr  release_msgadmittrip_nows rErz#ProcessRegistry._global_watch_admitsb $3 !3 !/ #C4;[4[4[!F 360<=925/12.>>')')#% 9&0])]]]%'#%#%%'%'##KK"#'KK" / !C$:Z4Z4Z99Q>9988A;c ddl}|sdS||jkS#t$rYdSwxYw)zTrue if a psutil.Process is running and not a zombie. A zombie is already dead (just unreaped), so there's nothing to SIGKILL. rNF)psutil is_runningstatus STATUS_ZOMBIErl)procr:s rE _proc_alivezProcessRegistry._proc_alives_   MMM??$$ u;;==F$88 8   55 s99 AAc ddlm}m}m}|}||dd}||dd}t t |dS#t $rYdSwxYw)a%Grace window (s) between SIGTERM and escalated SIGKILL. Read from ``terminal.daemon_term_grace_seconds`` in config.yaml; floored at 0 (0 disables escalation). Falls back to the DEFAULT_CONFIG value if config is unreadable, so callers always get a sane number. r)read_raw_configcfg_getDEFAULT_CONFIGterminaldaemon_term_grace_secondsNrg@)hermes_cli.configrArBrCr6rrl)rArBrCcfgvals rE_daemon_term_grace_secondsz*ProcessRegistry._daemon_term_grace_seconds%s  R R R R R R R R R R!/##C'#z+FGGC{$Z01LMuSzz3'' '   33 sA A AAc |3||std|dStr t jddt |ddgdddd d ttj n`#ttj tf$rA tj |tjn#tt t"f$rYnwxYwYnwxYwdSd dl} ||}nb#|j$rYdStt"f$rB tj |tjn#tt t"f$rYnwxYwYdSwxYw |d }n#|j|jtf$rg}YnwxYw|||D]9} |#|j$rY$|jtf$rY6wxYw}|d krdSt5j|z}t5j|krGt9fd|Dsn+t5jdt5j|kG|D]p} |s| td|j |O#|j$rY[|jtf$rYmwxYwdS)u Terminate a host-visible PID and its descendants. ``expected_start`` is the kernel start time captured when we spawned the process. When provided, it is re-validated against the live PID before any signal is sent; a mismatch (or a dead PID) means the number was recycled onto an unrelated process and we refuse to touch it, so a stale background-session PID can never tree-kill a browser or other stranger. POSIX: walks the process tree with ``psutil`` and SIGTERMs children before the parent so subprocess trees (e.g. Chromium renderers/GPU helpers spawned by an ``agent-browser`` daemon) don't get reparented to init and survive cleanup. After a bounded grace window (``terminal.daemon_term_grace_seconds``) any tree member that ignored SIGTERM — a daemon stalled in its signal handler — is escalated to SIGKILL so it can't leak indefinitely. Set the grace to 0 to disable escalation (SIGTERM only). Windows: shells out to ``taskkill /PID /T /F``. This is the documented Microsoft primitive for tree-kill and matches the existing convention in ``gateway.status.terminate_pid``. ``/F`` is already a hard kill, so no separate escalation step is needed. We can't reuse the POSIX psutil path on Windows because: 1. Windows doesn't maintain a Unix-style process tree — ``psutil.Process.children(recursive=True)`` walks PPID links that go stale when intermediate processes exit, so enumeration is best-effort and misses orphaned descendants. 2. ``psutil.Process.terminate()`` on Windows is ``TerminateProcess()`` which kills only the target handle and is a hard kill — there is no Windows equivalent of a SIGTERM that cascades through a process group. (See the warning in ``gateway/status.py::terminate_pid``: "os.kill with SIGTERM is not equivalent to a tree-killing hard stop" on Windows.) Headless Chromium has no GUI window, so the softer ``taskkill /T`` without ``/F`` won't reach it either. ``psutil`` is a hard dependency (see ``pyproject.toml``); the bare-``os.kill`` fallback covers OSError / PermissionError on POSIX and a missing ``taskkill.exe`` on Windows (effectively unreachable on real Windows installs, but cheap insurance). NufRefusing to terminate host pid %d: start-time mismatch — PID was recycled onto an unrelated process.taskkillz/PIDz/Tz/FTrrYr)rVrrrrW creationflagsstdinr) recursivec3BK|]}|VdSr)r?)r_pr4s rErz6ProcessRegistry._terminate_host_pid..s/==rsr**======rXg?zDEscalated to SIGKILL for pid %d (ignored SIGTERM within %.1fs grace))!r5r)r*r_rfrgrrDEVNULLFileNotFoundErrorTimeoutExpiredr2r#killsignalSIGTERMProcessLookupErrorPermissionErrorr:Process NoSuchProcesschildren AccessDeniedr1 terminaterIrZr[rsleepr?infor) r4rr2r:parenttargetsr>gracedeadlines ` rE_terminate_host_pidz#ProcessRegistry._terminate_host_pid7sV  %c.C.CC.X.X % NN>?B    F   S4>#' "4"6"6$, &z'@'J   GC0000!3_ED  F  ^^C((FF#    FF)    V^,,,,/A     FF   ooo55GG$f&97C   GGG v  D     '   '1     ..00 A:: F>##e+n))====W=====  Jt   n))  D t,,  #$(He'   '1      sABC!!CC!CC!CC! C!+D E E D?>E ?EE EE E $E;;FF4G  G(G('G(K 5K  K+K+*K+envcDt|dd}t|r |}t|tr,|dr|dpdSn2#t $r%}td|Yd}~nd}~wwxYwdS)zEReturn the writable sandbox temp dir for env-backed background tasks. get_temp_dirNr z*Could not resolve environment temp dir: %sz/tmp) getattrcallable isinstancerr-rrlr)ri)rergtemp_dirrss rE _env_temp_dirzProcessRegistry._env_temp_dirssND99 L ! ! P P'<>>h,,71D1DS1I1I7#??3//636 P P P I3OOOOOOOO PvsA A.. B8BBrFrrrrenv_varsuse_ptyc X ddlm}||}tdtjjdd|||t |ptjtj } d} |r+ trddl m } nddl m } t} ttj|} d | d <| d d |g}t o t#}|o t%}|r)t'|| j }d| jd| _d} n|rt,d| || j| d}|j| _|| j| _|| _t=j|j | fdd| j}|| _!|"|j#5|$| |j%| j<dddn #1swxYwY|&| S#tN$rt,(dYnetR$rY}t,(d|| r2| jr+tU| jstWd|d| _Yd}~nd}~wwxYwt} ttj|}d |d <trdtYini}| d d |g}t o t#}|o t%}|r2| r | jdn| j}t'|| }d|d| _d}n.|}d}|r(t,d|t%t[j.|fd| j|ddtZj/tZj0tZj1|d |}|| _2|j| _|| j| _ t=j|j3| fdd | j}|| _!|"|j#5|$| |j%| j<dddn #1swxYwY|&n #tR$r | jr5tU| j|4|j| jnts tktld!tlj7}tj8tj9|j|nE#tttvtxf$r|=YnwxYw|=n#tR$rYnwxYw |>d"#n#tR$rYnwxYwwxYw| S)$aw Spawn a background process locally. Only for TERMINAL_ENV=local. Other backends use spawn_via_env(). Args: use_pty: If True, use a pseudo-terminal via ptyprocess for interactive CLI tools (Codex, Claude Code, Python REPL). Falls back to subprocess.Popen if ptyprocess is not installed. r)_rewrite_compound_backgroundproc_N )rrrrrrF) PtyProcessrwPYTHONUNBUFFEREDz-liczset +m; )rrz.scopeTz{PTY background executor not isolated in a systemd scope (systemd-run --user unavailable); worker shares the gateway cgroup.)rx)rre dimensionszproc-pty-reader-targetargsdaemonnamez3ptyprocess not installed, falling back to pipe modez0PTY spawn failed (%s), falling back to pipe modezZPTY scope could not be reaped; refusing pipe fallback to avoid duplicate command executionrrLz-pipe-fallbackzLocal background executor not isolated in a systemd scope (in_supervised_gateway=%s, systemd-run --user available=%s); worker shares the gateway cgroup.rrY) rrrerrstdoutrjrMstart_new_sessionz proc-reader-SIGKILLrW)?tools.terminal_toolrprrcrdrerr#getcwdrZr_winptyrs ptyprocessrrr{rrtrrrr)rispawnrrr1rrrr_pty_reader_looprstartr_prune_if_neededr_write_checkpoint ImportErrorr*rlr RuntimeErrorrrfrPIPESTDOUTrQr _reader_looprdrhrUrVkillpggetpgidrWrXr2rTwait)rrrrrrmrn _rewrite_bg safe_commandrpty_scope_attempted_PtyProcessCls user_shellpty_envpty_argvpty_in_supervised_gatewaypty_use_systemd_scopepty_procreaderebg_env _popen_kwargsrin_supervised_gatewayuse_systemd_scoper spawn_argvpopen_start_new_sessionr> kill_signals rE spawn_localzProcessRegistry.spawn_localsK0 TSSSSS"{7++  .tz||',..#!#"455y{{    $ J .H .HCCCCCCCGGGGGG(]] 22:xHH.1*+&0I<0I0IJ $OH(F(H(H*.U2S2U2U&) 8 $+J   H,OGJ+N+N+NG(*.''.LL< *// ( 0 'l *.*D*DW[*Q*Q'' #)0!8GJ88  *0& Z88))+++07DM'*-888888888888888&&((( V V VTUUUUU . . .QSTUUU&.7+?.-g.BCC!*C !!,.G( .!]] *"*h??%(!"CNV*<*>*>??TV !&*C\*C*CD $/ T4R4T4T ! I&G&I&I  ! 1DT7:----'* 3'J$HK#G#G#GG '+ # ##J&* #$  8*577     ?$$5      h "&"<"VV' V"V'!V""V'rrWc tdtjjdd||||t j|d}||}|d|jd} |d|jd} |d|jd } tj|} tj|} tj| }tj| }tj| }d | d | d |d |d|d| } | ||d}| dd }| D]@}| }| rt||_nA|j|d|_t| dd|_|jdkrd|_d|_d|_| dd |_n=#t*$r0}d|_d|_d|_d|_d||_Yd}~nd}~wwxYw|jsEt-j|j||| | | fdd|j}||_||j5||js||j|j<dddn #1swxYwY|js||S)a# Spawn a background process through a non-local environment backend. For Docker/Singularity/Modal/Daytona/SSH: runs the command inside the sandbox using the environment's execute() interface. We wrap the command to capture the in-sandbox PID and redirect output to a log file inside the sandbox, then poll the log via subsequent execute() calls. This is less capable than local spawn (no live stdout pipe, no stdin), but it ensures the command runs in the correct sandbox context. rqNrrsandbox)rrrrrrrrz /hermes_bg_z.logz.pidz.exitz mkdir -p z && ( nohup bash -lc z > z$ 2>&1; rc=$?; printf '%s\n' "$rc" > z ) & echo $! > z && cat F)rWrewrite_compound_backgroundrrTrhr failed_startzFailed to start: z proc-poller-rw)rrcrdrerZrlrshlexquoteexecuter|r%r,r0r&rrrrrrrlrr_env_poller_looprrrrrr)rrerrrrrWrrklog_pathpid_path exit_pathquoted_commandquoted_temp_dirquoted_log_pathquoted_pid_pathquoted_exit_path bg_commandrrrr>rrs rE spawn_via_envzProcessRegistry.spawn_via_envs(!.tz||',..#y{{    %%c**;;7:;;;;;7:;;;==GJ=== W--+h//+h//+h// ;y11 D D D . D D3B D D/? D D) D D3B D D  <[[,1!F ZZ"--3355F))++  zz||<<>>"%d))GKE {"!%$' <(D(D$E$E!$))(*G%,:)-;*(. 8R(@(@(F(F(H(H% < < <!GN "G (6G %)7G &$;$;$;G ! ! ! ! ! !  <~ %,sHh B0GJ00 F &,G " LLNNN Z 4 4  ! ! # # #> 4,3 gj) 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 ~ %  " " $ $ $s+?DH I"&I  I(+KK#&K#cdtjdd}dtffd } j}||j |dd }|r ||n#t $rYnwxYw jd n2#t $r%}t d |Yd}~nd}~wwxYwd_ j d krjj _ d_ dS|j}tt|dddd}d} |dt s]t|dd} t#| r | nd} n#t $rd} YnwxYwt%| t&r| dkr| } | ddl} d} | | gggd\}}}n#t*t,f$rYnZwxYw|r3|d}|snF||}|r ||d} n | | dz } | dkrnnN |'|d}|sn=||}|s)n|d}|sn ||Mn2#t $r%}t d|Yd}~nd}~wwxYw |dd }|r ||n#t $rYnwxYw jd n2#t $r%}t d |Yd}~nd}~wwxYwd_ j d krjj _ d_ dS# |dd }|r ||n#t $rYnwxYw jd n2#t $r%}t d |Yd}~nd}~wwxYwd_ j d krjj _ d_ wxYw)uBackground thread: read stdout from a local Popen process. IMPORTANT: avoid ``TextIOWrapper.read(4096)`` here. On pipes that call can block until EOF (or a large buffer fills), which makes "live" output land in one burst at process exit. ``buffer.read1(4096)`` yields incremental chunks as bytes become available, then we decode to text. Orphaned-pipe guard (issue #68915): when the user's command backgrounds a long-lived process (``node server.js &``, ``sleep 300 &``), that grandchild inherits the write end of our stdout pipe via ``fork()``. The direct ``bash`` child exits promptly, but the pipe never reaches EOF while the grandchild lives — so a blocking read would park this thread forever, ``session.exited`` would never flip, and ``notify_on_complete`` would never fire (``_reconcile_local_exit`` only runs lazily from poll()/wait(), which an autonomous notification can't rely on). On POSIX we therefore ``select()`` with a short poll interval and stop draining shortly after the direct child exits, even if the pipe hasn't EOF'd — mirroring the foreground fix in ``tools/environments/base.py::_wait_for_process`` (#8340). Windows pipes don't support select(); the blocking path is kept there and the lazy reconcile in poll()/wait() remains the safety net. TrrYrrc^r|}dj5xj|z c_tjjkrjj d_dddn #1swxYwY||dS)NF)rrrrrr!r)r first_chunkrrs rE _append_chunkz3ProcessRegistry._reader_loop.._append_chunk;s $//66#  ^ ^%%.%%w,--0HHH,3,A7C[B[B\B\,]G) ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^  & &w 6 6 6   gu - - - - -sAA66A:=A:NrXfinalrrz$Process wait timed out or failed: %skilledrbufferread1filenorg?rrzProcess stdout reader ended: %s)codecsgetincrementaldecoderrrr|rkrlrr)rirrrhrr7rhr_rirjr&selectr(r2pollread)rrdecoderrr>tailrr|raw_readfdr candidate_selectidle_after_exitready_rawrrs`` @rErzProcessRegistry._reader_loops. 8&.w77yIII . . . . . . . . .U ,?D|t{2F ~~c~66(!M$'''     H$$Q$//// H H H CQGGGGGGGG H!GN(H44$+O$>!,4)  " "7 + + + + +c[Fwvx>>NNH B#K# 488%,4V,<,< F$II %%% $III%i--#)q.."B~(((("#"&-nnbT2r3&G&G q!!&0"&htnn""! 's 3 3 1)M%000*+0 (1,*a//!+".)+&htnn""! 's 3 3$%$% !' D 1 1$"!!M%((()  ? ? ? LL:A > > > > > > > > ?  ~~c~66(!M$'''     H$$Q$//// H H H CQGGGGGGGG H!GN(H44$+O$>!,4)  " "7 + + + + + ~~c~66(!M$'''     H$$Q$//// H H H CQGGGGGGGG H!GN(H44$+O$>!,4)  " "7 + + + +s"I?$A++ A87A8<B C"CC AI?E+*I?+ E:7I?9E::)I?$GI?GI?GB(I?>M7? J. J)$M7)J..M72$K K$#K$(L L3L..L37P=9$NP= N+(P=*N++P=/O  P= O:O50P=5O::AP=rrrctj|}tj|}tj|}d} |jstjd |d|dd} | dd} | rt| | kr | | d nd} t| } |j5| |_ t|j |j kr|j |j d |_ d d d n #1swxYwY| r,| || | || |d |d d } | dd }|r|d  dkr|d|dd }|dd } t|d  |_n#t"t$f$r d |_YnwxYwd|_|jdkrd|_||d SnB#t*$r5d|_d |_d|_d|_||Yd SwxYw|jd Sd S)zBBackground thread: poll a sandbox log file for non-local backends.rrzcat 2>/dev/nullrrrrNzkill -0 "$(cat z# 2>/dev/null)" 2>/dev/null; echo $?rr0Trrlost backend_lost)rrrrZr^rr|rrrrr!rr%r,r&rr( IndexErrorrr7rlr)rrrerrrrrrprev_output_lenrr new_outputdeltacheck check_output exit_resultexit_strs rErz ProcessRegistry._env_poller_loopsx +h//+h// ;y11.0  JqMMM. %IO%I%I%ISUVV#ZZ"55  :> L$;$;$=$=b$A$G$G$I$IS$P$P"%++=/=== !#.##K +x<<BBDDH/,/0C0C0E0Eb0I0O0O0Q0Q,R,R))& 3///,.)))/%)GN0H<<4<1**7333F   !%$&!,2)-;*&&w/// S.0 0 0 0 0 s\A(J?D JDJDC*J>IJIJI1J;KKcj}tjdd}dtffd } |r |d}|r9t |tr|n||}|r ||n#t$rYn#t$rYnwxYw|n2#t$r%}t d|Yd}~nd}~wwxYw |d d }|r ||n#t$rYnwxYw | n2#t$r%}t d |Yd}~nd}~wwxYwd _ jd kr%t|dr|jnd_d_dS)z2Background thread: read output from a PTY process.rrYrrc,j5xj|z c_tjjkrjj d_dddn #1swxYwY||dSr)rrrrr!r)rrrs rE _append_textz6ProcessRegistry._pty_reader_loop.._append_texts ^ ^%%-%%w,--0HHH,3,A7C[B[B\B\,]G) ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^  & &w 5 5 5   gt , , , , ,sAAA!$A!rzPTY stdout reader ended: %sNrXTrz PTY wait timed out or failed: %sr exitstatusrr)rrrrisaliverrjrkEOFErrorrlr)rirrrhasattrrrr7) rrptyrrrrrrs `` rErz ProcessRegistry._pty_reader_loopsVl8&.w77yIII -s - - - - - - - ;++--  HHTNNE/(25#(>(>YuuGNNSXDYDY/(L...E E++--  ; ; ; LL6 : : : : : : : : ; >>#T>22D # T"""    D  @ HHJJJJ @ @ @ LL;Q ? ? ? ? ? ? ? ? @  $ 0 029#|2L2L TRTG (0G % w'''''srC ABC  B5'C ) B52C 4B55C C<C77C<$D%% D21D26E E:E55E:c |j5|j|jddu}||j|j<dddn #1swxYwY|j||rw|jrrddl m }|j r||j ddnd}|j d|j|j|j|j|j|j||jd dSdSdS)uMove a session from running to finished. Idempotent: if the session was already moved (e.g. kill_process raced with the reader thread), the second call is a no-op — no duplicate completion notification is enqueued. Nr strip_ansi0r completion) r rrrrrrrr)rrrrrrrrrtools.ansi_striprrrrrrrrrr)rr was_runningr output_tails rEr7z!ProcessRegistry._move_to_finished sxZ 1 1-++GJ==TIK)0DN7: & 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 !%%'''     75  3 3 3 3 3 3GNG\d**W%:566%BCCCbdK  ! % %$%j&2"?$.%,%>&-&@%&0 ' '         s2AA  A rc||jvS)zECheck if a completion notification was already consumed via wait/log.)r)rrs rEis_completion_consumedz&ProcessRegistry.is_completion_consumed/sT666rXcR|sdS|j5|j|p|j|}dddn #1swxYwY|dS ||n#t $rYnwxYw|jrdS|jr|js |j dkrdSdS)uWhether a goal loop parked on this session should still be parked. Used by the goal-loop wait barrier (``hermes_cli.goals``) to support waiting on a process's OWN trigger, not just its exit. A session is "still waiting" when: - it is still running, AND - if it has ``watch_patterns``, none has matched yet (so a long-lived watcher that fires a trigger mid-run — and may never exit — unblocks the moment its pattern hits, not on exit). Returns False (don't wait) when the session has exited, its watch pattern has already fired, or the session is unknown — so a stale or already-triggered barrier can never wedge the loop. FNrT) rrr|rr8rlrrrrrrrs rEis_session_waitingz"ProcessRegistry.is_session_waiting3s- 5 Z V Vm'' 33Ut~7I7I*7U7UG V V V V V V V V V V V V V V V ?5   * *7 3 3 3 3    D  > 5  ! '*A "Q&&uts#5A  AAA33 B?BTskip_poll_observedrc*||jvp |o||jvS)uPWhether this drain should skip a completion event for this session. Skips when the agent has either truly consumed the output (wait/log → ``_completion_consumed``) or observed the exit inline via poll() (``_poll_observed``). In both cases the CLI agent already has the result this turn, so injecting a [SYSTEM: ...] completion would be a duplicate (#8228). The gateway/tui watchers do NOT use this — they check only ``is_completion_consumed`` so a read-only poll never suppresses their autonomous delivery turn (#10156). )rr)rrrs rE_drain_should_skipz"ProcessRegistry._drain_should_skipWs)T66  D:1D#D rXzlist[tuple[dict, str]]cg}g}|js |j}n#t$rYnwxYw|ddk}t |dpd}t |dpd} |pt |p| } |H| rF t ||} n#t$rd} YnwxYw| s||nP|r | r||kr||%n.|r,|dr||T|d d} |dd kr|| | rt|} | r||| f|j|D]}|j ||S) auPop all pending notification events and return formatted pairs. Returns a list of (raw_event, formatted_text) tuples. Skips completion events the agent already consumed via wait/log or observed inline via poll() (see ``_drain_should_skip``). Gateway/TUI callers pass ``skip_poll_observed=False`` because read-only polling must not suppress autonomous delivery there. When a routing filter is supplied, addressed notifications must not be drained into the wrong session. Async-delegation events always require conversation payload; ordinary notifications require routing when they carry ``session_key`` or ``origin_ui_session_id`` metadata. Two filter modes are supported, strongest first: - ``owns_event(evt) -> bool``: positive-proof ownership callback. When provided, a routed event is consumed ONLY if the callback returns True; everything else is re-queued for its owner. The TUI passes its compression-chain-aware ownership check here so a post-compression session still claims its own pre-compression dispatches. - ``session_key``: plain key equality (CLI and other single-session callers). Non-matching addressed events are re-queued. With neither set, all events are consumed (legacy single-session behavior, backward compatible). Ownerless ordinary notifications also retain that legacy behavior even when a filter is provided. When a filter is provided, ownerless async-delegation events remain fail-closed and require positive proof. r async_delegationrrorigin_ui_session_idNFrestoredrrr) rempty get_nowaitrlr|rrr1rformat_process_notificationr)rr owns_eventrresultsrequeueevtis_async_delegationevt_session_keyevt_origin_sidrequires_positive_proofowned_evt_sidrs rEdrain_notificationsz#ProcessRegistry.drain_notificationshsvH-/ "'--//, , +6688     #&''&//5G"G !#''-"8"8">B??O )?!@!@!FBGGN&9'T1>>> #%*A%" C11EE """!EEE"NN3''' !8 "k11NN3'''2% )<)< s###ww|R00Hwwv,..43J3J-?4K44..s33D ,T{+++Y'--//, ,Z + +C  ! % %c * * * *s!: AAC C,+C,c|j5|j|p|j|}dddn #1swxYwY||S)z*Get a session by ID (running or finished).N)rrr|rr8rs rEr|zProcessRegistry.gets Z V Vm'' 33Ut~7I7I*7U7UG V V V V V V V V V V V V V V V--g666s5A  A A rc||jrdSt|dd}|dS |}n#t$rYdSwxYw|dSd}t|dd}|atsY ddl}|}|||j}|||j|tj z | } | r.t| tr| n| dd}n#tt t"f$rYnwxYw |||j|nB#t$rYn6wxYw# |||j|w#t$rYwwxYwxYwn8#t$r+} t$d |j| Yd} ~ nd} ~ wwxYw|j5|rG|xj|z c_t/|j|jkr|j|j d|_d |_|jd kr||_d |_dddn #1swxYwYt$d |j|||dS)u$Reconcile session.exited against the real child process state. The reader thread (`_reader_loop`) sets `session.exited = True` only in its `finally` block, which runs when `stdout.read()` returns EOF. If the direct `Popen` child has exited but a descendant process (e.g. a daemon spawned by `hermes update` restarting the gateway) is still holding the stdout pipe open, the reader blocks forever and poll() keeps returning "running" indefinitely (issue #17327 — 74 polls over 7 minutes on Feishu). This helper closes that window: when `session.exited` is still False but the direct child's `Popen.poll()` reports an exit code, drain any readable bytes non-blocking and flip `session.exited`. The orphaned reader thread remains stuck on its blocking `read()` but is a daemon thread and will be reaped with the process. Safe no-op on sessions without a local `Popen` (env/PTY), already- exited sessions, and detached-recovered sessions. Nrrr|rrrYrz$Non-blocking drain failed for %s: %sTrrzxReconciled session %s: direct child exited with code %s but reader was still blocked (orphaned pipe). Flipped to exited.)rrhrrlr_fcntlrF_GETFLF_SETFLr# O_NONBLOCKrrjrrkBlockingIOErrorr2r(r)rirrrrrrrr_r7) rrr>rcdrainedr|r rflagsrrs rE_reconcile_local_exitz%ProcessRegistry._reconcile_local_exits7( ?gn? Fw 400 < F BB    FF  : F x..  k  T ]]__ B 66 B ur}/DEEE "KKMMEo+5eS+A+A"n%%u||T[dm|GnGn'*=D B u====$ B u====$ T T T CWZQRSSSSSSSS T] 5 5 ^%%0%%w,--0HHH,3,A7C[B[B\B\,]G)!GN(H44$&!,4) 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5   D J   w'''''s7 AA+AF AD E D'$E&D''E+EF  EF EF FE76F7 FFFFF G!F;;G A*IIIc(ddlm}||}|dd|dS|||j5|jr||jddnd}dddn #1swxYwY|j|j|jrd nd |j ttj |j z |d }|jr8|j |d <|j|d <|j|d<|j||jr d|d<d|d<|S)z9Check status and get new output for a background process.rrN not_foundNo process with ID r<errorrrrunning)rrr<ruptime_secondsoutput_previewrrrTrz=Process recovered after restart -- output history unavailablenote)rrr|rrrrrrrr&rZrrrrraddr)rrrrrrrs rErzProcessRegistry.polls//////((:&& ?)4V*4V4VWW W ""7+++ ] h hJQJ_gZZ(=eff(EFFFegN h h h h h h h h h h h h h h h"*").?hhi;!$)++0B"BCC,    > 0")"3F; *1*CF& '+2+EF' (   # #J / / /   ]!%F: \F6N s"A00A47A4offsetlimitcddlm}||}|dd|dS|j5||j}dddn #1swxYwY|}t |}|'|dkr!|| d} t| p|dk} nX|pd}||||z} t|||z |d} |dkpt| o| |k} |j |j |j rdnd d | |t | d d } |j r| r|j|| S) z;Read the full output log with optional pagination by lines.rrNrrrrrrrz lines)rrr<r total_linesshowing)rrr|rrr,rrsliceindicesrrrrrr ) rrr"r#rr full_outputrr%selectedobserved_completion_outputrrrs rEread_logzProcessRegistry.read_log:s//////((:&& ?)4V*4V4VWW W ] < <$*W%:;;K < < < < < < < < < < < < < < <&&((%jj  >eaiieVWW~H)-h)K;!;K & &FVFUN23H%0088EEaHDq LT(^^%K 8K ' "*").?hhiii))&h--///    > 68 6  % ) )* 5 5 5 sA  AAc ddlm}ddlm} t t jdd}n#ttf$rd}YnwxYw|}|}d}||dkr dd |d d S|r||kr |} d |d |d}n|p|} | |} | dd|d Stj | z} tj | kr$| | } | dd|d S| | | jrV|j|d| j| j| j| j|| jddd} |r|| d<| S|r+d| j|| jdddd} |r|| d<| S| tj z } | dkrnA| jt1d| tj | k$d| j|| jdddd} | jrtj | jz nd}d| d}||d t |d!z }| jr|d"z }n|d#z }|r |d$|| d<n|| d<| S)%aY Block until a process exits, timeout, or interrupt. Args: session_id: The process to wait for. timeout: Max seconds to block. Falls back to TERMINAL_TIMEOUT config. Returns: dict with status ("exited", "timeout", "interrupted", "not_found") and output snapshot. rr)is_interruptedTERMINAL_TIMEOUT180Nrztimeout must be positive (got )rzRequested wait of z%s was clamped to configured limit of rrrrrr<rrrrr timeout_note interruptedrz+User sent a new message -- wait interrupted)r<rrrg?rrWT)r<rrprocess_runningzWait window of uAs elapsed — the process is still running. This is not an error.z Uptime: r%uc notify_on_complete is set: you will be notified on exit — do more work instead of waiting again.zq Poll again later or use terminal(background=true, notify_on_complete=true) next time for automatic notification.z. )rrtools.interruptr.r&r#r$r(r7r|rZr[r8rrrr rrrrrrrr4rr)rrrWr_is_interrupteddefault_timeout max_timeoutrequested_timeoutr4effective_timeoutrrcrr remaininguptime base_notes rErzProcessRegistry.waitds 0/////EEEEEE "!"),>"F"FGGOOI& " " "!OOO "% #   (->!-C-C!N:KNNN   A!2[!@!@ + 9%699*5999 L !2 @[ ((:&& ?)4V*4V4VWW W>##&77n))44W==G"-8Zj8Z8Z[[[  & &w / / /~ )--j999&&!(!2)0)B*1*D(j)>uvv)FGG  :-9F>*   +&(j)>uvv)FGGI   :-9F>*  4>#3#33IA~~  % * *3sI3F3F * G G GIn))N  j!6uvv!>?? $  6=5GQw111T 3/ 3 3 3    4S[[444 4I  %  9 II Q I  /(4%C%C %C%CF> " "%.F> " s"1AAz process.killsourceconsume_outputrArBc ddlm}||}|dd|dS|jr|jrt |j|j5d|j|j|j |j ||j ddd }dddn #1swxYwY|r|j ||S |jrZ |jd n#t $r/|jr$t%j|jt(jYnawxYw|jr'||jj|jn/|jr-|jr&|jd |jd dn|jr|jdkr|jr||j|js|jrt |j|j5d |_d|_||j dd}dddn #1swxYwY|r|j |||d|j|dS||j|jndddS|jrt |j|j5||j dd}|r|j |d |_d|_d|_ ||_ dddn #1swxYwY|||d|j |j |j |dS#t $r}dtC|dcYd}~Sd}~wwxYw)uNKill a background process and return its output snapshot. ``consume_output`` is true for explicit tool/RPC kills because their caller observes the returned output. Bulk cleanup passes false: it discards each result and therefore must not suppress an autonomous output-bearing completion notification. Exception: abandoned-turn reaping (``kill_started_since``) is bulk cleanup that deliberately passes true — a killed abandoned process must not enqueue a synthetic follow-up that revives work the timeout/interrupt stopped. rrNrrralready_exitedrr3T)forcezkill rrrr)r<rrrzkRecovered process cannot be killed after restart because its original runtime handle is no longer availabler)r<rrrr)"rrr|rrrrrrrrrrr rr]rlrr#rTrUrVrrdrrrrrr5r7rrr) rrrArBrrrrrrs rE kill_processzProcessRegistry.kill_processs" 0/////((:&& ?)4V*4V4VWW W >  # 9"7#7888  .&!(!2)0)B*1*D(j)>uvv)FGG                 :)--j999MO 8|. =L***6666 ==={= V^<<<=' (()UVVVV" W[" ''(I (I(I(IST'UUUU! g&76&A&Agk&A--gk7;RSS+A*7+?@@@ KK)-,0)!+G,A%&&,I!J!JKKKKKKKKKKKKKKK&B155jAAA**7333"2%,%6"( ((g6MNNNN&M# 9"7#7888 4 4#G$9%&&$ABB!>-11*===!%$'!,4)-3* 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4  " "7 + + +  " " $ $ $"%j%,%>&-&@   8 8 8%A77 7 7 7 7 7 7 8s4BBB9MCM5DMDCM'H > M HMH>M%M7"MAK6* M6K::M=K:>AM M' M"M'"M'datac0||}|dd|dS|jrdddSt|dr|jr tr:t |t r|dnt|}n-t |tr| dd n|}|j |d t|d S#t$r}d t|dcYd}~Sd}~wwxYw|j r |j jsd d dS |j j ||j jd t|d S#t$r}d t|dcYd}~Sd}~wwxYw)zASend raw data to a running process's stdin (no newline appended).NrrrrDProcess has already finishedrrsurrogateescapeok)r< bytes_writtenr?Process stdin not available (non-local backend or stdin closed))r|rrrr_rjbytesrkrencodewriterrlrrMflush)rrrHrpty_datars rE write_stdinzProcessRegistry.write_stdinZs((:&& ?)4V*4V4VWW W > Y.9WXX X 7F # # < < <j7A$7N7N]t{{7333TWX\T]T]HHKUUY[^J_J_it{{74EFFFeiH ""8,,,"&TCCC < < <")CFF;;;;;;;; < sgo&; s%0qrr r 8 O ! ' ' - - - O ! ' ' ) ) )"SYY?? ? 8 8 8%A77 7 7 7 7 7 7 8s>BC D(C?9D?D AE// F9F FFc4|||dzS)zGSend data + newline to a running process's stdin (like pressing Enter).r)rT)rrrHs rE submit_stdinzProcessRegistry.submit_stdin{s D4K888rXc|j}|dddS||} |||n)#t$r}dt|dcYd}~Sd}~wwxYwd|ddS)uyAsk the desktop GUI to close the read-only terminal tab mirroring this background process. This does NOT kill the process — it only drops the view. Output keeps streaming into the (capped) buffer and the user can reopen the tab from the status stack. Desktop-only: returns an error if no UI close sink is wired (e.g. CLI / messaging).Nrz;close_terminal is only available in the Hermes desktop app.rrLzClosed the read-only terminal tab. The process was not killed; its output remains available and the user can reopen the tab from the status stack.)r<closedr)rr|rlr)rrrrrs rErequest_close_terminalz&ProcessRegistry.request_close_terminals} <!V  ((:&& 8 D* % % % % 8 8 8%A77 7 7 7 7 7 7 8 )    s 2 AA AAc||}|dd|dS|jrdddSt|drO|jrH |jdd d S#t $r}d t |dcYd}~Sd}~wwxYw|jr |jjsd d dS |jj dd d S#t $r}d t |dcYd}~Sd}~wwxYw)zGClose a running process's stdin / send EOF without killing the process.NrrrrDrJrrLzEOF sent)r<rrrNz stdin closed) r|rrrsendeofrlrrrMclose)rrrrs rE close_stdinzProcessRegistry.close_stdinsb((:&& ?)4V*4V4VWW W > Y.9WXX X 7F # # <  < < $$&&&"&:>>> < < <")CFF;;;;;;;; < sgo&; s%0qrr r 8 O ! ' ' ) ) )"~>> > 8 8 8%A77 7 7 7 7 7 7 8s<A"" B,B=BB$"C C-C("C-(C-cN t|jS#t$rYdSwxYw)akReturn the count of currently-running background processes. Cheap O(1) read of the running dict, suitable for status-bar polling on every render tick. CPython dict ``len()`` is atomic; callers do not need to hold ``self._lock``. Reflects ``_running`` only: sessions are moved to ``_finished`` when their subprocess exits. r)rrrl)rs rE count_runningzProcessRegistry.count_runnings9 t}%% %   11 s  $$c j5tjtjz}dddn #1swxYwYfd|D}srfd|D}g}|D])}|j|jdd|j|jtj dtj |j ttj |j z |jrdnd|jr|jddnd d }rr|jkr|jkrd |d <|jr,|js%t|j|d <|jdk|d<|jrd |d<|jr |j|d<|jrd |d<||+|S)uList all running and recently-finished processes. When ``task_id`` is given, processes for that task are included. When ``session_key`` is also given, session-scoped background processes (``background: true``) registered under that gateway session are surfaced too, even if they belong to a different task — so the agent can discover a forgotten preview server that is blocking session reset (#29177). Such cross-task entries are flagged with ``"session_scoped": true``. Nc:g|]}|Sr)r8)rrrs rE z1ProcessRegistry.list_sessions..s'PPPa66q99PPPrXcHg|]}r |jks r |jk|Srrr)rrrrs rErbz1ProcessRegistry.list_sessions..sM ! W 4 4!5$%M[$@$@$@$@$@rXr!z%Y-%m-%dT%H:%M:%Srri8r)rrrrrrr<rTsession_scopedrr watch_hitrrr)rrrvaluesrrrrrrZstrftime localtimerr&rrrrrrrrrrr1)rrr all_sessionsrrrentrys``` rE list_sessionszProcessRegistry.list_sessionssmZ X X 4 4 6 677$t~?T?T?V?V:W:WWL X X X X X X X X X X X X X X XQPPP<PPP  k 'L  ! !Ad9TcT?uu"m,?PQP\A]A]^^"%dikkAL&@"A"A&'h=((I<=O"S!/$%%"8"8QS  E /; /19+?+?AMU`D`D`*.&' 7(9 7*.q/?*@*@&'%&]Q%6k"# 3.2*+x 1%&[k"z )$(j! MM%  sAA%%A),A)ch|j5t|j}dddn #1swxYwY|D]}|||j5t fd|jDcdddS#1swxYwYdS)zK|]}|jko|j VdSr)rrrrrs rErz7ProcessRegistry.has_active_processes.. sG W$5QXrXrrrrgr8r)rrsessionsrs ` rEhas_active_processesz$ProcessRegistry.has_active_processessP Z 4 4DM002233H 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4  4 4G  * *7 3 3 3 3 Z  --//                  s!'<AA(2B''B+.B+max_active_agec|j5t|j}dddn #1swxYwY|D]}||t j|j5t fd|jDcdddS#1swxYwYdS)uCheck if there are active processes for a gateway session key. When *max_active_age* is set (seconds), processes that started more than that many seconds ago are **ignored** — they are still running but are considered stale and must not block session idle / daily reset. This prevents a forgotten ``http.server`` (or any long-lived preview process) from permanently freezing the session lifecycle. Args: session_key: Gateway session key to check. max_active_age: If set, ignore processes older than this many seconds. ``None`` retains the legacy behaviour (any running process blocks). Nc3bK|])}|jko|j odup |jz kV*dSr)rrr)rrrsrnrs rErz9ProcessRegistry.has_active_for_session.." sl ,VLV#t+Tal0Bn/TrX)rrrrgr8rZr)rrrsrqrrns `` @rEhas_active_for_sessionz&ProcessRegistry.has_active_for_session sk"Z 4 4DM002233H 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4  4 4G  * *7 3 3 3 3ikk Z  --//                   s!'>AA=4B>>CCcb|j5t|j}dddn #1swxYwY|D]}|||j5t d|jDcdddS#1swxYwYdS)aWhether ANY background process is still running (across all sessions). Used by scale-to-zero idle detection (gateway/scale_to_zero): a gateway with a live background process (terminal background=true) is NOT idle and must not be suspended, or the process is lost. Refreshes detached sessions first so a finished-but-unreaped process reads as inactive. Nc3&K|] }|j V dSr)r)rrs rErz1ProcessRegistry.has_any_active..8 s&DD18|DDDDDDrXrp)rrqrs rEhas_any_activezProcessRegistry.has_any_active) sLZ 4 4DM002233H 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4  4 4G  * *7 3 3 3 3 Z E EDDT]-A-A-C-CDDDDD E E E E E E E E E E E E E E E E E Es';??'0B$$B(+B(c|j5tfd|jDcdddS#1swxYwYdS)aOCapture running process IDs owned by ``task_id``. Gateway turns use this as a boundary marker: if a turn times out, only processes absent from its starting snapshot belong to the abandoned turn. Older session processes must survive because background tasks intentionally span successful turns. c3JK|]}|jk |j|jVdSr)rrrros rErz7ProcessRegistry.snapshot_running_ids..C sE9'''''''rXN)r frozensetrrg)rrs `rEsnapshot_running_idsz$ProcessRegistry.snapshot_running_ids: sZ  --//                  s2AA A cR||t|pd|dS)zKill processes created for ``task_id`` after a prior snapshot. ``consume_output`` is forced on: abandoned-turn output must not enqueue a synthetic follow-up that revives work the timeout deliberately stopped. rT exclude_idsrArB)kill_allr|)rr baseline_idsrAs rEkill_started_sincez"ProcessRegistry.kill_started_sinceI s8}} !,"4"55    rXrrrc|j5fd|jD}dddn #1swxYwYd}|D];}||j||}|ddvr|dz }<|S)zQKill all running processes, optionally filtered by task_id. Returns count killed.cNg|]!} |jkr|jv|j|"Sr)rrr)rrrrs rErbz,ProcessRegistry.kill_all..g sKOqyG';';D ++,+++rXNrr@r<>rrDr)rrrgrGrr|) rrrrArBrarrrrs `` rErzProcessRegistry.kill_all] sZ  =//11G                 G&& -'F zz(##'CCC!  s'=AActjfdjD}|D]>}j|=j|j|?t jt jz}|tkr\jrUtjfd}j|=j|j|j j z}j|z }|rxj|zc_j|z }|rxj|zc_dSdS)zGRemove oldest finished sessions if over MAX_PROCESSES. Must hold _lock.c@g|]\}}|jz tk|Sr)rFINISHED_TTL_SECONDS)rsidrrns rErbz4ProcessRegistry._prune_if_needed.. s:   Cal"&::: :::rXc(j|jSr)rr)rrs rEz2ProcessRegistry._prune_if_needed.. sDN3)>>)G3  /  % % . % %)G3  /   ; .     / /rX extra_entriesc n |j5g}|jD]}|js|j1|jdkr&|jr||j|_|id|j dt|j dd|jd|jd |jd |j d |j d |jd |jd|jd|jd|jd|jd|jd|jd|jd|j|j|jd|r-d|D|fd|Ddddn #1swxYwYddlm}|t:|dS#t<$r(}t> d|dYd}~dSd}~wwxYw)z=Write running process metadata to checkpoint file atomically.NrrrT code_filerrrrrrrrrrrrrrr)rrc8h|]}|dS)rr|)ritems rE z4ProcessRegistry._write_checkpoint.. s$"N"N"Nd488L#9#9"N"N"NrXc3JK|]}|dv|VdS)rNr)rr tracked_idss rErz4ProcessRegistry._write_checkpoint.. sF## 88L11DDDDDD##rXr)atomic_json_writez#Failed to write checkpoint file: %s)exc_info)!rrrgrrrrr1r1rrrrrrrrrrrrrrrrrextendutilsrCHECKPOINT_PATHrlr)ri)rrentriesrrrrs @rErz!ProcessRegistry._write_checkpoint s 2 R+ + --//""A8!,49N9NSTSX9N040J0J150Q0QA-((!$(&'5(((8!"N"Ng"N"N"NKNN####$1###O+ + + + + + + + + + + + + + + \ 0 / / / / /  ow 7 7 7 7 7 R R R LL>DL Q Q Q Q Q Q Q Q Q Rs;FEE FE""F%E"&F F4 F//F4ctsdS tjtd}n#t $rYdSwxYwd}g}|D]}|d}|s|dd}|dkr:td|dd d d ||q|d }| ||s| |r0td |dd||dd}|r@t|s1t d||| |;td(id|dd|dd d|ddd|ddd|d |d|d|ddd|dd|dtjddd|ddd|ddd|ddd|ddd|ddd|ddd |d dd!|d!d"d#|d#g} |j5| |j| j<d d d n #1swxYwY|d$z }td%| jd d || jdkrW|j | j| j| j| j| j| j| j| j| j| jd& ||'|S))z On gateway startup, probe PIDs from checkpoint file. Returns the number of processes recovered as detached. rrrrrrz=Skipping recovery for non-host process: %s (pid=%s, scope=%s)runknownNrruNot recovering session %s: pid %d is alive but its start time no longer matches — PID was recycled onto an unrelated process; refusing to adopt it.r?rrzjCould not reap persisted scope %s for dead wrapper pid %s; retaining checkpoint entry for the next startuprrrrrrTrrrrrrrrFrrz'Recovered detached process: %s (pid=%d)) rcheck_intervalrr r r rrrr)rr)rexistsjsonloadsr+rlr|r)r_r5r.rr*r1rrZrrrrrrrrrrrrrrr) rr recoveredunresolved_scope_entriesrkrrrecorded_startrrs rErecover_from_checkpointz'ProcessRegistry.recover_from_checkpoint s %%'' 1 j!:!:G!:!L!LMMGG   11  9; T T E))E""C  +v66IF"" SIIi33CRC8  #YY'899N))#~>> **3//KKF ,44c  %yy<< ;(:<(H(H;NNJ$  -33E:::$&& )Y777 )R000"IImR888  C  !/ $)#YY~r:::IIe$$$!99\49;;???"'+=r!B!B!B!& *;R @ @ @!& *;R @ @ @#()),?"D"D"D #()),?"D"D"D!"$)99-A2#F#F#F#$"'+=q!A!A!A%&$)99-A5#I#I#I'( %yy)92>>>)G, 4 4,3 gj) 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 NI KKA7?SVTVSVCWY\ ] ] ]'!++%,,")*&-&>#*#6 ' 8&6&6!(!:!(!:")"<*1*D . .    -EFFFs#-A AA,MM M r)NrrNF)Nrrr)rN)rrrN)Nr!)r)NN)?rrrrrr staticmethodrrrrr!rrrrr&r.r1 classmethodr5r8r?rIrdr rldictrrrrrr7rrrr r|rrr,rrGrTrVrYr]r_rrlrrrvryr|r}rrrr r rrrrXrErrs666p     \  N 3 4    ~ ^~ s~ t~ ~ ~ ~ @UuUUUUUn   $   \ 8C=Xc]\@HSM@8C=@UY@@@[@(.1IhWeNf, T   \ \"}}c}8C=}TX}}}[}B 3 3   \ llll l  l  ll lllldbb bb b  b  bb bbbbLB,NB,B,B,B,H8%8,/8;>8JM8Z]8888t1(1(1(1(1(f     H777777"S"T""""J>B    6:     &U $( UUUU ! U " UUUUn7c7h~&>7777 H(H(H(H(T)s)t))))V((3(d (#(X\((((TuusuSuDuuuuv%# }8}8}8}8 }8  }8  }8}8}8}8~8c888888B99s9#9t9999      >8c8d8888. s    55S5c5T5555r C D    CG08 @EEEEE" C IcN            ,"&"+ $ #      <///J9=7R7RT#s(^ 457R7R7R7RrhhhhhhhrXrc* ttd|}n#ttf$rYdSwxYw|dkr|dSt |d\}}|dkr|dkr|dn|d|dSt |d\}}|dkr|dn|d|dS)z5Human-friendly elapsed string ('18m', '2h3m', '45s').rrrrrh)r&r6r7r(r)rrrrs rE _format_agerF s Aw  z "ss2vvwww !R==DAq2vvq&&!wwwwkkQkkk1 !R==DAq1ffa7777Q+++++-s  55rc :ddl}|dd}|ddpd}|d}|d}|d pd }|d pd }|d pd}|d} |d} |dd} |dd } |d} |dp|}|d}|dst|tr|pg}|dpg}|rt |nt |}|d| }d|dd|ddg}t| t t frY|d|| }dt|| z d}| d |||r| d!||r+| d"d# || d$|d%|d&|d'| rD|sB| d(| d)| d* |St|d+,D]}|d-d}|d d }|d}|d}|t |kr||n|dd}|d.vrd/nd0}| dd1|d2|d3zd4|}|r|d5|z }|d6|z }|dr|d7|dz }|d|d#|dd'z }|d8z }| ||d.vr|r| |np|rI|r| d9|d5|d:| d;| |n%| d<||rd5|ndzd:z|d=}|r| d>|d* |Sd}t| t t frdt|| z d}d?|dd@dg}t| t t frC|d|| }| d ||| dA||r| d!||r+| d"d# || d$|d%|| dB|dC| dD| d'| dE|d.vr| r| | n|dFkrL| dG| rd5| ndHz| r*| d;| | nO| dI|dJ| rd*| ndz| r*| d;| | d* |S)KuFormat an async-delegation completion into a self-contained re-injection. Carries the FULL original task source (goal, the context the parent supplied, toolsets, role, model) plus dispatch time, status, and the complete result summary. When this re-enters the conversation the agent may be deep in unrelated context and won't remember why the subagent existed, so the block is written to stand entirely on its own — enough to use the result OR re-dispatch if the world has moved on. rN delegation_idrgoalrcontexttoolsetsroleleafmodelrr< completedsummaryr api_callsduration_seconds dispatched_at completed_atris_batchgoalstotal_duration_secondsu%[ASYNC DELEGATION BATCH COMPLETE — ]zA background fan-out of u subagent(s) you dispatched earlier has finished. All ran in parallel and waited on each other; their consolidated results are below. You may have moved on since dispatching — act on these or re-dispatch if things have changed.z%Y-%m-%d %H:%M:%Sz (z ago)z Dispatched: zContext you provided: z Toolsets: z, zRole: z Model: z Total duration: rz --- ERROR ---z)The batch did not complete successfully: rc.|ddS)N task_indexrr)xs rErz*_format_async_delegation.. squu\1/E/ErXrr)rsuccessu✓u✗z--- z TASK rr z: z (status=z , api_calls=z) ---(r2zPartial output:u(no summary — status=live_transcriptz6Full live transcript (complete tool/assistant trace): u[ASYNC DELEGATION COMPLETE — zA background subagent you dispatched earlier has finished. You may have moved on since dispatching it; the full task source is below so you can act on the result or re-dispatch if things have changed.zOriginal goal: zStatus: z API calls: z Duration: z--- RESULT ---r5z.The subagent was interrupted before completing.z3The subagent did not complete successfully (status=z).) rZr|rjrrr&rrhrirr1rsorted) r_timedeleg_idrrrrrr<rrrdurationrr batch_resultsrrn total_durrtsageridxr_status r_summaryr_errorr_goaliconheaderr_lives rE_format_async_delegationrU s4ww 22H 7762   $"Dggi  Gwwz""H 776?? $fD GGG   #E WWX   -+Fggi  G GGG  E Q''Iww)3//HGGO,,M77>**:ejjllL GGI&&M wwz> j==> %2  &B# 3CLLLUGG4h?? ?H ? ? ? Rq R R R    mc5\ 2 2 3 3U__]5S5STTBG{<-#?@@GGGC LL11C11 2 2 2  = LL;';; < < <  = LL;dii&9&9;; < < < TdTTeTT TTTUUU  $ $ LL ) ) ) LLLULL M M M99U## #%E%EFFF# # A%% a((CuuXs++Hi((IeeGnnG#&U#3#3U3ZZvr9J9JF$(@@@55eD LL   5D55a55!55F (-v--' -8-- -Fuu[!! :9;999uu'((47q!347777 g F LL 333 3 Y'''' =LL!;X!;!;!;!;!;<<< ./// Y'''' 8h88)08~G~~~b: UU,--F  UVUUyy C-#u..DC;|m;<<CCC 6(555 K  E-#u../ ^^/1O1O P P -B---... LL)4))***9 7g778889 7$))H"5"577888 LL1$11%11222 LLUFUU)UU(UUUVVV LL!""" )))g) W =  <$-|E|||# /     " LL* + + + LL ! ! !  L& L L L$,|E|||" .     " LL* + + + LL ! ! ! 99U  rXz str | Nonec |dd}|dd}|dd}|dkrd|dd d S|d krb|d d }|dd }|dd}d|d|d|d|}|r |d|dz }|d z }|S|dkrt|S|dd }|dd }|dpd} |dpd } d } |dvrd} | dkrd| pd } n| d!krd"} n| d#krd$} n |dkrd%} nd} d|d&| d'|| d(|d)|d S)*zFormat a process notification event into a [IMPORTANT: ...] message. Handles completion events (notify_on_complete), watch pattern matches, and watch disabled events from the unified completion_queue. r rrrrrz [IMPORTANT: rrrrrrrr rz[IMPORTANT: Background process z matched watch pattern "z ". Command: z Matched output: z (z/ earlier matches were suppressed by rate limit)rrrrr>-15143rFz , SIGTERMrzterminated by Hermesrz3marked lost because the process backend disappearedrzfailed to startzcompleted normally z (exit code z ). Command: z Output: )r|r) revt_type_sid_cmd_pat_out_supr_exit_reason_source_signal_statuss rErr sN wwv|,,H 77< + +D 779i ( (D###7cggi447777=  wwy#&&wwx$$ww|Q'' 'd ' '# ' ' ' '!% ' '  P O$OOO OD   %%%',,, GGK % %E 778R Dgg)**6hGgg*++1rGG ((((87#6h88 F  G N " "# !& $     $       rX)registry tool_errorrafManage background processes started with terminal(background=true). Actions: 'list' (show all), 'poll' (check status + new output), 'log' (full output with pagination), 'wait' (block until done or timeout), 'kill' (terminate), 'write' (send raw stdin data without newline), 'submit' (send data + Enter, for answering prompts), 'close' (close stdin/send EOF).objectstring)rrlogrrTrQsubmitr\z)Action to perform on background processes)r enum descriptionz]Process session ID (from terminal background output). Required for all actions except 'list'.)r rz@Text to send to process stdin (for 'write' and 'submit' actions)integerzJMax seconds to block for 'wait' action. Returns partial output on timeout.r)r rminimumz6Line offset for 'log' action (default: last 200 lines)z$Max lines to return for 'log' action)actionrrHrWr"r#r)r  propertiesrequired)r{r parametersrrc~t|ts|Sddlm}m}|dpd}dD]=}||}t|t r|r|||||<>t|dt r|dr||dd|d<|S)uDRedact secrets from background-process output before it reaches the model, session.db, and CLI display. Mirrors the foreground ``terminal`` redaction (terminal_tool.py) so the two surfaces can't diverge — issue #43025 (background output was returned verbatim). Respects ``security.redact_secrets`` (no force): output fields pass through ``redact_terminal_output`` which picks ``code_file`` based on the recorded command (env dumps get the ENV-assignment pass). The command string itself is also redacted in case it carried an inline credential. r)rredact_terminal_outputrr)rrTr)rjr agent.redactrrr|r)rrrrrr values rE_redact_process_resultrJ s fd # # JJJJJJJJjj##)rG-CC 5!! eS ! ! Ce C225'BBF5M&**Y''--U&2CU11&2CtTTTy MrXc B|d}|dd}|d#t|ddnd}|dkrf ddlm}|dpd}n#t$rd}YnwxYwt jd d t||pd Did S|dvr7|std|S|dkr;t jtt |d S|dkret jtt ||d|ddd S|dkrPt jtt ||dd S|dkr;t jtt|d S|dkrPt jt|t|ddd S|dkrPt jt|t|ddd S|dkr.t jt|d Std|dS) Nrrrrrr)get_current_session_key)r processesc,g|]}t|Sr)r)rps rErbz#_handle_process..t s0+1--rXrdF) ensure_ascii>rrTrrr\rQrzsession_id is required for rrr"r#r!)r"r#rrWrrTrQrHrr\zUnknown process action: z8. Use: list, poll, log, wait, kill, write, submit, close)r|rtools.approvalr rlrdumpsprocess_registryrlrrrr,rrGrTrVr])rykwrrrr rs rE_handle_processrc snffYG XXh # #F48HH\4J4J4VTXXlB//000\^J   > > > > > >11"===CKK   KKK z-;;GYdYlhl;mm       N N N FDFDDEE E V  :45E5J5J:5V5VWWfklll l u__:45E5N5N488H#5#5TXXgs=S=S6O6U6UVVdikkk k v  :45E5J5J:_c_g_ghq_r_r5J5s5sttDIJJJ J v  :&'7'D'DZ'P'PQQ" w  :.:::s488TZ\^K_K_G`G`aapuvvv v x  :.;;JDHHU[]_L`L`HaHabbqvwww w w  :.:::FFUZ[[[ [ qqqq r rrs-B BBrDu⚙️)r{toolsetschemahandleremoji)Prrrloggingr#r rrUrfrrZrcpathlibrsystemr_tools.environments.localrrrhermes_cli._subprocess_compatr dataclassesr r typingr r r rrFrrr getLoggerrr)rrrrMAX_ACTIVE_PROCESS_AGErrr'r&r(rrrrr^r\r]r'r8r5r&rFrtrrrrrrrrrrrrrtools.registryrrPROCESS_SCHEMArrregisterrrXrEr$s>    ho9, ]]]]]]]]]]<<<<<<((((((((,,,,,,,,,,,,------......  8 $ $"/##&66  !  "&,0(4.///*IN,,%)"/#5 5;M#;M;M;M;M|K4KKKK\2$S $$ #Y$$$$N(#($((((V 10101010101010 10h\"\"\"\"\"\"\"\"@E#?$$ . .3 . . . .H$H3HHHHV5T5l5555v0///////  _![[[J !~ !a "k "W "E/  :J?  **Z4D2-s-s-s`      rX