Ë
    ãß²j¹% ã                   óJ  — U d Z ddlZddlmZ ddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddlZddlZddlZddlmZ  ej$                  «       dk(  Z ej$                  «       dk(  ZddlmZmZmZ ddlmZ dd	lmZmZ dd
lmZm Z m!Z!m"Z"m#Z#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z,m-Z-  ej\                  e/«      Z0 e&«       dz  Z1e1Z2defd„Z3dZ4dZ5dZ6dZ7dZ8dZ9dZ:dZ;dZ<dZ=dZ>dZ?dZ@daAe$eB   eCd<    ejˆ                  «       ZEdaFdZGd ZHd!ZId"ZJdeKfd#„ZLd$eMd%eMd&eMde!eM   fd'„ZNdefd(„ZOd)edeBfd*„ZPdŽd+e$e eMeMf      de eMeMf   fd,„ZQde$eB   fd-„ZRdeBfd.„ZSdeBfd/„ZTd0e!eM   d1eMde!eM   fd2„ZUd3aV G d4„ d5eW«      ZXd6eMd7eMddfd8„ZYd9ZZd:Z[ G d;„ d<e#«      Z\d=e eMeMf   deBfd>„Z]d3d?œd@e!eM   d1eMdAeBdBeBde\f
dC„Z^d%eMdeBfdD„Z_dEeKdeMfdF„Z`dGeMdeafdH„ZbdIdJdKeKdeMfdL„ZcdIdJdeafdM„Zde G dN„ dJ«      «       ZedOZfd@dPdQdRdSdTdUdVdWdXg
dY„ efD «       ¢dZ‘d[‘d\‘d]‘d^‘d_‘­ZgeejÐ                  jÓ                  «       D � ci c]8  } | jÔ                  egv r(| jÔ                  | jÔ                  d^k(  rg n| jÖ                  “Œ: c} Zl G d`„ dae*«      Zm em«       ZnddblompZpmqZq dcdddedfg dg¢dhœdfdidjœdfdkdjœdldmdndoœdldpdjœdldqdndoœdrœdsgdtœduœZrdvdwœdxeMd@eMdye$eK   dVeMdeMf
dz„Zsd{eadeafd|„Ztdeafd}„Zud~„ dfd€„ dfd�„ dfd‚„ dfdƒ„ d3fd„„ d3fd…„ d3fd†œZvdGeMd‡eadVe$eM   deafdˆ„ZwdZxd‰„ Zy epjô                  dcdŠereyd‹¬Œ«       d�Z{yc c} w )�aK  Process Registry -- in-memory registry for background processes spawned via
terminal(background=true): rolling 200KB output buffer, poll/log/wait/kill, JSON
checkpoint for crash recovery, session-scoped tracking for gateway reset protection.
Nothing runs on the host unless TERMINAL_ENV=local; other backends run in their sandbox.
é    N)Úsuppress)ÚPathÚWindowsÚLinux)Ú_find_shellÚ_resolve_safe_cwdÚ_sanitize_subprocess_env)Úwindows_hide_flags)Ú	dataclassÚfield)ÚAnyÚDictÚListÚLiteralÚ
NamedTupleÚOptional)Úget_hermes_home)Úformat_process_notification)ÚProcessCheckpointMixin)Úload_completed_resultsÚsave_completed_resultúprocesses.jsonÚreturnc                  óB   — t         t        k7  rt         S t        «       dz  S )u7  Active profile's checkpoint file at call time: the patched ``CHECKPOINT_PATH`` when a test
    changed it, else live profile-scoped HERMES_HOME â€” the multiplexed gateway serves every
    profile from one process, so the import-time constant would pin every profile's process
    checkpoint to the launch home.r   )ÚCHECKPOINT_PATHÚ_CHECKPOINT_PATH_AT_IMPORTr   © ó    ú;/home/ubuntu/.hermes/hermes-agent/tools/process_registry.pyÚ_checkpoint_pathr    .   s!   € ô
 .Ô1KÒKŒ?ÐuÔQ`ÓQbÐeuÑQuÐur   i@ éÐ  i  é@   é   é   é   é<   é   é
   é   Ú_SYSTEMD_SCOPE_AVAILABLEç        g      N@i   i   @l        c                  óX  — d} t        j                  dd«      j                  «       }|r<	 t        |«      dz  dz  }|t
        k\  r|} nt        j                  d|t
        dz  «       g }t        t        t        «      5  t        d«      j                  d	¬
«      j                  «       }t        d„ |D «       d«      }|�Ž|j                  d«      d   j                  d«      }t        d«      |z  dz  j                  d	¬
«      j                  «       }|j!                  «       r,t        |«      t
        k\  r|j#                  t        |«      «       ddd«       t        t        t        t$        «      5  t        t        j&                  d«      «      t        t        j&                  d«      «      z  }|j#                  t)        t*        t-        t
        |dz  «      «      «       ddd«       |rt)        |«      nt.        }	| rt)        | |	«      S |	S # t        $ r d}Y �ŒÕw xY w# 1 sw Y   ŒÍxY w# 1 sw Y   ŒJxY w)añ  Finite per-worker cgroup limit that can never widen host risk.
    ``TERMINAL_LOCAL_MEMORY_MAX_MB`` is honored only when it *tightens* the safe
    bound (min of the gateway's cgroup-v2 ``memory.max`` and half of physical RAM,
    capped at 4 GiB), so an oversized override cannot exceed the enclosing slice.

    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.
    NÚTERMINAL_LOCAL_MEMORY_MAX_MBÚ i   éÿÿÿÿzbIgnoring invalid TERMINAL_LOCAL_MEMORY_MAX_MB=%r; expected an integer representing at least %d MiBi   z/proc/self/cgroupúutf-8)Úencodingc              3   óD   K  — | ]  }|j                  d «      sŒ|–— Œ y­w)z0::N)Ú
startswith©Ú.0Úlns     r   ú	<genexpr>z+_worker_memory_max_bytes.<locals>.<genexpr>‹   s   è ø€ Ò>˜"¨¯©°uÕ)=”2Ñ>ùs   ‚ ™ z::é   ú/z/sys/fs/cgroupz
memory.maxÚSC_PHYS_PAGESÚSC_PAGE_SIZE)ÚosÚgetenvÚstripÚintÚ
ValueErrorÚ_MIN_WORKER_MEMORY_MAX_BYTESÚloggerÚwarningr   ÚOSErrorr   Ú	read_textÚ
splitlinesÚnextÚ	partitionÚlstripÚisdigitÚappendÚ	TypeErrorÚsysconfÚminÚ_WORKER_MEMORY_MAX_CAP_BYTESÚmaxÚ _DEFAULT_WORKER_MEMORY_MAX_BYTES)
Úoverride_boundÚoverrideÚparsedÚ
candidatesÚlinesÚv2ÚrelativeÚ	raw_limitÚphysical_bytesÚ
safe_bounds
             r   Ú_worker_memory_max_bytesr\   q   sì  € ð %)€NÜ�y‰yÐ7¸Ó<×BÑBÓD€HÙð	Ü˜“] TÑ)¨DÑ0ˆFð Ô1Ò1Ø#‰Nä�N‰NðCàÔ6¸;ÑGôIð €JÜ	”'œ:Ó	&ñ 2ÜÐ(Ó)×3Ñ3¸WÐ3ÓE×PÑPÓRˆÜÑ> Ô>ÀÓEˆØˆ>Ø—|‘| DÓ)¨!Ñ,×3Ñ3°CÓ8ˆHÜÐ.Ó/°(Ñ:¸\ÑI×TÑTÐ^eÐTÓf×lÑlÓnˆIØ× Ñ Ô"¤s¨9£~Ô9UÒ'UØ×!Ñ!¤# i£.Ô1÷2ô 
”'œ:¤yÓ	1ñ uÜœRŸZ™Z¨Ó8Ó9¼CÄÇ
Á
È>Ó@ZÓ<[Ñ[ˆØ×Ñœ#Ô:¼CÔ@\Ð^lÐpqÑ^qÓ<rÓsÔt÷uñ %/”�Z”Ô4T€JÙ.<Œ3ˆ~˜zÓ*ÐLÀ*ÐLøô- ò 	Ø‹Fð	ú÷2ð 2ú÷uð uús+   ªH Á;CHÅ)A.H ÈHÈHÈHÈ H)ÚbinaryÚ	unit_nameÚargvc                 ó8   — | dddd|dddddt        «       › �d	g|¢S )
zì``systemd-run --user --scope`` argv shared by the probe and real spawns.
    ``--collect`` self-cleans the scope after exit; ``--unit`` names it for systemctl.
    No ``OOMPolicy=``: transient scopes reject it on systemd <253 (#102486).ú--userz--scopez--quietz--unitz	--collectz
--propertyzMemoryAccounting=yesz
MemoryMax=z--)r\   )r]   r^   r_   s      r   Ú_systemd_scope_argvrb   ˜   sA   € ð
 	�˜) Y°¸)À[ØÐ,Ø˜
Ô#;Ó#=Ð">Ð?Øð	ð ð	ð r   c                  óB   — t        dt        j                  «       › �«      S )zW``/run/user/<uid>``; a function so tests can point it at a temp dir with a real socket.z
/run/user/)r   r<   Úgetuidr   r   r   Ú_default_user_runtime_dirre   ¤   s   € ä�*œRŸY™Y›[˜MÐ*Ó+Ð+r   Úpathc                 ó  — 	 | j                  «       }| j                  «       xrV t        j                  |j                  «      xr5 |j
                  t        j                  «       k(  xr |j                  dz  dk(  S # t        $ r Y yw xY w)z<Accept only an absolute, owned, non-writable real directory.é   r   F)	ÚlstatÚis_absoluteÚstatÚS_ISDIRÚst_modeÚst_uidr<   rd   rD   )rf   Úmetadatas     r   Ú_secure_user_runtime_dirrp   ©   s   € ð	Ø—:‘:“<ˆà×ÑÓò .Ü—‘˜X×-Ñ-Ó.ò.à—‘¤2§9¡9£;Ñ.ò.ð × Ñ  5Ñ(¨AÑ-ð		
øô ò Ùðús   ‚A7A: Á:	BÂBÚbase_envc                 óâ  — t        | €t        j                  n| «      }t        s|S |j	                  d«      }|r t        t        |«      «      rt        |«      }nt        «       }t        |«      s|S |dz  }	 |j                  «       }t        j                  |j                  «      r!|j                  t        j                  «       k7  r|S t        |«      |d<   d|› �|d<   |S # t        $ r |cY S w xY w)a§  Build an environment that can reach this user's lingering systemd manager.

    System-level gateway units run as an unprivileged ``User=`` but normally do
    not inherit login-session variables.  When the conventional runtime
    directory is owned by this uid and its bus exists, derive the two standard
    variables.  Derived fresh on every call rather than adopted once at boot:
    linger may be enabled after the gateway started (existing installs), so
    the bus can appear later and the probe's failure TTL must be able to
    recover (#104893).
    The returned copy is passed explicitly to the probe and every scoped spawn;
    ``os.environ`` is left unchanged.
    ÚXDG_RUNTIME_DIRÚbusz
unix:path=ÚDBUS_SESSION_BUS_ADDRESS)Údictr<   ÚenvironÚ	_IS_LINUXÚgetrp   r   re   ri   rD   rk   ÚS_ISSOCKrm   rn   rd   Ústr)rq   ÚenvÚ
configuredÚruntime_dirÚbus_pathÚbus_metadatas         r   Úsystemd_user_bus_envr�   ·   sã   € ô ˜XÐ-Œr�zŠz°8Ó
<€CÝØˆ
Ø—‘Ð*Ó+€JÙÔ.¬t°JÓ/?Ô@Ü˜:Ó&‰ä/Ó1ˆÜ'¨Ô4ØˆJà˜UÑ"€HðØ—~‘~Ó'ˆô �=‰=˜×-Ñ-Ô.°,×2EÑ2EÌÏÉËÒ2TØˆ
ä  Ó-€CÐÑØ(2°8°*Ð&=€CÐ"Ñ#Ø€Jøô ò ØŠ
ðús   Á6C  Ã C.Ã-C.c                  óh   — t         €yt        j                  «       t        z
  t        k\  } | rdS t         S )z6Cached probe verdict, or None when a (re)probe is due.N)r*   ÚtimeÚ	monotonicÚ_SYSTEMD_SCOPE_PROBED_ATÚ _SYSTEMD_SCOPE_PROBE_TTL_SECONDS)Ústales    r   Ú_systemd_scope_cachedrˆ   Ü   s1   € äÐ'ØÜ�N‰NÓÔ7Ñ7Ô;[Ñ[€EÙˆ4Ð6Ô6Ð6r   c            
      óÖ  — t        «       } | �| S t        5  t        «       } | �| cddd«       S d}t        rÝ	 ddl}|j	                  d«      }|rÅdt        j                  «       › dt        j                  «       j                  dd › �}t        j                  t        ||dd	d
«      ddt        «       ¬«      }|j                  dk(  }|sMt        j!                  d|j                  |j"                  xs dj%                  dd«      j'                  «       «       |at-        j.                  «       a|cddd«       S # t(        $ r }t        j!                  d|«       Y d}~ŒEd}~ww xY w# 1 sw Y   yxY w)a¸  True if ``systemd-run --user --scope`` can create a cgroup.
    ``shutil.which`` alone is insufficient: system services and containers may lack
    the user D-Bus bus even with the binary on PATH (every spawn would fail with
    ``Failed to connect to user bus``), so a cheap probe is run and cached.

    Use ``/bin/sh -c 'exit 0'``: NixOS provides ``/bin/sh`` but not ``/bin/true``
    (#105365), regardless of the gateway service's PATH.NFr   úsystemd-runzhermes-probe-scope-Ú-r%   z/bin/shz-czexit 0Tr$   )Úcapture_outputÚtimeoutr|   z3systemd-run --user --scope probe failed (rc=%s): %sr   r0   Úreplacez*systemd-run --user --scope probe error: %s)rˆ   Ú_SYSTEMD_SCOPE_PROBE_LOCKrx   ÚshutilÚwhichr<   ÚgetpidÚuuidÚuuid4ÚhexÚ
subprocessÚrunrb   r�   Ú
returncoderB   ÚdebugÚstderrÚdecoder>   Ú	Exceptionr*   rƒ   r„   r…   )ÚverdictÚ	availabler�   r]   Ú
probe_unitÚresultÚexcs          r   Ú!_systemd_run_user_scope_availabler¢   ä   s[  € ô $Ó%€GØÐØˆô 
#ñ Ü'Ó)ˆØÐØ÷ñ ð ˆ	ÝðPÛàŸ™ mÓ4�Ùà#6´r·y±y³{°mÀ1ÄTÇZÁZÃ\×EUÑEUÐVXÐWXÐEYÐDZÐ![�JÜ'Ÿ^™^Ü+¨F°JÀ	È4ÐQYÓZØ'+Ø !Ü0Ó2ô	�Fð !'× 1Ñ 1°QÑ 6�IÙ$ÜŸ™ØQØ"×-Ñ-°·±Ò0DÀ×/LÑ/LÈWÐV_Ó/`×/fÑ/fÓ/hôð $-Ð Ü#'§>¡>Ó#3Ð Ø÷;ñ øô2 ò PÜ—‘ÐIÈ3×OÑOûðPú÷3ð ús:   •E­E¶CD3ÄEÄ3	EÄ<EÅEÅEÅEÅE(c                  ó  — t         j                  j                  d«      dk7  ry	 ddlm}  ddlm}  | «       xr  |d¬«      t        j                  «       k(  S # t        $ r }t        j                  d|«       Y d	}~yd	}~ww xY w)
u'  Whether this process is the live, supervised Hermes gateway itself.
    Supervisor markers and ``_HERMES_GATEWAY`` are inherited by every descendant (and
    importing ``gateway.run`` sets the latter), so also require ownership of the live
    gateway PID file â€” scopes are for the gateway, not terminal children or CLIs.
    Reads the launch marker (``HERMES_SUPERVISED_CHILD`` included), not the restart-route
    probe: a Windows Scheduled-Task gateway sets only that marker, and the self-kill guards
    gated here must protect it too (#113667).Ú_HERMES_GATEWAYÚ1Fr   )Úis_supervised_gateway_launch)Úget_running_pid)Úcleanup_stalez8Could not verify supervised gateway process identity: %sN)r<   rw   ry   Úgateway.restartr¦   Úgateway.statusr§   r’   rœ   rB   r™   )r¦   r§   r¡   s      r   Ú_is_supervised_gateway_processr«     sn   € ô 
‡z�z‡~�~Ð'Ó(¨CÒ/ØðÝ@Ý2á+Ó-Òe±/ÐPUÔ2VÔZ\×ZcÑZcÓZeÑ2eÐeøÜò Ü�‰ÐOÐQTÔUÜûðús   ¥2A Á	BÁ!A<Á<BÚ
shell_argvÚunit_suffixc                 óT   — ddl }|j                  d«      }|€| S t        |d|› �g| ¢­Ž S )aK  Wrap *shell_argv* in a ``systemd-run --user --scope`` invocation with its own
    memory accounting, so an OOM in the worker cannot kill the gateway cgroup.

    ``--collect`` makes the transient scope self-clean after exit; ``--unit`` gives it a recognisable name
    for ``systemctl --user status`` / journalctl. See #70716.
    r   NrŠ   úhermes-worker-)r�   r‘   rb   )r¬   r­   r�   r]   s       r   Ú_build_systemd_scope_argvr°   &  s9   € ó à�\‰\˜-Ó(€FØ€~àÐÜ˜v¨¸°}Ð'EÐSÈ
ÒSÐSr   Fc                   ó   — e Zd ZdZy)ÚRestartSafeScopeUnavailablea>  A ``require_restart_safe_scope=True`` child could not get its transient scope.

    Host-level (no user D-Bus / no ``systemd-run``), never a property of the
    child being launched: callers that keep per-job retry budgets must not
    charge it (a kanban card parked ``blocked`` for an unreachable bus, #114720).
    N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r   r   r²   r²   9  s   „ òr   r²   ÚdetailÚconsequencec                óD   — t         ryda t        j                  d| |«       y)zŒWarn once per process: the condition is host-level and the probe verdict
    is cached, so this would otherwise fire on every cron dispatch.NTz%s; %s)Ú_scope_degraded_warnedrB   rC   )r·   r¸   s     r   Ú_warn_scope_degraded_oncer»   B  s    € õ ØØ!ÐÜ
‡N�N�8˜V [Õ1r   zÜcron children are dispatched as direct external subprocesses without restart-safe cgroup isolation (killed if the gateway restarts mid-job). Set cron.require_restart_safe_scope=true in config.yaml to fail closed instead.a2  workers are spawned unmanaged inside this systemd unit's cgroup and will be KILLED when the unit exits (Type=oneshot dispatch timers lose every worker within a second). Give the unit's user a session bus (`loginctl enable-linger <user>`) so workers get their own scope, or set KillMode=process on the unit.c                   ó2   — e Zd ZU dZed   ed<   ee   ed<   y)ÚGatewayChildDispatchuô  How a managed-gateway child is launched.

    ``in_process``: not a managed systemd gateway, ``argv is command``, the caller
    keeps its in-process path.  ``scoped``: ``argv`` is the systemd-run wrapper.
    ``degraded``: no user scope could be created; ``argv`` is the direct command but
    the caller MUST still launch it as an external subprocess â€” the distinct mode
    exists so this case can never collapse into ``in_process`` and recreate the
    restart interruption #101940 closed.
    )Ú
in_processÚscopedÚdegradedÚmoder_   N)r³   r´   rµ   r¶   r   Ú__annotations__r   r{   r   r   r   r½   r½   Y  s   … ñð Ð4Ñ
5Ó5Ø
ˆs‰)„Or   r½   Ú	spawn_envc                 ó¼   — t        | «      }|j                  dd«       dt        |«      v ryt        5  dat        j                  «       addd«       y# 1 sw Y   yxY w)a‘  After a ``systemd-run --user --scope`` wrapper exits before its child could start: True
    when the user bus is gone (:func:`systemd_user_bus_env` derives nothing), in which case the
    cached True verdict is replaced so the next dispatch re-probes and degrades instead of
    consuming another occurrence on the same dead wrapper (#110803).

    *spawn_env* is the environment the wrapper was launched with: re-deriving from it (minus the
    bus address it carried) honours a configured ``XDG_RUNTIME_DIR`` exactly as the spawn did, so
    an unrelated wrapper exit on a host whose bus lives outside ``/run/user/<uid>`` is not
    misread as a lost bus.ru   NFT)rv   Úpopr�   r�   r*   rƒ   r„   r…   )rÃ   rq   s     r   Úscoped_spawn_lost_user_busrÆ   h  s]   € ô �I‹€HØ‡L�LÐ+¨TÔ2Ø!Ô%9¸(Ó%CÑCØÜ	"ñ 4Ø#(Ð Ü#'§>¡>Ó#3Ð ÷4ð ÷4ð ús   ²AÁA)Úoutlives_parentÚcommandÚrequire_restart_safe_scoperÇ   c                óz  ‡ ‡‡— t         st        d‰ «      S t        j                  j	                  d«      st        d‰ «      S t        «       Š‰s|st        d‰ «      S dt        dt        fˆ ˆˆfd„}t        «       s |dt        j                  «       › d�«      S t        ‰ |¬«      }|‰ k(  r |d	«      S t        d
|«      S )uØ  Place a managed-systemd gateway child outside the gateway cgroup.

    A systemd-supervised gateway restart kills every process in the service
    cgroup, so children that must survive it run in a transient user scope.
    Hosts with no user systemd session (containers, LXCs without linger) cannot
    create one; hard-failing there is a silent cron outage, so callers state the
    policy: ``require_restart_safe_scope=True`` raises
    :class:`RestartSafeScopeUnavailable` (kanban's long-lived workers), ``False``
    degrades to a direct external subprocess with a once-per-process warning
    (cron, behind ``cron.require_restart_safe_scope``).

    ``outlives_parent=True`` (fire-and-forget kanban workers): any *other*
    systemd unit â€” a ``Type=oneshot`` dispatch timer, an operator's sequencer
    service â€” tears its cgroup down when it exits, so the child is scope-wrapped
    there too (#113612). Whether that unit actually kills its children
    (``KillMode``, lifetime) is not knowable here, so without a user bus it
    degrades with a loud warning instead of refusing: a long-lived
    ``Type=simple`` sequencer without linger keeps working. A cron job blocks its
    caller until it finishes and never needs this.
    r¾   ÚINVOCATION_IDr·   r   c                 ó’   •— ‰r%‰rt        d| › �«      ‚t        d| › �t        ¬«       nt        d| › �t        ¬«       t	        d‰«      S )Nz<cannot create restart-safe systemd scope for gateway child: zmanaged gateway: )r¸   zsystemd unit dispatch: rÀ   )r²   r»   Ú_CRON_DEGRADED_CONSEQUENCEÚ_UNIT_DEGRADED_CONSEQUENCEr½   )r·   rÈ   rÉ   Úsupervised_gateways    €€€r   Ú_degradez1restart_safe_gateway_child_argv.<locals>._degrade�  sW   ø€ ÙÙ)ä1ØRÐSYÐRZÐ[óð ô &Ð(9¸&¸Ð&BÔPjÖkä%Ð(?À¸xÐ&HÔVpÕqÜ# J°Ó8Ð8r   z`systemd-run --user --scope is unavailable (usually no reachable user D-Bus session at /run/user/zs/bus). On a system-level service install, run `sudo loginctl enable-linger <gateway-user>` and restart the gateway.©r­   z4systemd-run disappeared after the availability prober¿   )
rx   r½   r<   rw   ry   r«   r{   r¢   rd   r°   )rÈ   r­   rÉ   rÇ   rÐ   r¿   rÏ   s   ` `   @r   Úrestart_safe_gateway_child_argvrÒ   }  sÁ   ú€ õ0 Ü# L°'Ó:Ð:Ü�:‰:�>‰>˜/Ô*Ü# L°'Ó:Ð:Ü7Ó9ÐÙ¡oÜ# L°'Ó:Ð:ð
9œð 
9Ô!5÷ 
9ô -Ô.ÙðÜŸ™›˜ð &TðTó
ð 	
ô
 ' w¸KÔH€FØ�ÒÙÐNÓOÐOÜ ¨&Ó1Ð1r   c                 óä  ‡— ddl }|j                  d«      }|€y	 t        j                  |dd| gddt        j                  t        «       ¬	«      }|j                  dk7  rf|j                  xs d
j                  d¬«      j                  «       Št        ˆfd„dD «       «      ryt        j                  d| |j                  ‰«       yy# t        $ r!}t        j                  d| |«       Y d}~yd}~ww xY w)uh  Stop a transient systemd user scope by unit name.
    Reaps the *entire* cgroup â€” catching double-forked descendants reparented to init
    inside the scope that survive a plain PID signal (SIGTERM all, SIGKILL after
    ``TimeoutStopSec``). True if stopped or already gone; False if ``systemctl`` is
    unavailable or the stop failed.

    See #70716.
    r   NÚ	systemctlFra   ÚstopTr#   )rŒ   r�   Ústdinr|   r   rŽ   ©Úerrorsc              3   óB   •K  — | ]  }|‰j                  «       v –— Œ y ­w©N)Úlower)r5   Úmarkerrš   s     €r   r7   z%_stop_systemd_unit.<locals>.<genexpr>Í  s   øè ø€ Òh°�6˜VŸ\™\›^Ô+Ñhùs   ƒ)z
not loadedz	not foundzdoes not existz&systemctl --user stop %s exited %d: %sz#systemctl --user stop %s failed: %s)r�   r‘   r–   r—   ÚDEVNULLr�   r˜   rš   r›   r>   ÚanyrB   r™   rœ   )r^   r�   r]   r    r¡   rš   s        @r   Ú_stop_systemd_unitrß   µ  sÝ   ø€ ó à�\‰\˜+Ó&€FØ€~ØðÜ—‘Ø�X˜v yÐ1ØØÜ×$Ñ$Ü$Ó&ô
ˆð ×Ñ Ò!Ø—m‘mÒ* s×2Ñ2¸)Ð2ÓD×JÑJÓLˆFÜÓhÐ:gÔhÔhØÜ�L‰LÐAÀ9Èf×N_ÑN_ÐagÔhØØøÜò Ü�‰Ð:¸IÀsÔKÜûðús   ›BC Â!"C Ã	C/ÃC*Ã*C/Úsecondsc                 ó¦   — t        dt        | «      «      }|dk  r|› d�S t        |d«      \  }}|dk  r|› d|› d�S t        |d«      \  }}|› d|› d�S )Nr   r&   Úszm zh Úm)rP   r?   Údivmod)rà   râ   ÚminsÚsecsÚhourss        r   Úformat_uptime_shortrè   ×  sp   € ÜˆAŒs�7‹|Ó€AØˆ2‚vØ��AˆwˆÜ˜˜2“�J€Dˆ$Øˆb‚yØ��r˜$˜˜qÐ!Ð!Ü˜˜rÓ"�K€Eˆ4ØˆW�B�t�f˜AÐÐr   Ú
session_idc                 ó   — dd| › �dœS )NÚ	not_foundzNo process with ID ©ÚstatusÚerrorr   )ré   s    r   Ú
_not_foundrï   â  s   € Ø!Ð.AÀ*ÀÐ,NÑOÐOr   ÚsessionÚProcessSessionÚnc                 ó:   — ddl m}  || j                  | d «      S )zBLast *n* chars of the session output with ANSI sequences stripped.r   ©Ú
strip_ansiN)Útools.ansi_striprõ   Úoutput_buffer)rð   rò   rõ   s      r   Ú_output_tailrø   æ  s   € å+á�g×+Ñ+¨Q¨B¨CÐ0Ó1Ð1r   c                 óŽ   — | j                   xs t        }t        | j                  «      |z
  }dt	        | |«      i|dkD  rd|i¥S i ¥S )ag  ``output`` sized by the session's ``completion_output_chars`` plus ``output_cut`` when trimmed.

    Shared by the completion notification AND the wait/poll/kill snapshots: a bot in an api_server
    or one-shot session cannot receive notifications and polls instead, so the polled result must
    carry the same whole reply and the same cut marker (#115334).Úoutputr   Ú
output_cut)Úcompletion_output_charsÚCOMPLETION_OUTPUT_CHARSÚlenr÷   rø   )rð   ÚlimitÚcuts      r   Ú_completion_outputr  í  sV   € ð ×+Ñ+ÒFÔ/F€EÜ
ˆg×#Ñ#Ó
$ uÑ
,€CØ”l 7¨EÓ2Ð_ÈcÐTUÊg¸ÀcÐ7JÐ_Ð_Ð[]Ð_Ð_r   c                   óN  — e Zd ZU dZeed<   eed<   dZeed<   dZeed<   dZeed<   dZ	e
e   ed	<   dZe
ej                     ed
<   dZeed<   dZe
e   ed<   dZeed<   dZe
e   ed<   dZeed<   dZeed<   dZe
e   ed<   dZeed<   dZeed<   dZeed<   eZeed<   dZeed<   dZeed<   dZ eed<   dZ!eed<   dZ"eed<   dZ#eed<   dZ$eed<   dZ%eed <   dZ&eed!<   dZ'eed"<   d#Z(eed$<   dZ)eed%<   dZ*eed&<   d#Z+eed'<    e,e-¬(«      Z.e/e   ed)<   d#Z0eed*<   d#Z1eed+<    e,dd¬,«      Z2eed-<    e,d#d¬,«      Z3eed.<    e,d#d¬,«      Z4eed/<    e,d#d¬,«      Z5eed0<    e,d#d¬,«      Z6eed1<    e,dd¬,«      Z7eed2<    e,dd¬,«      Z8eed3<    e,dd¬,«      Z9eed4<    e,d#d¬,«      Z:eed5<    e,e;jx                  d¬6«      Z=e;jx                  ed7<    e,e;j|                  ¬(«      Z?e;j|                  ed8<    e,dd¬,«      Z@e
e;j‚                     ed9<    e,dd¬,«      ZBeed:<   d;ed<dfd=„ZCdAd>ed?ed<dfd@„ZDy)Brñ   z3A tracked background process with output buffering.ÚidrÈ   r.   Útask_idÚowner_task_idÚsession_keyNÚpidÚprocessÚenv_refÚcwdr+   Ú
started_atÚhost_start_timeFÚexitedÚ	exited_atÚ	exit_codeÚcompletion_reasonÚtermination_sourcer÷   Úmax_output_charsÚdetachedÚhostÚ	pid_scopeÚsystemd_unitÚhandoff_noteÚwatcher_platformÚwatcher_chat_idÚwatcher_user_idÚwatcher_user_nameÚwatcher_thread_idÚwatcher_message_idr   Úwatcher_intervalÚparent_session_idÚnotify_on_completerü   )Údefault_factoryÚwatch_patternsÚheartbeat_secondsÚtotal_output_chars)ÚdefaultÚreprÚ_heartbeat_lastÚ_heartbeat_total_at_lastÚ_heartbeat_seqÚ_watch_hitsÚ_watch_suppressedÚ_watch_disabledÚ_watch_cooldown_untilÚ_watch_strike_candidateÚ_watch_consecutive_strikes)r!  r&  Ú_completion_eventÚ_lockÚ_reader_threadÚ_ptyÚtextr   c                 ó.  — | j                   5  | xj                  |z  c_        | xj                  t        |«      z  c_        t        | j                  «      | j                  kD  r| j                  | j                   d | _        ddd«       y# 1 sw Y   yxY w)zMAppend to the rolling output buffer under the session lock, keeping the tail.N)r1  r÷   r$  rþ   r  )Úselfr4  s     r   Úappend_outputzProcessSession.append_output4  s€   € à�Z‰Zñ 	QØ×Ò $Ñ&ÕØ×#Ò#¤s¨4£yÑ0Õ#Ü�4×%Ñ%Ó&¨×)>Ñ)>Ò>Ø%)×%7Ñ%7¸×9NÑ9NÐ8NÐ8OÐ%P�Ô"÷		Q÷ 	Qñ 	Qús   �A5BÂBÚreasonÚsourcec                 ób   — d| _         | j                  dk7  r|| _        || _        |r|| _        yyy)zuRecord an exit. A kill that raced the observer already recorded its own
        exit_code/reason; never overwrite it.TÚkilledN)r  r  r  r  )r6  r  r8  r9  s       r   Úmark_exitedzProcessSession.mark_exited<  s=   € ð ˆŒØ×!Ñ! XÒ-Ø&ˆDŒNØ%+ˆDÔ"ÙØ*0�Õ'ð ð .r   )r  r.   )Er³   r´   rµ   r¶   r{   rÂ   r  r  r  r  r   r?   r  r–   ÚPopenr	  r   r
  r  Úfloatr  r  Úboolr  r  r  r  r÷   ÚMAX_OUTPUT_CHARSr  r  r  r  r  r  r  r  r  r  r  r  r  r   rü   r   Úlistr"  r   r#  r$  r'  r(  r)  r*  r+  r,  r-  r.  r/  Ú	threadingÚEventr0  ÚLockr1  r2  ÚThreadr3  r7  r<  r   r   r   rñ   rñ   ø  s¼  … á=ØƒGØƒLØ€GˆSÓà€M�3Óà€K�ÓØ€Cˆ�#‰ÓØ*.€GˆX�j×&Ñ&Ñ'Ó.Ø€GˆSÓØ€Cˆ�#‰ÓØ€J�ÓØ%)€O�X˜c‘]Ó)Ø€FˆDÓØ€IˆuÓØ#€Iˆx˜‰}Ó#Ø%Ð�sÓ%Ø Ð˜Ó Ø€M�3ÓØ,Ð�cÓ,Ø€HˆdÓØ€IˆsÓØ€L�#ÓØ€L�#Óð Ð�cÓØ€O�SÓØ€O�SÓØÐ�sÓØÐ�sÓØ Ð˜Ó ØÐ�cÓð  Ð�sÓØ$Ð˜Ó$Ø#$Ð˜SÓ$Ù %°dÔ ;€N�D˜‘IÓ;ØÐ�sÓØÐ˜ÓÙ"¨3°UÔ;€O�UÓ;Ù$)°!¸%Ô$@Ð˜cÓ@Ù¨°Ô6€N�CÓ6Ù Q¨UÔ3€K�Ó3Ù"¨1°5Ô9Ð�sÓ9Ù!¨%°eÔ<€O�TÓ<á#(°¸5Ô#AÐ˜5ÓAÙ$)°%¸eÔ$DÐ˜TÓDÙ&+°A¸EÔ&BÐ ÓBÙ).¸y¿¹ÐUZÔ)[Ð�y—‘Ó[Ù!°)·.±.ÔA€Eˆ9�>‰>ÓAÙ16¸tÈ%Ô1P€N�H˜Y×-Ñ-Ñ.ÓPÙ˜d¨Ô/€Dˆ#Ó/ðQ #ð Q¨$ó Qñ1¨Sð 1ÀSð 1ÐRVô 1r   )ÚplatformÚchat_idÚuser_idÚ	user_nameÚ	thread_idÚ
message_idr  r  r  r  r
  r  r  r  r  c              #   ó&   K  — | ]	  }d |› �–— Œ y­w)Úwatcher_Nr   )r5   Úks     r   r7   r7   N  s   è ø€ Ò2˜ˆ��„nÑ2ùs   ‚r  r  r   rü   r"  r#  c                   óÞ  — e Zd ZdZdZd„ Zdededefd„Zdœd	„Z	dœd
„Z
dededdfd„Zededefd„«       Zdededdfd„Zdededdfd„Zdedededdfd„Zededefd„«       Zedededefd„«       Zdedefd„Zedee   defd„«       Zedee   dee   fd„«       Zedee   dee   defd„«       Zdee   dee   fd „Zedefd!„«       Zed"ed#efd$„«       Zed#ed%edefd&„«       Z edefd'„«       Z!ed�dedee   ddfd(„«       Z"edede#e   fd)„«       Z$d*Z%dd+de#e   fd,„Z&dd+de#e   fd-„Z'edefd.„«       Z(ed/e)defd0„«       Z*ded1ed2ed3ede#e   f
d4„Z+ed5edefd6„«       Z,džded7eddfd8„Z-ded1ed5edefd9„Z.	 	 dŸd<ed=ed>ed?ed5ed@edAedefdB„Z/dedCe0jb                  ddfdD„Z2d:d:d:d:dEdFœdCe0jb                  d<ed=ee   d>ed?edAedGedHedefdI„Z3	 	 d d/e)d<ed=ed>ed?edJedAedefdK„Z4defdL„Z5dœdM„Z6edNedOedefdP„«       Z7ded/e)dQedRedSef
dT„Z8defdU„Z9dededdfdV„Z:deddfdW„Z;dedefdX„Z<ededefdY„«       Z=defdZ„Z>d[edefd\„Z?d[edefd]„Z@	 d�dd*d^œd>ee   dJedz  d_edefd`„ZAedefda„«       ZBdEdbœd[edcedefdd„ZCedefde„«       ZDedfed?edgedefdh„«       ZE	 d¡dEdbœd?edceddifdj„ZFdkZGd[edee   fdl„ZHd[edee   fdm„ZId¢dn„ZJededefdo„«       ZKd[edefdp„ZLd£d[edOedz  dqedefdr„ZMd�d[edJedefds„ZNededtedefdu„«       ZOdvdEdwœd[edxedyedefdz„ZPded[edyedee   fd{„ZQd[ed|edefd}„ZRd[ed~edefd„ZSd¤d[ed~edefd€„ZTd[edefd�„ZUd[edefd‚„ZVdefdƒ„ZWd¥d;d„œd>ed?ed…edeXfd†„ZYdefd‡„ZZd>edefdˆ„Z[dAede#e   fd‰„Z\dAede#e   fdŠ„Z]d:d‹œd[edŒed�edŽed�ed�edee   fd‘„Z^d�d?ed’ee   defd“„Z_defd”„Z`d>edeae   fd•„Zbd>edxedefd–„Zc	 d� ea«       d—d;d˜œd>ee   d™eadxedyedef
dš„Zdd›„ Zey)¦ÚProcessRegistryzáIn-memory registry of running and finished background processes.
    Thread-safe: accessed from executor threads (terminal_tool, process handlers),
    the gateway asyncio loop (watchers, reset checks) and the cleanup thread.)zno job control in this shellz!cannot set terminal process groupz)tcsetattr: Inappropriate ioctl for devicec                 óì  — i | _         i | _        t        j                  «       | _        g | _        dd l}|j                  «       | _        	 ddl	m
}  || j                  «       t        «       | _        t        «       | _        t        j                  «       | _        dx| _        | _        dx| _        | _        d | _        d | _        d | _        y # t        $ r }t        j                  d|«       Y d }~Œ�d }~ww xY w)Nr   )Úrestore_undelivered_completionsz2Could not restore async delegation completions: %sr+   )Ú_runningÚ	_finishedrB  rD  r1  Úpending_watchersÚqueueÚQueueÚcompletion_queueÚtools.async_delegationrR  rœ   rB   rC   ÚsetÚ_completion_consumedÚ_poll_observedÚ_global_watch_lockÚ_global_watch_window_startÚ_global_watch_tripped_untilÚ_global_watch_window_hitsÚ$_global_watch_suppressed_during_tripÚ	on_outputÚon_closeÚ_heartbeat_thread)r6  Ú
_queue_modrR  r¡   s       r   Ú__init__zProcessRegistry.__init__a  sÙ   € Ø35ˆŒØ46ˆŒÜ—^‘^Ó%ˆŒ
à68ˆÔó 	#Ø2<×2BÑ2BÓ2DˆÔð	VÝNÙ+¨D×,AÑ,AÔBô
 *-«ˆÔ!ô $'£5ˆÔä"+§.¡.Ó"2ˆÔØMPÐPˆÔ'¨$Ô*JØUVÐVˆÔ&¨Ô)Rð ˆŒØˆŒØ=AˆÕøô+ ò 	VÜ�N‰NÐOÐQT×UÑUûð	Vús   Á	C
 Ã
	C3ÃC.Ã.C3rð   rà   r   c                 óº   — t        t        |«      t        «      }||_        t	        j                  «       |_        |j                  |_        | j                  «        |S )zQEnable periodic heartbeat events for ``session``; returns the effective interval.)	rP   r?   ÚHEARTBEAT_MIN_SECONDSr#  rƒ   r'  r$  r(  Ú_ensure_heartbeat_thread)r6  rð   rà   s      r   Úarm_heartbeatzProcessRegistry.arm_heartbeat‡  sH   € ä”c˜'“lÔ$9Ó:ˆØ$+ˆÔ!Ü"&§)¡)£+ˆÔØ+2×+EÑ+EˆÔ(Ø×%Ñ%Ô'Øˆr   Nc                 ó(  — | j                   5  | j                  �$| j                  j                  «       r
	 d d d «       y t        j                  | j
                  dd¬«      | _        | j                  j                  «        d d d «       y # 1 sw Y   y xY w)Nzprocess-heartbeatT)ÚtargetÚnameÚdaemon)r1  rd  Úis_aliverB  rE  Ú_heartbeat_loopÚstart©r6  s    r   ri  z(ProcessRegistry._ensure_heartbeat_thread�  s~   € Ø�Z‰Zñ 	+Ø×%Ñ%Ð1°d×6LÑ6L×6UÑ6UÔ6WØ÷	+ð 	+ô &/×%5Ñ%5Ø×+Ñ+Ð2EÈdô&TˆDÔ"à×"Ñ"×(Ñ(Ô*÷	+÷ 	+ñ 	+ús   �(B¾ABÂBc                 óš  — 	 t        j                  t        «       t        j                   «       }| j                  5  | j                  j                  «       D �cg c];  }|j                  dkD  r*|j                  s||j                  z
  |j                  k\  r|‘Œ= }}ddd«       D ]  }| j                  ||«       Œ Œºc c}w # 1 sw Y   Œ(xY w)z¤One daemon thread for every heartbeat session: reader threads block on the pipe and
        cannot keep time, and a per-process timer would leak one thread per job.r   N)
rƒ   ÚsleepÚHEARTBEAT_TICK_SECONDSr1  rS  Úvaluesr#  r  r'  Ú_emit_heartbeat)r6  Únowrâ   Úduerð   s        r   rp  zProcessRegistry._heartbeat_loop˜  sÄ   € ð Ü�J‰JÔ-Ô.Ü—)‘)“+ˆCØ—‘ñ KØ"&§-¡-×"6Ñ"6Ó"8ö K˜QØ×-Ñ-°Ò1¸!¿(º(Ø ×!2Ñ!2Ñ2°a×6IÑ6IÒIò ð K�ð K÷Kð ò 3�Ø×$Ñ$ W¨cÕ2ð3ð ùòK÷Kð Kús   »CÁA B<ÂCÂ<CÃC
rx  c                 ór  — |j                   5  |j                  |j                  z
  }|dkD  r|j                  | d  nd}|j                  |_        d d d «       t	        «      t
        kD  r#t	        |«      t
        z
  }d|› d�|t
         d  z   }||_        |xj                  dz  c_        i | j                  |«      ¥d|j                  |j                  |j                  rt        ||j                  z
  «      nd||j                  dœ¥}t        |«       | j                  j                  |«       y # 1 sw Y   ŒßxY w)Nr   r.   z...(z earlier characters omitted)
é   Ú	heartbeat)ÚtypeÚseqÚintervalÚelapsedrú   r  )r1  r$  r(  r÷   rþ   ÚHEARTBEAT_OUTPUT_CHARSr'  r)  Ú_watch_event_baser#  r  r?   Ú_redact_process_resultrX  Úput)r6  rð   rx  Údeltarú   r   Únotifications          r   rw  zProcessRegistry._emit_heartbeat¥  s5  € Ø�]‰]ñ 	JØ×.Ñ.°×1QÑ1QÑQˆEØ7<¸q²y�W×*Ñ*¨E¨6¨7Ñ3ÀbˆFØ/6×/IÑ/IˆGÔ,÷	Jô ˆv‹;Ô/Ò/Ü�f“+Ô 6Ñ6ˆCØ˜C˜5Ð >Ð?À&ÔJ`ÐI`ÐIaÐBbÑbˆFØ"%ˆÔØ×Ò !Ñ#Õð
Ø×$Ñ$ WÓ-ð
àØ×)Ñ)Ø×1Ñ1Ø8?×8JÒ8J”s˜3 ×!3Ñ!3Ñ3Ô4ÐPQØØ!×,Ñ,ò
ˆô 	˜|Ô,Ø×Ñ×!Ñ! ,Õ/÷'	Jð 	Jús   �AD-Ä-D6r4  c                 óü   ‡— | j                  d«      Š‰rXt        ˆfd„t        j                  D «       «      r6‰j	                  d«       ‰r#t        ˆfd„t        j                  D «       «      rŒ6dj                  ‰«      S )z:Strip shell startup warnings from the beginning of output.Ú
c              3   ó,   •K  — | ]  }|‰d    v –— Œ y­w)r   Nr   )r5   ÚnoiserV   s     €r   r7   z5ProcessRegistry._clean_shell_noise.<locals>.<genexpr>¿  s   øè ø€ Òc°%˜E U¨1¡XÔ-Ñcùs   ƒr   )ÚsplitrÞ   rP  Ú_SHELL_NOISE_SUBSTRINGSrÅ   Újoin)r4  rV   s    @r   Ú_clean_shell_noisez"ProcessRegistry._clean_shell_noise»  s[   ø€ ð —
‘
˜4Ó ˆÙœÓc¼?×;bÑ;bÔcÔcØ�I‰I�aŒLñ œÓc¼?×;bÑ;bÔcÕcà�y‰y˜ÓÐr   Úchunkc                 ó€   — | j                   }|�|syt        t        «      5   |||«       ddd«       y# 1 sw Y   yxY w)zRForward a chunk to the live-output sink; called from reader threads, never raises.N)rb  r   rœ   )r6  rð   r�  Úsinks       r   Ú_emit_outputzProcessRegistry._emit_outputÃ  s<   € à�~‰~ˆØˆ<™uØÜ”iÓ ñ 	!Ù�˜%Ô ÷	!÷ 	!ñ 	!ús   ¡
4´=Únew_textc           	      ó¦  ‡— |j                   r|j                  ry|j                  ry|j                  «       D �‡cg c]N  Št	        ˆfd„|j                   D «       «      r.t        ˆfd„|j                   D «       «      ‰j                  «       f‘ŒP }}|sy|d   d   }|D ��cg c]  \  }}|‘Œ	 }}}t        j                  «       }|j                  5  |j                  r¿||j                  k  r°|xj                  t        |«      z  c_
        |j                  r
	 ddd«       yd|_        |xj                  dz  c_        |j                  t        k  r
	 ddd«       yd|_        d|_        | j!                  ||j                  t        › dt"        › d�«       	 ddd«       y|j                  r|j                  sd|_        d	|_        |t"        z   |_	        |xj$                  dz  c_        |j                  }	d|_
        |j$                  t&        k\  }
|
rd|_        d|_        ddd«       d
j)                  |dd «      }t        |«      dkD  r|dd dz   }| j+                  |«      r@i | j-                  |«      ¥d||	dœ¥}t/        |«       | j0                  j3                  |«       
r| j!                  |ddt&        › d�«       yyc c}w c c}}w # 1 sw Y   Œ®xY w)as  Scan a freshly-read chunk for watch patterns and queue notifications.
        Per-session rate limiting (see WATCH_* constants): one match per cooldown
        window, a match inside the window is one strike, WATCH_STRIKE_LIMIT consecutive
        strikes or WATCH_LIFETIME_MAX_HITS total deliveries disable watching and
        promote the session to notify_on_complete.Nc              3   ó&   •K  — | ]  }|‰v –— Œ
 y ­wrÚ   r   ©r5   ÚpÚlines     €r   r7   z8ProcessRegistry._check_watch_patterns.<locals>.<genexpr>Ù  s   øè ø€ Ò4_À1°Q¸$´YÑ4_ùs   ƒc              3   ó,   •K  — | ]  }|‰v sŒ|–— Œ y ­wrÚ   r   r–  s     €r   r7   z8ProcessRegistry._check_watch_patterns.<locals>.<genexpr>Ø  s   øè ø€ ÒA˜°q¸D²y”!ÑAùs   ƒ	�r   Tr{  z7 consecutive rate-limit windows triggered (min spacing zs). Frˆ  é   r!   z
...(truncated)Úwatch_match)r}  Úpatternrú   Ú
suppressedzreached the lifetime cap of z delivered matches. )r"  r,  r  rF   rÞ   rG   Úrstriprƒ   r1  r-  r+  rþ   r.  r/  ÚWATCH_STRIKE_LIMITr   Ú_emit_watch_disabledÚWATCH_MIN_INTERVAL_SECONDSr*  ÚWATCH_LIFETIME_MAX_HITSr�  Ú_global_watch_admitr‚  rƒ  rX  r„  )r6  rð   r“  r˜  ÚhitsÚmatched_patternÚ_Úmatched_linesrx  r�  Úlifetime_exhaustedrú   r†  s      `         r   Ú_check_watch_patternsz%ProcessRegistry._check_watch_patternsË  sà  ø€ ð ×%Ò%¨×)@Ò)@Øð �>Š>Øð !×+Ñ+Ó-÷aà´Ó4_È×H^ÑH^Ô4_Ô1_ô ÓA˜W×3Ñ3ÔAÓAÀ4Ç;Á;Ã=ÒQðaˆð añ ØØ˜q™' !™*ˆØ-1×2¡' ! TšÐ2ˆÑ2Ü�i‰i‹kˆØ�]‰]ñ "	2Ø×,Ò,°°w×7TÑ7TÒ1Tð ×)Ò)¬S°Ó-?Ñ?Õ)Ø×2Ò2Ø÷"	2ð "	2ð 37�Ô/Ø×2Ò2°aÑ7Õ2Ø×5Ñ5Ô8JÒJØ÷"	2ð "	2ð +/�Ô'ð .2�Ô*Ø×)Ñ)Ø˜W×6Ñ6Ü)Ð*ð +$Ü$>Ð#?¸tðEôFð ÷'"	2ð "	2ð, ×,Ò,°W×5TÒ5TØ56�Ô2Ø.3ˆGÔ+à,/Ô2LÑ,LˆGÔ)Ø×Ò 1Ñ$ÕØ ×2Ñ2ˆJØ()ˆGÔ%à!(×!4Ñ!4Ô8OÑ!OÐÙ!Ø*.�Ô'Ø-1�Ô*÷E"	2ðF —‘˜=¨¨"Ð-Ó.ˆÜˆv‹;˜ÒØ˜E˜T�]Ð%7Ñ7ˆFØ×#Ñ# CÔ(ðØ×(Ñ(¨Ó1ðà%Ø*Ø Ø(òˆLô # <Ô0Ø×!Ñ!×%Ñ% lÔ3áØ×%Ñ%Ø˜Ð:Ô;RÐ:SÐSgÐhõð ùòsaùó 3÷"	2ð "	2ús,   »AJ<Â KÃAKÄ0KÅ:KÆA?KËKr�  Úwhyc           
      óŠ   — | j                   j                  i | j                  |«      ¥d|d|j                  › d|› d�dœ¥«       y)zNQueue the one-shot watch_disabled summary (strike-limit or lifetime-cap path).Úwatch_disabledz$Watch patterns disabled for process u    â€” ziFalling back to notify_on_complete semantics; you'll get exactly one notification when the process exits.)r}  r�  ÚmessageN)rX  r„  r‚  r  )r6  rð   r�  rª  s       r   r   z$ProcessRegistry._emit_watch_disabled  sV   € à×Ñ×!Ñ!ð #
Ø×$Ñ$ WÓ-ð#
à$Ø$à6°w·z±z°lÀ%ÈÀuðCðDò#
õ 	r   c           
      óà   — | j                   | j                  | j                  | j                  xs | j                  | j                  dœt
        D �ci c]  }|t        | d|› �«      “Œ c}¥S c c}w )zFSession identity + watcher routing fields shared by every watch event.)ré   r  r  r  rÈ   rM  )r  r  r  r  rÈ   Ú_WATCHER_ROUTE_KEYSÚgetattr)rð   Úkeys     r   r‚  z!ProcessRegistry._watch_event_base!  sn   € ð "Ÿ*™*Ø"×.Ñ.Ø—‘Ø$×2Ñ2ÒE°g·o±oØ—‘ñ
ô CVÖV¸3ˆs”G˜G x°¨uÐ%5Ó6Ñ6ÒVð
ð 	
ùò Ws   ÁA+Útype_r­  c                 ó&   — ddd| dœ|¥|ddddddœ¥S )z/Unaddressed (all-sessions) watch breaker event.r.   )ré   r  rÈ   r}  )r­  rF  rG  rH  rI  rJ  r   )r²  r­  Úextras      r   Ú_global_watch_eventz#ProcessRegistry._global_watch_event-  s3   € ð ¨R¸BÈñ
ØQVð
àØ r°bÀrÐXZò
ð 	
r   c                 ó*  — g }| j                   5  | j                  rd|| j                  k\  rU| j                  }d| _        d| _        |dc| _        | _        |dkD  r'|j                  | j                  dd|› d�|¬«      «       | j                  r'|| j                  k  r| xj                  dz  c_        d}nª|| j                  z
  t        k\  r|dc| _        | _        | j                  t        k  }|r| xj                  dz  c_        nZ|t        z   | _        | xj                  dz  c_        |j                  | j                  d	d
t        › dt        › dt        › d�«      «       ddd«       |D ]  }| j                  j                  |«       Œ S # 1 sw Y   Œ-xY w)a%  True if this watch_match may pass the global breaker.
        In cooldown: drop and count. Otherwise slide the rolling window; exceeding
        the cap trips the breaker for WATCH_GLOBAL_COOLDOWN_SECONDS with ONE
        "tripped" summary, and the cooldown's end emits ONE "released" summary.r+   r   Úwatch_overflow_releasedz%Watch-pattern notifications resumed. z1 match event(s) were suppressed during the flood.)r�  r{  FÚwatch_overflow_trippedzWatch-pattern overflow: >z notifications in zCs across all processes. Suppressing further watch_match events for ús.N)r]  r_  ra  r^  r`  rK   rµ  ÚWATCH_GLOBAL_WINDOW_SECONDSÚWATCH_GLOBAL_MAX_PER_WINDOWÚWATCH_GLOBAL_COOLDOWN_SECONDSrX  r„  )r6  rx  Úeventsr�  ÚadmitÚmsgs         r   r£  z#ProcessRegistry._global_watch_admit6  s±  € ð
 ˆØ×$Ñ$ñ 	?à×/Ò/°C¸4×;[Ñ;[Ò4[Ø!×FÑF�
Ø36�Ô0Ø<=�Ô9ØRUÐWXÐO�Ô/°Ô1OØ ’>Ø—M‘M $×":Ñ":Ø1Ø?Ø%˜,Ð&WðYà#-ð	 #;ó #/ô 0ð
 ×/Ò/°C¸$×:ZÑ:ZÒ4Zà×9Ò9¸QÑ>Õ9Ø‘à˜×8Ñ8Ñ8Ô<WÒWØVYÐ[\ÐS�DÔ3°TÔ5SØ×6Ñ6Ô9TÑT�ÙØ×2Ò2°aÑ7Ö2à7:Ô=ZÑ7Z�DÔ4Ø×=Ò=ÀÑBÕ=Ø—M‘M $×":Ñ":Ø0Ø3Ô4OÐ3Pð Q,Ü,GÐ+Hð IFä8Ð9¸ð=ó#>ô ?÷5	?ð@ ò 	+ˆCØ×!Ñ!×%Ñ% cÕ*ð	+àˆ÷E	?ð 	?ús   �EF	Æ	Fr  c                 ó$   — | syddl m}  || «      S )z1Best-effort liveness check for host-visible PIDs.Fr   )Ú_pid_exists)rª   rÁ  )r  rÁ  s     r   Ú_is_host_pid_alivez"ProcessRegistry._is_host_pid_alive`  s   € ñ Øõ 	/Ù˜3ÓÐr   c                 óF   — 	 ddl m} | r || «      S dS # t        $ r Y yw xY w)z<Kernel start ticks for a host PID, or None when unavailable.r   )Úget_process_start_timeN)rª   rÄ  rœ   )r  rÄ  s     r   Ú_safe_host_start_timez%ProcessRegistry._safe_host_start_timej  s/   € ð	Ý=Ù25Ñ)¨#Ó.Ð?¸4Ð?øÜò 	Ùð	ús   ‚ ’ ”	 Ÿ Úexpected_startc                 ó\   — | j                  |«      xr |du xs | j                  |«      |k(  S )aƒ  True only if ``pid`` is alive AND still the process we spawned.
        The kernel recycles PIDs, so a stored number can later name an unrelated
        process (seen in the wild: a browser's session leader tree-killed). The kernel
        start time captured at spawn must match the live one; with no baseline
        (legacy checkpoints, no ``/proc``) degrade to a bare liveness check.N)rÂ  rÅ  )Úclsr  rÆ  s      r   Ú_host_pid_is_oursz!ProcessRegistry._host_pid_is_ourss  s;   € ð ×%Ñ% cÓ*ò XØ˜dÐ"ÒV c×&?Ñ&?ÀÓ&DÈÑ&Vð	Xr   c                 ó\  — |�'|j                   s|j                  r|j                  dk7  r|S | j                  |j                  |j
                  «      r|S |j                  5  |j                   r|cddd«       S d\  |_         |_        ddd«       | j                  |«       |S # 1 sw Y   ŒxY w)zJUpdate recovered host-PID sessions when the underlying process has exited.Nr  )TN)	r  r  r  rÉ  r  r  r1  r  Ú_move_to_finished)r6  rð   s     r   Ú_refresh_detached_sessionz)ProcessRegistry._refresh_detached_session}  sŸ   € àˆ?˜gŸnšn°G×4DÒ4DÈ×HYÑHYÐ]cÒHcØˆNð ×!Ñ! '§+¡+¨w×/FÑ/FÔGØˆNØ�]‰]ñ 	;Ø�~Š~Ø÷	;ñ 	;ð 1;Ñ-ˆGŒN˜GÔ-÷		;ð
 	×Ñ˜wÔ'Øˆ÷	;ð 	;ús   Á B"Á8B"Â"B+c                 óˆ   — 	 ddl }| j                  «       xr | j                  «       |j                  k7  S # t        $ r Y yw xY w)zSTrue if a psutil.Process is running and not a zombie (already dead, just unreaped).r   NF)ÚpsutilÚ
is_runningrí   ÚSTATUS_ZOMBIErœ   )ÚprocrÎ  s     r   Ú_proc_alivezProcessRegistry._proc_alive�  s?   € ð	ÛØ—?‘?Ó$ÒN¨¯©«¸&×:NÑ:NÑ)NÐNøÜò 	Ùð	ús   ‚25 µ	AÁ AÚsectionr±  c                 óL   — ddl m}m}m}  | |«       | |«      }|€||    |   S |S )zß``config.yaml`` value for ``section.key``, else the DEFAULT_CONFIG value.
        Raises if config is unreadable; callers wrap with their own hard fallback so
        registry code paths never crash on a broken config file.r   )ÚDEFAULT_CONFIGÚcfg_getÚread_raw_config)Úhermes_cli.configrÕ  rÖ  r×  )rÓ  r±  ÚfallbackrÕ  rÖ  r×  Úvals          r   Ú_config_valuezProcessRegistry._config_value–  s5   € ÷
 	OÑNá‘oÓ'¨°#Ó6ˆØ/2¨{ˆ~˜gÑ& sÑ+ÐCÀÐCr   rÙ  c           	      óz   — 	 t        t        t        j                  d| |«      «      d«      S # t        $ r |cY S w xY w)zR``terminal.<key>`` as a non-negative float (0 disables); *fallback* if unreadable.Úterminalr+   )rP   r>  rP  rÛ  rœ   )r±  rÙ  s     r   Ú_config_secondszProcessRegistry._config_seconds   s=   € ð	Ü”uœ_×:Ñ:¸:ÀsÈHÓUÓVÐX[Ó\Ð\øÜò 	ØŠOð	ús   ‚), ¬:¹:c                  ó.   — t         j                  dd«      S )zGGrace (s) between SIGTERM and escalated SIGKILL; 0 disables escalation.Údaemon_term_grace_secondsg       @©rP  rÞ  r   r   r   Ú_daemon_term_grace_secondsz*ProcessRegistry._daemon_term_grace_seconds¨  s   € ô ×.Ñ.Ð/JÈCÓPÐPr   c           
      ó¸  ‡ ‡‡— |�)‰ j                  ‰|«      st        j                  d‰«       yˆfd„}t        rC	 t	        j
                  ddt        ‰«      ddgddd	d
dt        «       t        j                  ¬«       yddl}|j                  |j                  t        f}	 |j                  ‰«      }	 |j#                  d¬«      }t%        |«      5  |j'                  «        ddd«       ‰ j)                  «       Šdˆ ˆfd„} ||g«       ‰dk  r|n!|D �	cg c]  }	‰ j+                  |	«      sŒ|	‘Œ c}	}
|
D ]&  }	t%        |«      5  |	j'                  «        ddd«       Œ( |g|
¢}‰dk  ry ||«       |D ]X  }	t%        |«      5  ‰ j+                  |	«      r1|	j-                  «        t        j/                  d|	j0                  ‰«       ddd«       ŒZ y# t        t        j                  t        f$ r
  |«        Y yw xY w# |j                  $ r Y yt        t         f$ r
  |«        Y yw xY w# |$ r g }Y �Œjw xY w# 1 sw Y   �ŒTxY wc c}	w # 1 sw Y   �ŒxY w# 1 sw Y   ŒéxY w)u¯  Terminate a host-visible PID and its descendants.
        ``expected_start`` (kernel start time at spawn) is re-validated first: a mismatch
        or dead PID means the number was recycled onto a stranger and we refuse to touch
        it â€” a leaked orphan beats tree-killing someone's browser. POSIX: snapshot descendants,
        SIGTERM the parent alone so it can perform an orderly shutdown, then clean up snapshot
        descendants that survive its grace window. Survivors are SIGKILLed after a second
        ``terminal.daemon_term_grace_seconds`` window. Windows:
        ``taskkill /T /F`` (psutil's stale PPID links miss orphans there); ``os.kill``
        is the fallback.Nuf   Refusing to terminate host pid %d: start-time mismatch â€” PID was recycled onto an unrelated process.c                  óª   •— t        t        t        t        «      5  t	        j
                  ‰ t        j                  «       d d d «       y # 1 sw Y   y xY wrÚ   )r   rD   ÚProcessLookupErrorÚPermissionErrorr<   ÚkillÚsignalÚSIGTERM)r  s   €r   Ú_sigterm_quietlyz=ProcessRegistry._terminate_host_pid.<locals>._sigterm_quietly¾  s7   ø€ Üœ'Ô#5´ÓGñ -Ü—‘˜œVŸ^™^Ô,÷-÷ -ñ -ús   ›%A	Á	AÚtaskkillz/PIDz/Tz/FTr0   rŽ   r(   )rŒ   r4  r1   rØ   r�   ÚcreationflagsrÖ   r   ©Ú	recursivec                 ó  •— ‰dk  ry t        j                  «       ‰z   }t        j                  «       |k  rXt        ˆfd„| D «       «      rCt        j                  d«       t        j                  «       |k  rt        ˆfd„| D «       «      rŒAy y y y )Nr   c              3   ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wrÚ   )rÒ  )r5   r—  rÈ  s     €r   r7   zNProcessRegistry._terminate_host_pid.<locals>._wait_for_exit.<locals>.<genexpr>æ  s   øè ø€ Ò5ZÈQ°c·o±oÀa×6HÑ5Zùs   ƒçš™™™™™©?)rƒ   r„   rÞ   rt  )ÚtargetsÚdeadlinerÈ  Úgraces     €€r   Ú_wait_for_exitz;ProcessRegistry._terminate_host_pid.<locals>._wait_for_exitâ  so   ø€ Ø˜ŠzØÜ—~‘~Ó'¨%Ñ/ˆHÜ—.‘.Ó" XÒ-´#Ó5ZÐRYÔ5ZÔ2ZÜ—
‘
˜4Ô ô —.‘.Ó" XÒ-´#Ó5ZÐRYÔ5ZÖ2ZÐ-Ð2ZÐ-r   zDEscalated to SIGKILL for pid %d (ignored SIGTERM within %.1fs grace)©r   N)rÉ  rB   rC   Ú_IS_WINDOWSr–   r—   r{   r
   rÝ   ÚFileNotFoundErrorÚTimeoutExpiredrD   rÎ  ÚNoSuchProcessÚAccessDeniedÚProcessræ  Úchildrenr   Ú	terminaterâ  rÒ  rç  Úinfor  )rÈ  r  rÆ  rê  rÎ  ÚgoneÚparentÚdescendantsrõ  rÑ  Ú	remainingrò  rô  s   ``          @r   Ú_terminate_host_pidz#ProcessRegistry._terminate_host_pid­  sn  ú€ ð Ð%¨c×.CÑ.CÀCÈÔ.XÜ�N‰Nð>Ø?BôDð ô	-õ ð#Ü—‘Ø ¬¨S«°4¸Ð>ÈtÐZ^Ø$¨YÀÔRdÓRfÜ$×,Ñ,õ.ð ÛØ×$Ñ$ f×&9Ñ&9¼7ÐCˆð	Ø—^‘^ CÓ(ˆFð	Ø Ÿ/™/°D˜/Ó9ˆKô �d‹^ñ 	Ø×ÑÔ÷	ð ×.Ñ.Ó0ˆö	!ñ 	˜�xÔ ð $)¨A¢:‘KØ(ö4
Ø¨C¯O©O¸DÕ,AŠDò4
ˆ	ð ò 	!ˆDÜ˜$“ñ !Ø—‘Ô ÷!ð !ð	!ð Ð&˜IÐ&ˆð �AŠ:ØÙ�wÔØò 	yˆDÜ˜$“ñ yØ—?‘? 4Ô(Ø—I‘I”KÜ—K‘KÐ fÐhl×hpÑhpÐrwÔx÷yð yñ	yøôu &¤z×'@Ñ'@Ä'ÐJò #Ù Õ"Øð#ûð ×#Ñ#ò 	ÙÜœÐ)ò 	ÙÔÙð	ûð ò 	Ø‹Kð	ú÷	ñ 	üò"4
÷!ñ !ú÷ yð yúsm   »AG ÂG7 Â1H# ÃH1ÄH>Ä)H>Å IÅ>AIÇ%G4Ç3G4Ç7H ÈH ÈH È#H.È-H.È1H;ÉI	ÉI	c                 óÚ   — 	 ddl }|j                  | «      j                  d¬«      }|D �cg c]$  }t        j                  |«      sŒ|j                  ‘Œ& c}S # t        $ r g cY S w xY wc c}w )zHPIDs of living non-zombie descendants of host PID ``pid`` (best-effort).r   NTrí  )rÎ  rü  rý  rœ   rP  rÒ  r  )r  rÎ  rý  Úcs       r   Ú_live_descendantsz!ProcessRegistry._live_descendants  sb   € ð	ÛØ—~‘~ cÓ*×3Ñ3¸dÐ3ÓCˆHð  (ÖJ˜!¬?×+FÑ+FÀqÕ+I�—“ÒJÐJøô ò 	ØŠIð	üâJs   ‚%A «A(ÁA(ÁA%Á$A%ç      ð?rñ   c                 óÊ   — t        j                  «       | j                  z   }	 | j                  |«      }|rt        j                  «       |k\  r|S t        j                  d«       ŒB)uv  Host PIDs still alive once the kill signals have had time to land (#115490).

        Fail-closed: anything unverifiable counts as a survivor, so a kill
        that leaves a live tree can never write a killed receipt. Sandbox
        (env) sessions have no host-visible tree and are unverifiable by
        design â€” they return no survivors, preserving existing behavior.rñ  )rƒ   r„   Ú_KILL_SETTLE_SECONDSÚ_probe_survivorsrt  )r6  rð   ró  Ú	survivorss       r   Ú_post_kill_survivorsz$ProcessRegistry._post_kill_survivors  sV   € ô —>‘>Ó# d×&?Ñ&?Ñ?ˆØØ×-Ñ-¨gÓ6ˆIÙ¤§¡Ó 0°HÒ <Ø Ð Ü�J‰J�tÔð	 r   c                 ó  ‡— g Št        |dd «      }|�?	 |j                  «       d u }|r*‰j                  t        |dd «      xs |j                  «       t        |dd «      }|�7	 t        |j                  «       «      }|r‰j                  |j                  «       |j                  dk(  rŽ|j                  r‚| j                  |j                  |j                  «      r\|j                  ‰vr‰j                  |j                  «       ‰j                  ˆfd„| j                  |j                  «      D «       «       ‰D �cg c]  }|sŒ|‘Œ	 c}S # t        $ r d}Y �Œ0w xY w# t        $ r | j                  |j                  «      }Y �Œw xY wc c}w )Nr  Tr  r3  r  c              3   ó*   •K  — | ]
  }|‰vr|–— Œ y ­wrÚ   r   )r5   r  r  s     €r   r7   z3ProcessRegistry._probe_survivors.<locals>.<genexpr>;  s!   øè ø€ ò !-ØØ )Ñ+ô ñ!-ùs   ƒ)r°  Úpollrœ   rK   r  r?  ÚisaliverÂ  r  rÉ  r  Úextendr  )r6  rð   rÑ  Ú
root_aliveÚptyÚ	pty_aliver  r  s          @r   r  z ProcessRegistry._probe_survivors%  sa  ø€ Ø!ˆ	Ü�w 	¨4Ó0ˆØÐð"Ø!ŸY™Y›[¨DÐ0�
ñ Ø× Ñ ¤¨¨u°dÓ!;Ò!J¸w¿{¹{ÔKÜ�g˜v tÓ,ˆØˆ?ðAÜ  §¡£Ó/�	ñ Ø× Ñ  §¡Ô-Ø×Ñ Ò&¨7¯;ª;Ø×%Ñ% g§k¡k°7×3JÑ3JÔKØ—;‘; iÑ/Ø×$Ñ$ W§[¡[Ô1Ø× Ñ ó !-Ø#'×#9Ñ#9¸'¿+¹+Ó#Fô!-ô -ð  )Ö0˜ªC’Ò0Ð0øô- ò "Ø!“
ð"ûô ò AØ ×3Ñ3°G·K±KÓ@“	ðAüò 1s/   ”E Á"E Ä9FÅFÅEÅEÅ$FÆFc                 ó´   — ddl m} t        ddt        j                  «       j
                  d d › �| ||xs ||| |dd«      t        j                  «       dœ|¤ŽS )	Nr   )Úget_session_envÚproc_é   ÚHERMES_SESSION_IDr.   )r  rÈ   r  r  r  r
  r  r  r   )Úgateway.session_contextr  rñ   r“   r”   r•   rƒ   )rÈ   r  r  r  r
  r´  r  s          r   Ú_new_sessionzProcessRegistry._new_sessionE  sd   € å;äð -Ø”t—z‘z“|×'Ñ'¨¨Ð,Ð-Ð.¸ÈØ'Ò2¨7ÀÐQTÙ-Ð.AÀ2ÓFÜ—y‘y“{ñ	-ð ',ñ	-ð 	-r   r|   c                 ó|  — t        | dd«      }t        |«      rR	  |«       }t        |t        «      r&|j	                  d«      r|j                  d«      xs dS t        j                  «       S t        j                  «       S # t        $ r3}t        j                  d|«       Y d}~t        j                  «       S d}~ww xY w)zEReturn the writable sandbox temp dir for env-backed background tasks.Úget_temp_dirNr9   z*Could not resolve environment temp dir: %s)r°  ÚcallableÚ
isinstancer{   r3   rž  rœ   rB   r™   ÚtempfileÚ
gettempdir)r|   r  Útemp_dirr¡   s       r   Ú_env_temp_dirzProcessRegistry._env_temp_dirO  s¦   € ô ˜s N°DÓ9ˆÜ�LÔ!ðPÙ'›>�Ü˜h¬Ô,°×1DÑ1DÀSÔ1IØ#Ÿ?™?¨3Ó/Ò6°3Ð6ô ×"Ñ"Ó$Ð$Œx×"Ñ"Ó$Ð$øô ò PÜ—‘ÐIÈ3×OÐOÜ×"Ñ"Ó$Ð$ûðPús   š<A? Á?	B;ÂB6Â6B;Úsafe_commandr­   Úlabelc                 óÂ   — t        «       dd|› �g}t        xr
 t        «       }|r"t        «       rd|› d�|_        t        ||¬«      S |rt        j                  d|«       |S )a&  Login-shell argv for *safe_command* (parity with LocalEnvironment: rc files
        sourced, user tools on PATH), wrapped in a transient systemd scope when we are
        the supervised gateway (own cgroup: an OOM kills only the worker, not the
        gateway and its messaging control plane).z-liczset +m; r¯   z.scoperÑ   zz%s background executor not isolated in a systemd scope (systemd-run --user unavailable); worker shares the gateway cgroup.)r   rx   r«   r¢   r  r°   rB   r™   )r6  rð   r%  r­   r&  r_   Úin_supervised_gateways          r   Ú_scope_argvzProcessRegistry._scope_argv\  sq   € ô
 “˜v¨°,°Ð'@ÐAˆä )Ò NÔ.LÓ.NÐÙ Ô%FÔ%HØ%3°K°=ÀÐ#GˆGÔ Ü,¨T¸{ÔKÐKÙ ô �L‰LðVØW\ô^ð ˆr   Úenv_varsc                 óD   — t        t        j                  | «      }d|d<   |S )z�Sanitized child env; PYTHONUNBUFFERED so tqdm/datasets-style buffering
        doesn't hide progress from process(action="poll").r¥   ÚPYTHONUNBUFFERED)r	   r<   rw   )r*  r|   s     r   Ú
_spawn_envzProcessRegistry._spawn_envo  s$   € ô '¤r§z¡z°8Ó<ˆØ"%ˆÐÑØˆ
r   Úreader_namec                 óL  — ddl m} t        j                   |«       j                  ||g|¢­d|¬«      }||_        | j                  5  | j                  «        |j                  «        || j                  |j                  <   ddd«       | j                  «        y# 1 sw Y   ŒxY w)zLRegister before the reader can publish completion, even for an exited child.r   )Úcopy_contextT)rl  Úargsrn  rm  N)Úcontextvarsr0  rB  rE  r—   r2  r1  Ú_prune_if_neededrq  rS  r  Ú_write_checkpoint)r6  rð   Úreader_targetr.  Ú
extra_argsr0  Úreaders          r   Ú_track_startedzProcessRegistry._track_startedw  s�   € å,ô ×!Ñ!©«×);Ñ);À=ÐRYÐBgÐ\fÑBgØ)-°KôAˆà!'ˆÔØ�Z‰Zñ 	0Ø×!Ñ!Ô#ð �L‰LŒNØ(/ˆD�M‰M˜'Ÿ*™*Ñ%÷	0ð 	×ÑÕ ÷	0ð 	0ús   Á:BÂB#c                 ó  — t         rddlm} nddlm} | j	                  |||j
                  d«      }| j                  |«      }|j                  rt        |«      }|j                  dd«       |j                  dd«       |j                  ||j                  |d¬«      }|j                  |_        | j                  |j                  «      |_        ||_        | j!                  || j"                  d	|j
                  › �«       |S )
zÜPTY spawn for interactive CLI tools (Codex, Claude Code, REPLs).
        Raises ImportError when no PTY backend is installed and re-raises any spawn
        failure; ``spawn_local`` falls back to pipe mode in both cases.r   )Ú
PtyProcessÚPTYÚ	GIT_PAGERÚcatÚPAGER)r)   éx   )r
  r|   Ú
dimensionszproc-pty-reader-)r÷  Úwinptyr:  Ú
ptyprocessr)  r  r-  r  r�   Ú
setdefaultÚspawnr
  r  rÅ  r  r3  r8  Ú_pty_reader_loop)r6  rð   r%  r*  Ú_PtyProcessClsÚpty_argvÚpty_envÚpty_procs           r   Ú_spawn_local_ptyz ProcessRegistry._spawn_local_pty‡  sÚ   € õ Þ;å?Ø×#Ñ# G¨\¸7¿:¹:ÀuÓMˆØ—/‘/ (Ó+ˆØ×ÒÜ*¨7Ó3ˆGð 	×Ñ˜;¨Ô.Ø×Ñ˜7 EÔ*Ø!×'Ñ'¨°g·k±kÀwÐ[dÐ'ÓeˆØ—l‘lˆŒØ"&×"<Ñ"<¸W¿[¹[Ó"IˆÔØˆŒØ×Ñ˜G T×%:Ñ%:Ð>NÈwÏzÉzÈlÐ<[Ô\Øˆr   r.   FrÈ   r
  r  r  Úuse_ptyr  c                 óH  — ddl m}  ||«      }	| j                  ||||t        |xs t	        j
                  «       «      «      }
d}|r	 | j                  |
|	|«      S t        rd
t        «       ini }|r|
j                   › d�n|
j                   }| j#                  |
|	|d«      }| j%                  |«      }|
j                  rt'        |«      }t)        j*                  |fd|
j,                  |ddt(        j.                  t(        j0                  t(        j2                  ddœ	|¤Ž}||
_        |j6                  |
_        | j9                  |
j6                  «      |
_        	 | j=                  |
| j>                  d|
j                   › �«       |
S # t        $ r t        j                  d«       Y �ŒGt        $ rW}t        j                  d|«       |
j                  r*d}t        |
j                  «      st        d«      |‚d|
_        Y d	}~�Œ¡d	}~ww xY w# t        $ r | jA                  |
|«       ‚ w xY w)zûSpawn a background process locally (TERMINAL_ENV=local; other backends use
        spawn_via_env()). ``use_pty`` requests a pseudo-terminal via ptyprocess/pywinpty
        for interactive CLIs, falling back to a plain pipe when unavailable or failing.r   )Ú_rewrite_compound_backgroundFz3ptyprocess not installed, falling back to pipe modez0PTY spawn failed (%s), falling back to pipe modeTzZPTY scope could not be reaped; refusing pipe fallback to avoid duplicate command executionr.   Nrì  z-pipe-fallbackÚLocalr0   rŽ   )	r4  r
  r|   r1   rØ   Ústdoutrš   rÖ   Ústart_new_sessionúproc-reader-)!Útools.terminal_tool_sudorM  r  r   r<   ÚgetcwdrJ  ÚImportErrorrB   rC   rœ   r  rß   ÚRuntimeErrorr÷  r
   r  r)  r-  r�   r–   r=  r
  ÚPIPEÚSTDOUTrÝ   r  r  rÅ  r  r8  Ú_reader_loopÚ_reap_untracked)r6  rÈ   r
  r  r  r*  rK  r  Ú_rewrite_bgr%  rð   Úpty_scope_attemptedÚeÚ_popen_kwargsr­   Ú
spawn_argvrÃ   rÑ  s                     r   Úspawn_localzProcessRegistry.spawn_localž  s  € õ 	Yá" 7Ó+ˆØ×#Ñ# G¨W°mÀ[ÔRcÐdgÒdvÔkm×ktÑktÓkvÓRwÓxˆØ#ÐÙð.Ø×,Ñ,¨W°lÀHÓMÐMõ DO˜Ô*<Ó*>Ñ?ÐTVˆÙ7J˜Ÿ™˜ NÑ3ÐPW×PZÑPZˆØ×%Ñ% g¨|¸[È'ÓRˆ
Ø—O‘O HÓ-ˆ	Ø×ÒÜ,¨YÓ7ˆIô ×ÑØð5Ø! w§{¡{¸	ÈGØ¤Z§_¡_¼Z×=NÑ=NÔV`×VhÑVhØ"ñ5ð '4ñ5ˆð ˆŒØ—h‘hˆŒØ"&×"<Ñ"<¸W¿[¹[Ó"IˆÔð	Ø×Ñ ¨×):Ñ):¸lÈ7Ï:É:È,Ð<WÔXð ˆøôI ò VÜ—‘ÐT×UÜò 	.Ü—‘ÐQÐSTÔUØ×'Ò'Ø*.Ð'Ü-¨g×.BÑ.BÔCÜ*ðCóð  !ð!ð ,.�GÔ(ÿùð	.ûô> ò 	Ø× Ñ  ¨$Ô/Øð	ús+   ÁF Å*H ÆHÆ"HÆ*AG<Ç<HÈH!rÑ  c                 óp  — t        t        «      5  |j                  r<t        |j                  «       | j	                  |j
                  |j                  «       njt        sT	 t        t        dt        j                  «      }t        j                  t        j                  |j
                  «      |«       n|j#                  «        ddd«       t        t        «      5  |j%                  d¬«       ddd«       y# t        t        t         f$ r |j#                  «        Y ŒYw xY w# 1 sw Y   Œ^xY w# 1 sw Y   yxY w)zvPost-Popen setup failed: kill the orphaned subprocess (and any setsid
        descendants) so nothing leaks untracked.ÚSIGKILLNr'   ©r�   )r   rœ   r  rß   r  r  r  r÷  r°  rè  ré  r<   ÚkillpgÚgetpgidrå  ræ  rD   rç  Úwait)r6  rð   rÑ  Úkill_signals       r   rY  zProcessRegistry._reap_untrackedÖ  sé   € ô ”iÓ ñ 	Ø×#Ò#ô # 7×#7Ñ#7Ô8ð ×(Ñ(¨¯©°7×3JÑ3JÕKÝ ð Ü")¬&°)¼V¿^¹^Ó"L�KÜ—I‘IœbŸj™j¨¯©Ó2°KÕ@ð —	‘	”÷!	ô" ”iÓ ñ 	!Ø�I‰I˜aˆIÔ ÷	!ð 	!øô	 +¬O¼WÐEò  Ø—I‘I–Kð ú÷	ð 	ú÷"	!ð 	!ús=   �AD Á AC6Â2D ÃD,Ã6$DÄD ÄDÄD Ä D)Ä,D5T)r  r  r  Úoutput_so_farr   rg  r   c                ó(  — | j                  |||||«      }	||	_        |j                  |	_        | j                  |	j                  «      |	_        ||	_        |r|	j                  |«       | j                  |	| j                  d|	j                  › �«       |	S )ar  Take over a still-running foreground Popen as a tracked background session
        (yield-to-background: the user sent a message while the command was running).
        The caller has stopped its own drain thread; the registry's reader continues from
        the pipe's current position and ``output_so_far`` seeds the buffer so nothing
        already captured is lost.rQ  )
r  r  r  rÅ  r  r   r7  r8  rX  r  )
r6  rÑ  rÈ   r
  r  r  r  rg  r   rð   s
             r   Úadopt_localzProcessRegistry.adopt_localí  s‡   € ð ×#Ñ# G¨W°mÀ[ÐRUÓVˆØˆŒØ—h‘hˆŒØ"&×"<Ñ"<¸W¿[¹[Ó"IˆÔØ%7ˆÔ"ÙØ×!Ñ! -Ô0Ø×Ñ˜G T×%6Ñ%6¸,ÀwÇzÁzÀlÐ8SÔTØˆr   r�   c                 ó¼  ‡‡— | j                  ||||||d¬«      Š| j                  |«      Šˆˆfd„dD «       \  }}	}
t        j                  }d |‰«      › d ||«      › d ||«      › d ||
«      › d	 ||	«      › d
 ||	«      › �}	 |j	                  ||d¬«      }|j                  dd«      j                  «       }t        d„ t        t        j                  |j                  «       «      D «       d«      ‰_        ‰j                  €7‰j                  t        |j                  dd«      «      xs ddd«       |‰_        ‰j                   r'| j"                  5  | j%                  «        ddd«       ‰S | j'                  ‰| j(                  d‰j*                  › �|||	|
f«       ‰S # t        $ r'}‰j                  ddd«       d|› �‰_        Y d}~Œ�d}~ww xY w# 1 sw Y   ‰S xY w)a  Spawn a background process inside a non-local backend's sandbox.
        The command is wrapped to capture its in-sandbox PID and redirect output to a
        log file that later execute() calls poll. No live pipe or stdin, but it runs in
        the correct sandbox context.Úsandbox)r	  r  c              3   óF   •K  — | ]  }‰› d ‰j                   › d|› �–— Œ y­w)z/hermes_bg_ú.N©r  )r5   Úextrð   r#  s     €€r   r7   z0ProcessRegistry.spawn_via_env.<locals>.<genexpr>	  s'   øè ø€ Ò(vÐX[¨H¨:°[ÀÇÁÀÈAÈcÈUÔ)SÑ(vùs   ƒ!)Úlogr  Úexitz	mkdir -p z && ( nohup bash -lc z > z$ 2>&1; rc=$?; printf '%s\n' "$rc" > z ) & echo $! > z && cat F)r�   Úrewrite_compound_backgroundrú   r.   c              3   óT   K  — | ]   }|j                  «       sŒt        |«      –— Œ" y ­wrÚ   )rJ   r?   r4   s     r   r7   z0ProcessRegistry.spawn_via_env.<locals>.<genexpr>  s    è ø€ Òf¨BÐY[×YcÑYcÕYe¤ B§Ñfùs   ‚(˜(Nr˜   r/   Úfailed_startzFailed to start: zproc-poller-)r  r$  ÚshlexÚquoteÚexecutery   r>   rG   Úmapr{   rF   r  r<  r?   r÷   rœ   r  r1  r3  r8  Ú_env_poller_loopr  )r6  r|   rÈ   r
  r  r  r�   r  Úlog_pathÚpid_pathÚ	exit_pathÚqÚ
bg_commandr    rú   r\  rð   r#  s                   @@r   Úspawn_via_envzProcessRegistry.spawn_via_env   sé  ù€ ð ×#Ñ# G¨W°mÀ[ÐRUÐ_bÐnwÐ#ÓxˆØ×%Ñ% cÓ*ˆÜ(vÐ_uÔ(vÑ%ˆ�(˜IÜ�K‰Kˆà™˜(›�}ð % Ù ! '£
˜|¨3©q°«{¨mð </Ù/0°«|¨nð =Ù˜8›˜ X©a°«k¨]ð<ð 	ð
	<Ø—[‘[ °WÐZ_�[Ó`ˆFØ—Z‘Z ¨"Ó-×3Ñ3Ó5ˆFÜÑf´#´c·i±iÀ×ARÑARÓATÓ2UÔfÐhlÓmˆGŒKð �{‰{Ð"Ø×#Ñ#¤C¨¯
©
°<ÀÓ(DÓ$EÒ$KÈÈ^Ð]kÔlØ(.�Ô%ð �>Š>Ø—‘ñ (Ø×%Ñ%Ô'÷(ð
 ˆð ×ÑØ˜×.Ñ.°,¸w¿z¹z¸lÐ0KÈcÐS[Ð]eÐgpÐMqôsàˆøô ò 	<Ø×Ñ  N°NÔCØ&7¸°sÐ$;ˆG×!Ñ!ûð	<ú÷(ð
 ˆús%   ÂB5F ÅGÆ	GÆ'G	Ç	GÇGc                 óÌ  ‡ ‡‡‡‡‡— dŠ t        j                  d«      d¬«      Šdt        fˆˆ ˆfd„}	 ‰j                  }|�|j                  €/	 ‰ j                  ‰‰|d‰j                  j                  ˆfd	„«       y|j                  Št        t        ‰d
d«      dd«      Šˆˆˆfd„}	 ‰�t        s‰j                  «       nd}t        |t        «      r|dk\  sd}|�ddl}d}	 |�8	 j                  |gg g d«      \  }}	}	|s|j!                  «       �|dz  }|dk\  rnŒ; |«       }
|
€n|
r ||
«       d}ŒQ‰ j                  ‰‰|d‰j                  j                  ˆfd	„«       y# t        $ r d}Y Œ¬w xY w# t        t        f$ r Y ŒPw xY w# t        $ r }t"        j%                  d|«       Y d}~Œxd}~ww xY w# ‰ j                  ‰‰|d‰j                  j                  ˆfd	„«       w xY w)aS  Background thread: read stdout from a local Popen process.
        ``buffer.read1(4096)`` not ``TextIOWrapper.read(4096)``: on pipes the latter
        blocks until EOF, landing "live" output in one burst at exit. Orphaned-pipe
        guard: a backgrounded grandchild (``node server.js &``) inherits our pipe's write
        end so EOF never arrives while it lives, which would park this thread and never
        fire ``notify_on_complete``; on POSIX we ``select()`` and stop draining shortly
        after the direct child exits (mirrors ``environments/base.py::_wait_for_process``).
        Windows pipes lack select(), so the lazy ``_reconcile_local_exit`` is the net.

        Windows pipes don't support select(); the blocking path is kept there and the lazy reconcile in
        poll()/wait() remains the safety net. See #68915, #8340.
        Tr0   rŽ   r×   r�  c                 óT   •— ‰r‰j                  | «      } dŠ‰j                  ‰| «       y ©NF)rŽ  Ú_ingest_output)r�  Úfirst_chunkr6  rð   s    €€€r   Ú_append_chunkz3ProcessRegistry._reader_loop.<locals>._append_chunk=  s+   ø€ áØ×/Ñ/°Ó6�Ø#�Ø×Ñ ¨Õ/r   Nrü  c                  ó0   •— ‰ j                   j                  S rÚ   )r  r˜   ©rð   s   €r   ú<lambda>z.ProcessRegistry._reader_loop.<locals>.<lambda>v  s   ø€ ¨g¯o©o×.HÑ.H€ r   ÚbufferÚread1c                  ól   •— ‰€‰j                  d«      xs dS  ‰d«      } | r‰j                  | «      S dS )zLOne 4 KiB read: decoded text ('' for a partial multibyte tail), None at EOF.Né   )Úreadr›   )ÚrawÚdecoderÚraw_readrO  s    €€€r   Ú
_read_oncez0ProcessRegistry._reader_loop.<locals>._read_onceJ  s<   ø€ àÐ#Ø!Ÿ;™; tÓ,Ò4°Ð4Ù˜t“n�Ù.1�w—~‘~ cÓ*Ð;°tÐ;r   r   gš™™™™™É?r{  r$   zProcess stdout reader ended: %s)ÚcodecsÚgetincrementaldecoderr{   r  rO  Ú_finish_readerre  r°  r÷  Úfilenorœ   r   r?   Úselectr@   rD   r  rB   r™   )r6  rð   r…  rÑ  r‘  ÚfdÚ_selectÚidle_after_exitÚreadyr¦  r�  r\  r�  r„  r�  rO  s   ``          @@@@r   rX  zProcessRegistry._reader_loop&  sÿ  ý€ ð ˆð 8”&×.Ñ.¨wÓ7¸yÔIˆð	0¤÷ 	0ð3	JØ—?‘?ˆDØˆ|˜tŸ{™{Ð2Øð\ ×ÑØ˜ -°Ø—‘×$Ñ$Ó&HõJð[ —[‘[ˆFÜœw v¨x¸Ó>ÀÈÓNˆHö<ðØ(0Ð(<Å[�V—]‘]”_ÐVZ�ô ˜r¤3Ô'¨B°!ªGØ�Øˆ~Û(ØˆOØØ�>ðØ&-§n¡n°b°T¸2¸rÀ3Ó&G™˜˜q !ñ !ð  Ÿ9™9›;Ð2à+¨qÑ0˜OØ*¨aÒ/Ø!Ø Ù"›�Ø�=ØÙÙ! %Ô(Ø"#�ð+ ð2 ×ÑØ˜ -°Ø—‘×$Ñ$Ó&HõJøôA ò Ø’ðûô '¬Ð0ò Ùðûô$ ò 	?Ü�L‰LÐ:¸A×>Ñ>ûð	?ûð ×ÑØ˜ -°Ø—‘×$Ñ$Ó&HõJúsw   ´F Á=+F Â)E" Ã"F Ã&E3 Ã?5F Å"E0Å-F Å/E0Å0F Å3FÆF ÆFÆF Æ	F1ÆF,Æ'F4 Æ,F1Æ1F4 Æ4/G#c                 ód  — t        t        «      5  |j                  dd¬«      }|r ||«       ddd«       	  |«        | j                  | |«       «       y# 1 sw Y   Œ)xY w# t        $ rD} |«       €t        j	                  d||«       Y d}~yt        j	                  d||«       Y d}~Œld}~ww xY w)a¢  Reader-thread teardown: flush the decoder (a truncated multibyte tail becomes
        one U+FFFD instead of vanishing), reap the child (no zombies), record the exit.

        A process may close stdout long before it exits.  The reader owns a dedicated
        daemon thread, so it must keep waiting rather than publish a false completion
        and discard the only ``Popen`` handle that can reap the child.
        r   T)ÚfinalNz+%s wait failed; leaving process tracked: %sz/%s wait failed; recording known exit status: %s)r   rœ   r›   rB   rC   Ú_finish_exited)	r6  rð   r�  rK   r&  re  r  Útailr\  s	            r   r”  zProcessRegistry._finish_readerx  s£   € ô ”iÓ ñ 	Ø—>‘> #¨T�>Ó2ˆDÙÙ�t”÷	ð	XÙŒFð 	×Ñ˜G¡Y£[Õ1÷	ð 	ûô ò 	Xñ ‹{Ð"Ü—‘ÐLÈeÐUVÔWÜÜ�N‰NÐLÈeÐUV×WÑWûð	Xús(   �A·A" ÁAÁ"	B/Á+B*ÂB*Â*B/Úquoted_log_pathÚoffsetc                 ó&   — d|› d| › d| › d| › d| › d�S )a(  Shell command that reads only the log bytes written since ``offset``
        (``cat``-ing the whole file every poll re-sends all output over docker/SSH).

        Prints one header line ``"<size> <offset>"`` then the bytes in [offset, size).
        The size is read first and the tail cut at that same size, so a growing file
        never sends a byte twice; a file that shrank was rotated/truncated, so the
        offset drops to 0 and the reader starts over. The window end is pulled back
        to a UTF-8 character boundary (the backend decodes each ``execute()`` result
        on its own, so a straddling multibyte char would become U+FFFD and break watch
        patterns at the seam): up to 3 trailing continuation bytes are held for the
        next poll and the header reports the trimmed size.zO=z; S=$({ wc -c < z™; } 2>/dev/null | tr -dc '0-9'); S=${S:-0}; if [ "$S" -lt "$O" ]; then O=0; fi; N=0; P=$S; while [ "$P" -gt "$O" ] && [ "$N" -lt 3 ]; do B=$(tail -c +$P z¿ 2>/dev/null | head -c 1 | od -An -to1 | tr -dc '0-9'); case "$B" in 2[0-7][0-7]) P=$((P-1)); N=$((N+1));; *) break;; esac; done; if [ "$N" -gt 0 ] || [ "$P" -eq "$S" ]; then B=$(tail -c +$P zû 2>/dev/null | head -c 1 | od -An -to1 | tr -dc '0-9'); case "$B" in 3[0-3][0-7]) L=2;; 3[4-5][0-7]) L=3;; 3[6-7][0-7]) L=4;; *) L=1;; esac; if [ "$L" -gt $((N+1)) ]; then S=$((P-1)); fi; fi; echo "$S $O"; if [ "$S" -gt "$O" ]; then tail -c +$((O+1)) z# 2>/dev/null | head -c $((S-O)); fir   )rŸ  r   s     r   Ú_log_delta_commandz"ProcessRegistry._log_delta_command�  sK   € ð ��ð Ø-Ð.ð /ð  /Ð/ð 0ð  /Ð/ð 0!ð
 "1Ð 1Ð1Tð!Vð	
r   rz  r{  r|  c                 ó¸  — t         j                  }d}|j                  �s6t        j                  d«       	 |j                  | j                   ||«      |«      d¬«      j                  dd«      }|j                  d«      \  }	}
}	 |	j                  «       \  }}t        |«      }t        |«      }|�#||k  r|j                  5  d|_        ddd«       |}|r�|j                  5  |xj                  |z  c_        t        |j                  «      |j                  kD  r|j                  |j                   d |_        ddd«       | j!                  ||«       | j#                  ||«       |j                  d	 ||«      › d
�d¬«      }|j                  dd«      j%                  «       }|r¤|j'                  «       d   j%                  «       dk7  r€|j                  d ||«      › d�d¬«      j                  dd«      j%                  «       }	 t        |j'                  «       d   j%                  «       «      }||_        | j-                  ||«       y|j                  s�Œ5yy# t        $ r
 d}d}d}Y �Œ»w xY w# 1 sw Y   �Œ¦xY w# 1 sw Y   �ŒDxY w# t        t(        f$ r d}Y Œmw xY w# t.        $ r2 d\  |_        |_        d\  |_        |_        | j5                  |«       Y yw xY w)zBBackground thread: poll a sandbox log file for non-local backends.r   r8   r(   rb  rú   r.   rˆ  Nzkill -0 "$(cat z# 2>/dev/null)" 2>/dev/null; echo $?r'   r/   Ú0zcat ú 2>/dev/null)Tr/   )ÚlostÚbackend_lost)ru  rv  r  rƒ   rt  rw  r¢  ry   rH   r‹  r?   r@   r1  r÷   rþ   r  r©  r’  r>   rF   Ú
IndexErrorr  r�  rœ   r  r  rË  )r6  rð   r|   rz  r{  r|  r}  Úprev_output_bytesrŽ  Úheaderr¦  r…  Úsize_strÚ
offset_strÚnew_sizeÚused_offsetÚcheckÚcheck_outputÚexit_strr  s                       r   ry  z ProcessRegistry._env_poller_loop°  sÉ  € ä�K‰KˆàÐØ—.“.Ü�J‰J�qŒMð/à—k‘k $×"9Ñ"9¹!¸H»+ÐGXÓ"YØ*,ð "ó .ß.1©c°(¸BÓ.?ð à#&§=¡=°Ó#6Ñ �˜˜5ð	Ø+1¯<©<«>Ñ(�H˜jÜ" 8›}�HÜ"% j£/�Kð Ð'Ø"Ð%6Ò6à$Ÿ]™]ñ 7Ø46˜GÔ1÷7à(0Ð%ÙØ Ÿ™ñ fØ×-Ò-°Ñ6Õ-Ü˜w×4Ñ4Ó5¸×8PÑ8PÒPØ4;×4IÑ4IÈ7×KcÑKcÐJcÐJdÐ4e˜GÔ1÷fð ×.Ñ.¨w¸Ô>Ø×%Ñ% g¨uÔ5àŸ™Ø&¡q¨£{ mÐ3WÐXÐbcð $ó e�à$Ÿy™y¨°2Ó6×<Ñ<Ó>�Ù L×$;Ñ$;Ó$=¸bÑ$A×$GÑ$GÓ$IÈSÒ$Pà"Ÿ{™{¨T±!°I³,°¸|Ð+LÐVW˜{ÓX×\Ñ\Ð]eÐgiÓj×pÑpÓr�Hð'Ü$'¨×(;Ñ(;Ó(=¸bÑ(A×(GÑ(GÓ(IÓ$J˜	ð )2�GÔ%Ø×'Ñ'¨°Ô;ØðW —.–.øô "ò ð  $�HØ"&�KØ“Eðú÷7ñ 7ú÷fñ fûô '¬
Ð3ò 'Ø$&š	ð'ûô
 ò à4<Ñ1�” Ô 1ØH^ÑE�Ô)¨7Ô+EØ×&Ñ& wÔ/ÙðúsŒ   ¶AJ Â)I Â.J ÃI-Ã	J Ã!AI:Ä8C
J È*J È-J ÉI*É&J É)I*É*J É-I7É2J É:JÉ?J ÊJÊJ ÊJÊJ Ê8KËKc           	      óR  ‡ ‡‡
— ‰j                   Š
 t        j                  d«      d¬«      }d}t        sddlm}  |dd¬	«      }	 ‰
j                  «       r–	 ‰
j                  d
«      }|rq|�8t        |t        «      r(|j                  |«      \  }}|r	 ‰
j                  |«       t        |t        «      r|n|j!                  |«      }|r‰ j#                  ‰|«       ‰
j                  «       rŒ–|�3|j!                  |j%                  «       «      }	|	r‰ j#                  ‰|	«       ‰ j'                  ‰|ˆ ˆfd„d‰
j(                  ˆ
fd„«       y# t        $ r t        j                  dd¬«       Y ŒÇw xY w# t        $ r Y ŒŽw xY w# t        $ r }t        j                  d|«       Y d}~Œ¶d}~ww xY w)z2Background thread: read output from a PTY process.r0   rŽ   r×   Nr   )ÚPtyQueryResponderr)   r?  )ÚrowsÚcolsrŒ  zPTY query response write failedT)Úexc_infozPTY stdout reader ended: %sc                 ó(   •— ‰j                  ‰| «      S rÚ   )rƒ  )Útr6  rð   s    €€r   rˆ  z2ProcessRegistry._pty_reader_loop.<locals>.<lambda>  s   ø€ ¨×(;Ñ(;¸GÀQÓ(G€ r   r;  c                  ó8   •— t        ‰ d«      r‰ j                  S dS )NÚ
exitstatusr/   )Úhasattrrº  ©r  s   €r   rˆ  z2ProcessRegistry._pty_reader_loop.<locals>.<lambda>  s   ø€ ´¸¸\Ô0J˜cŸn™n€ ÐPR€ r   )r3  r’  r“  r÷  Útools.pty_query_responderr³  r  r�  r   Úbytesr  Úwriterœ   rB   r™   r{   r›   rƒ  Úflushr”  re  )r6  rð   r�  Ú	responderr³  r�  Úrepliesr4  r\  rž  r  s   ``        @r   rE  z ProcessRegistry._pty_reader_loopè  s�  ú€ à�l‰lˆð 8”&×.Ñ.¨wÓ7¸yÔIˆð
 ˆ	ÝÝCÙ)¨r¸Ô<ˆIð	;Ø—+‘+”-ðØŸH™H T›N�EÙà$Ð0´ZÀÄuÔ5MØ-6×->Ñ->¸uÓ-E™N˜E 7Ù&ð!&Ø$'§I¡I¨gÔ$6ô )3°5¼#Ô(>™uÀGÇNÁNÐSXÓDY˜ÙØ ×/Ñ/°¸Ô>ð# —+‘+•-ð, Ð à—>‘> )§/¡/Ó"3Ó4ˆDÙØ×#Ñ# G¨TÔ2Ø×ÑØ�WÔGÈØ�H‰HÓRõ	Tøô# (1ò !&Ü$*§L¡LØ(IØ15ð %1ö %&ð!&ûô !ò Ùðûäò 	;Ü�L‰LÐ6¸×:Ñ:ûð	;ús`   ÁE= Á;E. ÂE Â#7E. ÃE= Å E+Å(E. Å*E+Å+E. Å.	E:Å7E= Å9E:Å:E= Å=	F&ÆF!Æ!F&c                 ón   — |j                  |«       | j                  ||«       | j                  ||«       y)zIBuffer a freshly-read chunk, then scan watch patterns and stream it live.N)r7  r©  r’  )r6  rð   r4  s      r   rƒ  zProcessRegistry._ingest_output  s0   € à×Ñ˜dÔ#Ø×"Ñ" 7¨DÔ1Ø×Ñ˜' 4Õ(r   c                 óH   — |j                  |«       | j                  |«       y)zPMark a reader-observed exit (a raced kill keeps its own code/reason) and finish.N)r<  rË  )r6  rð   r  s      r   r�  zProcessRegistry._finish_exited  s   € à×Ñ˜IÔ&Ø×Ñ˜wÕ'r   c                 ó>  — | j                   5  |j                  | j                  v }|rIt        j                  «       |_        t        |«       | j                  j                  |j                  «       || j                  |j                  <   ddd«       | j                  |«       | j                  «        rÁ|j                  rµd|j                  |j                  |j                  |j                  xs |j                  |j                  dœ|j                  rd|j                  ini ¥| j!                  |«      ¥t#        |«      ¥d|j$                  i¥}t'        |«       | j(                  j+                  |«       |j,                  j/                  «        |S # 1 sw Y   �Œ
xY w)a  Move a session from running to finished.
        Idempotent: kill_process() and the reader thread can both call this; only
        the FIRST move enqueues the completion notification, so no duplicates.
        Returns True when this call is the one that persisted the session.NÚ
completion)r}  ré   r  r  r  rÈ   r  r  )r1  r  rS  rƒ   r  r   rÅ   rT  Ú_release_finished_handlesr4  r   r  r  r  rÈ   r  Ú_exit_fieldsr  r  rƒ  rX  r„  r0  rZ  )r6  rð   Úwas_runningr†  s       r   rË  z!ProcessRegistry._move_to_finished"  sd  € ð
 �Z‰Zñ 	1Ø!Ÿ*™*¨¯©Ð5ˆKÙÜ$(§I¡I£K�Ô!ô & gÔ.Ø—‘×!Ñ! '§*¡*Ô-Ø)0ˆD�N‰N˜7Ÿ:™:Ñ&÷	1ð$ 	×&Ñ& wÔ/Ø×ÑÔ Ù˜7×5Ò5à$Ø%Ÿj™jØ&×2Ñ2Ø"Ÿ?™?Ø!(×!6Ñ!6Ò!I¸'¿/¹/Ø"Ÿ?™?ñð >E×=QÒ=Q�N G×$8Ñ$8Ñ9ÐWYðð ×#Ñ# GÓ,ðô % WÓ-ðð ˜g×0Ñ0ñˆLô # <Ô0Ø×!Ñ!×%Ñ% lÔ3Ø×!Ñ!×%Ñ%Ô'ØÐ÷O	1ñ 	1ús   �A=FÆFc                 óJ   — | j                   | j                  | j                  dœS )N©r  r  r  rË  r‡  s    r   rÈ  zProcessRegistry._exit_fieldsP  s)   € ð !×*Ñ*Ø!(×!:Ñ!:Ø")×"<Ñ"<ñ
ð 	
r   c                 ó~  — |j                   }|�X|j                  |j                  |j                  fD ]2  }|€Œt	        t
        t        «      5  |j                  «        ddd«       Œ4 |j                  �3t	        t        «      5  |j                  j                  «        ddd«       yy# 1 sw Y   Œ~xY w# 1 sw Y   yxY w)uÍ  Close a finished session's OS handles (Popen pipes / PTY master).

        Best-effort and idempotent: the session may have no local Popen (env
        backends, detached recovery), or the handles may already be closed by
        the reader loop / kill path. Closing a Popen's stream objects does not
        kill anything â€” the child has already exited â€” it only releases the
        parent's pipe FDs, which is exactly the retained-resource leak.
        N)
r  rO  rš   rÖ   r   rD   r@   Úcloser3  rœ   )r6  rð   rÑ  Ústreams       r   rÇ  z)ProcessRegistry._release_finished_handlesX  s­   € ð �‰ˆØÐØŸ;™;¨¯©°T·Z±ZÐ@ò '�ØÑ%Ü!¤'¬:Ó6ñ 'ØŸ™œ÷'ð 'ð'ð �<‰<Ð#ô œ)Ó$ñ %Ø—‘×"Ñ"Ô$÷%ð %ð	 $÷'ð 'ú÷%ð %ús   ÁB'ÂB3Â'B0	Â3B<ré   c                 ó   — || j                   v S )zECheck if a completion notification was already consumed via wait/log.)r[  )r6  ré   s     r   Úis_completion_consumedz&ProcessRegistry.is_completion_consumedp  s   € à˜T×6Ñ6Ð6Ð6r   c                 ó¤  — | j                   5  |r8| j                  j                  |«      xs | j                  j                  |«      nd}ddd«       €yt	        t
        «      5  | j                  |«       ddd«       |j                   xr- |j                  xr |j                   xr |j                  dkD   S # 1 sw Y   ŒqxY w# 1 sw Y   ŒQxY w)aN  Whether a goal loop (``hermes_cli.goals`` wait barrier) should stay parked on
        this session: still running AND, with ``watch_patterns``, none matched yet (a
        long-lived watcher unblocks on its trigger, not on exit). Unknown/exited/
        already-fired sessions return False so a stale barrier can never wedge the loop.NFr   )r1  rS  ry   rT  r   rœ   rÌ  r  r"  r,  r*  ©r6  ré   rð   s      r   Úis_session_waitingz"ProcessRegistry.is_session_waitingt  sÈ   € ð
 �Z‰Zñ 	pÙ[e�t—}‘}×(Ñ(¨Ó4ÒV¸¿¹×8JÑ8JÈ:Ô8VÐkoˆG÷	pàˆ?ØÜ”iÓ ñ 	4Ø×*Ñ*¨7Ô3÷	4à—>‘>Ð!ò `Ø×"Ñ"Ò^¨7×+BÑ+BÐ'BÒ^Àw×GZÑGZÐ]^ÑG^ð'`ð 	`÷	pð 	pú÷	4ð 	4ús   �=B:Á$CÂ:CÃC)r�   Úpoll_intervalrÔ  c          	      óÐ  — |€| j                  «       }g g g dœ}| j                  5  | j                  | j                  fD ��cg c]P  }|j	                  «       D ];  }|j
                  r-|j                  j                  «       s|�|j                  |k(  r|‘Œ= ŒR }}}ddd«       r|dk  r|S |D �cg c]  }|j                  ‘Œ c}|d<   t        j                  d|t        |«      dj                  d„ |D «       «      «       t        j                  «       t!        t#        |«      d«      z   }t!        t#        |«      d	«      }		 dd
lm}
 d}|D �]  }	 |j                  j                  «       s¾|s |
«       rd}n²|t        j                  «       z
  }|dk  rn•t+        t(        «      5  | j-                  |«       | j/                  |«       ddd«       |j                  j                  «       rn@|j                  j1                  t3        ||	«      «       |j                  j                  «       sŒ¾||j                  j                  «       rdnd   j7                  |j                  «       �Œ |d   r6t        j9                  d|t        |d   «      dj                  |d   «      «       |S c c}}w # 1 sw Y   �ŒxY wc c}w # t(        $ r d„ }
Y �Œ‚w xY w# 1 sw Y   �Œ
xY w# t4        $ r d}Y Œ¿w xY w)u�  Bounded linger for ``notify_on_complete`` background processes at one-shot exit.
        A one-shot CLI run (``hermes -q/-Q/-z``) exits when its turn ends; a background
        process it spawned still holds a stdout pipe owned by the dying parent and dies of
        SIGPIPE seconds later (Bot Mode handoff replies were the visible casualty). Only
        ``notify_on_complete`` processes carry a completion contract â€” servers/daemons/
        watchers aren't the parent's to wait for. ``task_id=None`` waits on every tracked
        process; ``timeout=None`` reads ``terminal.oneshot_completion_wait_seconds`` (``<= 0``
        disables). Each pass re-reconciles child state so an orphaned-pipe exit can't wedge
        the linger. Returns ``{"waited", "completed", "timed_out"}`` id lists.

        Bot Mode handoff REPLIES are the visible casualty (#90879): a recipient invoked as ``hermes -p <bot>
        chat -Q --query-file ...`` dispatches its reply via ``message_agent`` / ``bot_relay`` exactly this
        way, then exits, and the reply process is destroyed ~3s later. The sender waits forever for a reply
        that was already killed.
        See #17327.
        N)ÚwaitedÚ	completedÚ	timed_outr   rÖ  zZOne-shot exit lingering (bounded %ss) for %d notify_on_complete background process(es): %sú, c              3   ó4   K  — | ]  }|j                   –— Œ y ­wrÚ   rn  )r5   râ   s     r   r7   z?ProcessRegistry.wait_for_pending_completions.<locals>.<genexpr>¦  s   è ø€ Ò,C°a¨Q¯T­TÑ,Cùs   ‚r+   rñ  )Úis_interruptedc                   ó   — yr‚  r   r   r   r   rˆ  z>ProcessRegistry.wait_for_pending_completions.<locals>.<lambda>¬  ó   � r   FTr×  rØ  u‰   One-shot exit linger timed out after %ss with %d background process(es) still running: %s â€” they may be killed when this process exits.)Ú _oneshot_completion_wait_secondsr1  rS  rT  rv  r   r0  Úis_setr  r  rB   rÿ  rþ   r�  rƒ   r„   rP   r>  Útools.interruptrÛ  rœ   r   Ú_reconcile_local_exitrÌ  re  rN   ÚKeyboardInterruptrK   rC   )r6  r  r�   rÔ  r    Ústorerâ   Úpendingró  r  Ú_is_interruptedÚinterruptedrð   r  s                 r   Úwait_for_pending_completionsz,ProcessRegistry.wait_for_pending_completions‚  sÇ  € ð& ˆ?Ø×;Ñ;Ó=ˆGØ"$°2ÀBÑGˆØ�Z‰Zñ 	ð
 !%§¡¨t¯~©~Ð>÷ØÈÏÉËòØCDØ×'Ò'°×0CÑ0C×0JÑ0JÔ0LÐRYÐRaÐef×enÑenÐryÒeyò ðØðˆGñ ÷		ñ ˜' Qš,ØˆMØ*1Ö2 Q˜AŸD›DÒ2ˆˆxÑÜ�‰ð)à”S˜“\ 4§9¡9Ñ,C¸7Ô,CÓ#Cô	Eô —>‘>Ó#¤c¬%°«.¸#Ó&>Ñ>ˆÜ”u˜]Ó+¨TÓ2ˆð	,ÝIð ˆØó 	jˆGð#Ø!×3Ñ3×:Ñ:Ô<Ù"¡oÔ&7Ø&*˜ØØ (¬4¯>©>Ó+;Ñ ;�IØ  A’~Øä!¤)Ó,ñ 
@ð ×2Ñ2°7Ô;Ø×6Ñ6°wÔ?÷
@ð ×0Ñ0×7Ñ7Ô9ØØ×-Ñ-×2Ñ2´3°yÀ(Ó3KÔLð+ "×3Ñ3×:Ñ:Õ<ð4  '×";Ñ";×"BÑ"BÔ"D‘;È+ÑV×]Ñ]Ð^e×^hÑ^hÖið9	jð: �+ÒÜ�N‰Nð!ð œ˜V KÑ0Ó1°4·9±9¸VÀKÑ=PÓ3Qô	Sð
 ˆùók÷		ñ 	üò 3øô ò 	,Ù+‹Oð	,ú÷
@ñ 
@ûô %ò #ð #’ð#úsb   ¥J%ÁAJÂJ%Â.J2Ä>J7 ÅAKÆ#K
ÇA"KÊJ%Ê%J/Ê7KËKË
K	ËKËK%Ë$K%c                  ó.   — t         j                  dd«      S )zTLinger (s) for one-shot exits with pending notify_on_complete processes; 0 disables.Úoneshot_completion_wait_secondsg     À‚@rá  r   r   r   rÞ  z0ProcessRegistry._oneshot_completion_wait_secondsÓ  s   € ô ×.Ñ.Ð/PÐRWÓXÐXr   ©Úskip_poll_observedrë  c                óF   — || j                   v xs |xr || j                  v S )u/  Skip a completion the CLI agent already has this turn â€” consumed via wait/log
        or observed inline via poll(). Gateway/tui watchers check only
        ``is_completion_consumed`` so a read-only poll never suppresses their turn.

        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).
        )r[  r\  )r6  ré   rë  s      r   Ú_drain_should_skipz"ProcessRegistry._drain_should_skipØ  s-   € ð ˜T×6Ñ6Ð6ÒtÐ;MÒ;sÐR\Ð`d×`sÑ`sÐRsÐtr   c                  ób   — 	 t        t        j                  ddd«      «      S # t        $ r Y yw xY w)uu   ``delegation.surface_child_process_notifications``; False on any config
        error â€” never crash the drain loop.Ú
delegationÚ#surface_child_process_notificationsF)r?  rP  rÛ  rœ   r   r   r   Ú$_surface_child_process_notificationsz4ProcessRegistry._surface_child_process_notificationsã  s5   € ð	Üœ×5Ñ5°lÐDiÐkpÓqÓrÐrøÜò 	Ùð	ús   ‚" ¢	.­.ÚevtÚis_async_delegationc                 ó
  — t        | j                  d«      xs d«      }|xs t        |xs | j                  d«      «      }|�|r	 t         || «      «      S |r|r||k(  S |xr | j                  d«       S # t        $ r Y yw xY w)zQRouting verdict for one drained event (see drain_notifications); False = requeue.r  r.   Úorigin_ui_session_idFÚrestored)r{   ry   r?  rœ   )rò  r  Ú
owns_eventró  Úevt_session_keyÚrequires_positive_proofs         r   Ú_owns_eventzProcessRegistry._owns_eventì  s›   € ô ˜cŸg™g mÓ4Ò:¸Ó;ˆØ"5Ò"q¼¸oÒ>pÐQT×QXÑQXÐYoÓQpÓ9qÐØÐ!Ñ&=ðÜ™J s›OÓ,Ð,ñ Ñ2Ø" kÑ1Ð1ð (Ò?¨C¯G©G°JÓ,?Ð@Ð@øô ò Ùðús   ÁA6 Á6	BÂBzlist[tuple[dict, str]]c                óD  — g }g }d}| j                   j                  «       �sM	 | j                   j                  «       }|j	                  d«      dk(  }| j                  ||||«      s|j                  |«       Œp|j	                  dd«      }	|j	                  d«      dk(  r| j                  |	|¬«      rŒªt        |j	                  d«      xs |j	                  d	«      xs d«      }
|sO|
j                  d
«      r>|€| j                  «       }|s*t        j                  d|j	                  dd«      |	|
«       �Œ,t        |«      x}r|j                  ||f«       | j                   j                  «       s�ŒM|D ]  }| j                   j                  |«       Œ |S # t        $ r Y Œ/w xY w)a   Pop all pending events and return ``(raw_event, formatted_text)`` pairs.
        Skips completions per ``_drain_should_skip`` (gateway/TUI pass
        ``skip_poll_observed=False``). Routing (``_owns_event``): async-delegation events
        always need ownership proof, ordinary events once they carry ``session_key`` or
        ``origin_ui_session_id``; ``owns_event(evt)`` (strongest; the TUI passes a
        compression-chain-aware check) consumes ONLY on True, ``session_key`` uses plain
        equality; non-owned events are re-queued for their owner. No filter consumes
        everything (legacy single-session) except restored delegation payloads (fail-closed).Nr}  Úasync_delegationré   r.   rÆ  rê  r  r  zsa-z‡Suppressed subagent-owned process notification (delegation.surface_child_process_notifications=false): type=%s session_id=%s task_id=%s)rX  ÚemptyÚ
get_nowaitrœ   ry   rú  rK   rí  r{   r3   rñ  rB   r™   r   r„  )r6  r  r÷  rë  ÚresultsÚrequeueÚsurface_childrò  ró  Ú_evt_sidÚ_evt_task_idr4  s               r   Údrain_notificationsz#ProcessRegistry.drain_notificationsü  s©  € ð -/ˆØ "ˆð (,ˆØ×'Ñ'×-Ñ-Õ/ðØ×+Ñ+×6Ñ6Ó8�ð #&§'¡'¨&£/Ð5GÑ"GÐØ×#Ñ# C¨°jÐBUÔVØ—‘˜sÔ#Øð —w‘w˜|¨RÓ0ˆHØ�w‰w�v‹ ,Ò.°4×3JÑ3JØÐ-?ð 4Kô 4Aàô ˜sŸw™w Ó7ÒS¸3¿7¹7À9Ó;MÒSÐQSÓTˆLÙ&¨<×+BÑ+BÀ5Ô+IØ Ð(Ø$(×$MÑ$MÓ$O�MÙ$Ü—L‘Lð;ð Ÿ™ ¨Ó5°xÀô	Oñ
 Ü2°3Ó7Ð7ˆtÐ7Ø—‘  T˜{Ô+ðC ×'Ñ'×-Ñ-Ö/ðD ò 	+ˆCØ×!Ñ!×%Ñ% cÕ*ð	+àˆøôC ò Ùðús   £F Æ	FÆFé   c                 ób  — t        |t        «      r|sy| j                  5  | j                  j	                  |«      xs | j
                  j	                  |«      }ddd«       €t        |«      j	                  |«      }| j                  |�|«      S | j                  |«      «      S # 1 sw Y   ŒMxY w)z£Session by full ID or unique prefix (``proc_4dae`` / bare ``4dae``, like git
        short hashes); ambiguous or too-short prefixes resolve to None, never a guess.N)	r   r{   r1  rS  ry   rT  r   rÌ  Ú_resolve_prefixrÒ  s      r   ry   zProcessRegistry.get5  s    € ô ˜*¤cÔ*±*ØØ�Z‰Zñ 	VØ—m‘m×'Ñ'¨
Ó3ÒU°t·~±~×7IÑ7IÈ*Ó7UˆG÷	Vàˆ?Ü,¨ZÓ8×<Ñ<¸ZÓHˆGØ×-Ñ-¸Ð9L¨gÓsÐsÐRV×RfÑRfÐgqÓRrÓsÐs÷		Vð 	Vús    9B%Â%B.c                 óR  — t        |t        «      r|j                  «       nd}|sy|j                  d«      sd|› �}t	        |«      t	        d«      z
  | j
                  k  ryt        |«      }| j                  5  |j                  | j                  | j                  fD ���ci c].  }|j                  «       D ]  \  }}|j                  |«      r||“Œ Œ0 c}}}«       ddd«       t	        |«      dk(  r"t        t        |j                  «       «      «      S dS c c}}}w # 1 sw Y   ŒBxY w)z}Resolve a unique session-ID prefix (a bare hex tail is normalized to
        ``proc_<tail>``); :meth:`get` tries exact first.r.   Nr  r{  )r   r{   r>   r3   rþ   Ú_MIN_PREFIX_CHARSr   r1  ÚupdaterS  rT  ÚitemsrG   Úiterrv  )r6  ré   ÚqueryÚmatchesrã  Úsidrâ   s          r   r  zProcessRegistry._resolve_prefix@  s  € ô '1°¼SÔ&A�
× Ñ Ô"ÀrˆÙØØ×Ñ Ô(Ø˜E˜7�OˆEÜˆu‹:œ˜G›Ñ$ t×'=Ñ'=Ò=ØÜ(¨Ó/ˆØ�Z‰Zñ 	Ø�N‰NØ%)§]¡]°D·N±NÐ$C÷ð Ø Ø#Ÿk™k›mòá�C˜¨s¯~©~¸eÔ/Dð �Q‘ðØôô ÷	ô
 03°7«|¸qÒ/@Œt”D˜Ÿ™Ó)Ó*Ó+ÐJÀdÐJùô	÷	ð 	ús   Á8(DÂ 3DÃ	DÄDÄD&c                 ó   — |�|j                   ryt        |dd«      }|€y	 |j                  «       }|€yt        |dd«      }|��t        sý	 ddl}|j                  «       }|j                  ||j                  «      }|j                  ||j                  |t        j                  z  «       	 t        t        t        t        «      5  |j                  «       }|r4|j!                  t#        |t$        «      r|n|j'                  dd¬«      «       ddd«       t        t        «      5  |j                  ||j                  |«       ddd«       |j.                  5  |j1                  |«       ddd«       t(        j3                  d	|j,                  |«       | j5                  |«       y# t        $ r Y yw xY w# 1 sw Y   Œ¦xY w# 1 sw Y   Œ}xY w# t        t        «      5  |j                  ||j                  |«       ddd«       w # 1 sw Y   w xY wxY w# t        $ r+}	t(        j+                  d|j,                  |	«       Y d}	~	Œõd}	~	ww xY w# 1 sw Y   ŒàxY w)
u•  Reconcile ``session.exited`` against the real child state.
        The reader flips ``exited`` only at EOF; when the direct child has exited but a
        descendant (e.g. a daemon from ``hermes update``) holds the pipe open, poll()
        would report "running" forever. If ``Popen.poll()`` has an exit code, drain
        readable bytes non-blocking and flip ``exited``. No-op for env/PTY, exited and
        detached sessions.

        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).
        Nr  rO  r   r0   rŽ   r×   z$Non-blocking drain failed for %s: %szxReconciled session %s: direct child exited with code %s but reader was still blocked (orphaned pipe). Flipped to exited.)r  r°  r  rœ   r÷  Úfcntlr•  ÚF_GETFLÚF_SETFLr<   Ú
O_NONBLOCKr   ÚBlockingIOErrorrD   r@   r�  r7  r   r{   r›   rB   r™   r  r1  r<  rÿ  rË  )
r6  rð   rÑ  ÚrcrO  r  r—  Úflagsr�  r\  s
             r   rá  z%ProcessRegistry._reconcile_local_exitR  sù  € ð ˆ?˜gŸnšnØÜ�w 	¨4Ó0ˆØˆ<Øð	Ø—‘“ˆBð ˆ:Øä˜˜x¨Ó.ˆØÑ¥kðTÛØ—]‘]“_�ØŸ™ B¨¯©Ó6�Ø—‘˜B §¡¨u´r·}±}Ñ/DÔEð>Ü!¤/´7¼JÓGñ @Ø &§¡£˜Ù Ø#×1Ñ1¼:ÀeÌSÔ;Q±%ÐW\×WcÑWcÐdkÐt}ÐWcÓW~Ô÷@ô
 "¤)Ó,ñ >ØŸ™ B¨¯©°uÔ=÷>ð �]‰]ñ 	$Ø×Ñ Ô#÷	$ä�‰ðDà�J‰J˜ô	ð 	×Ñ˜wÕ'øô9 ò 	Ùð	ú÷@ð @ú÷
>ð >ûœ¤)Ó,ñ >ØŸ™ B¨¯©°uÔ=÷>÷ >ñ >þäò TÜ—‘ÐCÀWÇZÁZÐQR×SÑSûðTú÷	$ð 	$ús—   ¡F  ÁAH Â*G ÃAF/Ä
G ÄH Ä!F;Ä?H ÅIÆ 	F,Æ+F,Æ/F8Æ4G Æ;GÇ H ÇH
ÇG>Ç5	H
Ç>HÈH
È
H È	IÈ!H<È<IÉIc                 óV   — | j                   | j                  | j                  rddœS ddœS )Nr  Úrunning)ré   rÈ   rí   )r  rÈ   r  r‡  s    r   Ú_status_headzProcessRegistry._status_head…  s*   € à%Ÿj™j°W·_±_Ð\c×\jÒ\jÐPXÑzÐzÐpyÑzÐzr   c                 ó   — | j                  |«      }|€t        |«      S | j                  |«       |j                  5  t	        |d«      }ddd«       i | j                  |«      ¥|j                  t        t        j                  «       |j                  z
  «      dœ¥}|j                  r;|j                  | j                  |«      «       | j                  j                  |«       |j                  r|j                  dd¬«       |S # 1 sw Y   Œ¼xY w)z9Check status and get new output for a background process.Néè  )r  Úuptime_secondsÚoutput_previewTz=Process recovered after restart -- output history unavailable)r  Únote)ry   rï   rá  r1  rø   r  r  r?   rƒ   r  r  r
  rÈ  r\  Úaddr  )r6  ré   rð   r  r    s        r   r  zProcessRegistry.poll‰  sð   € à—(‘(˜:Ó&ˆØˆ?Ü˜jÓ)Ð)Ø×"Ñ" 7Ô+Ø�]‰]ñ 	9Ü)¨'°4Ó8ˆN÷	9ðgØ×Ñ Ó(ðgØ18·±Ü!¤$§)¡)£+°×0BÑ0BÑ"BÓCÐWeògˆð �>Š>Ø�M‰M˜$×+Ñ+¨GÓ4Ô5ð ×Ñ×#Ñ# JÔ/Ø×ÒØ�M‰M 4Ð.mˆMÔnØˆ÷	9ð 	9ús   ¼DÄDrÿ   c                 ót  — ddl m} | j                  |«      }|€t        |«      S |j                  5   ||j
                  «      }ddd«       j                  «       }t        |«      }|€|dkD  r|| d }	t        |	«      xs |dk(  }
nH|xs d}||||z    }	t        |||z   «      j                  |«      d   }|dk(  xs t        |	«      xr ||k(  }
i | j                  |«      ¥dj                  |	«      |t        |	«      › d�dœ¥}|j                  r|
r| j                  j                  |«       |S # 1 sw Y   ŒëxY w)z;Read the full output log with optional pagination by lines.r   rô   Nr{  rˆ  z lines)rú   Útotal_linesÚshowing)rö   rõ   ry   rï   r1  r÷   rF   rþ   r?  ÚsliceÚindicesr  r�  r  r[  r   )r6  ré   r   rÿ   rõ   rð   Úfull_outputrV   r"  ÚselectedÚobserved_completion_outputrÕ   r    s                r   Úread_logzProcessRegistry.read_logž  sP  € å/à—(‘(˜:Ó&ˆØˆ?Ü˜jÓ)Ð)Ø�]‰]ñ 	<Ù$ W×%:Ñ%:Ó;ˆK÷	<à×&Ñ&Ó(ˆÜ˜%“jˆð ˆ>˜e ašiØ˜e˜V˜W�~ˆHÜ)-¨h«Ò)K¸;È!Ñ;KÑ&à’[˜qˆFØ˜V F¨U¡NÐ3ˆHÜ˜ ¨%¡Ó0×8Ñ8¸ÓEÀaÑHˆDØ)4¸Ñ)9Ò)e¼dÀ8»nÒ>dÐQUÐYdÑQdÐ&ðMØ×Ñ Ó(ðMØ48·I±I¸hÓ4GØ&´c¸(³m°_ÀFÐ3KòMˆð �>Š>Ñ8Ø×%Ñ%×)Ñ)¨*Ô5Øˆ÷-	<ð 	<ús   ±D.Ä.D7c                 óÜ  — ddl m}m} 	 t        t	        j
                  dd«      «      }|�|dk  r	dd|› d	�d
œS d}|xs |}|r||kD  r|}d|› d|› d�}| j                  |«      }|€t        |«      S t        j                  «       |z   }	t        j                  «       |	k  �r5| j                  |«      }|€t        |«      S | j                  |«       d}
|j                  r.| j                  j!                  |«       | j#                  |d«      }
nc |«       rd|j$                  t'        |d«      ddœ}
n@ |t)        j*                  «       j,                  «      rd|j$                  t'        |d«      dddœ}
|
�	|r||
d<   |
S |	t        j                  «       z
  }|dk  rn?|j.                  j1                  t3        d|«      ¬«       t        j                  «       |	k  r�Œ5d|j$                  t'        |d«      ddœ}
d|› d�}|j4                  r1|dt        t        j                  «       |j4                  z
  «      › d�z  }||j6                  rdnd z  }|r|› d!|› �n||
d<   |
S # t        t        f$ r d}Y �ŒAw xY w)"uQ  Block until the process exits, the timeout elapses, the user interrupts, or a
        mid-turn user message (steer/redirect â†’ ``request_yield``) releases the wait.
        ``timeout`` defaults to (and is clamped by) TERMINAL_TIMEOUT. Returns a dict
        with status exited|timeout|interrupted|not_found|error and an output snapshot.r   )Úconsume_yieldrÛ  ÚTERMINAL_TIMEOUTÚ180é´   Nrî   ztimeout must be positive (got ú)rì   zRequested wait of z%s was clamped to configured limit of râ   r  ræ  r  z+User sent a new message -- wait interrupted)rí   rÈ   rú   r  Tz�User sent a new message -- wait released; the process is still running and you will be notified on exit. Respond to the user now.)rí   rÈ   rú   Úprocess_runningr  Útimeout_noter  rb  r�   )rí   rÈ   rú   r0  zWait window of uA   s 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. )rà  r+  rÛ  r?   r<   r=   r@   rL   ry   rï   rƒ   r„   rÌ  rá  r  r[  r   Ú_exit_snapshotrÈ   rø   rB  Úcurrent_threadÚidentr0  re  rN   r  r   )r6  ré   r�   Ú_consume_yieldrå  Úmax_timeoutr1  Úeffective_timeoutrð   ró  r    r  Ú	base_notes                r   re  zProcessRegistry.wait½  s´  € ÷
 	gð	ÜœbŸi™iÐ(:¸EÓBÓCˆKð
 Ð 7¨a¢<Ø%Ð2PÐQXÐPYÐYZÐ0[Ñ\Ð\ØˆØ#Ò2 {ÐÙ�w Ò,Ø +ÐØ/°¨yÐ8]Ð^iÐ]jÐjkÐlˆLØ—(‘(˜:Ó&ˆØˆ?Ü˜jÓ)Ð)Ü—>‘>Ó#Ð&7Ñ7ˆÜ�n‰nÓ Ó)Ø×4Ñ4°WÓ=ˆGØˆÜ! *Ó-Ð-Ø×&Ñ& wÔ/ØˆFØ�~Š~Ø×)Ñ)×-Ñ-¨jÔ9Ø×,Ñ,¨W°hÓ?‘Ù Ô"à+¸¿¹ÔS_Ð`gÐimÓSnØIñK‘ñ  ¤	× 8Ñ 8Ó :× @Ñ @ÔAð ,¸¿¹ÔS_Ð`gÐimÓSnØ'+ðbñd�ð
 Ð!ÙØ-9�F˜>Ñ*Ø�Ø ¤4§>¡>Ó#3Ñ3ˆIØ˜AŠ~ØØ×%Ñ%×*Ñ*´3°s¸IÓ3FÐ*ÔGô= �n‰nÓ Ô)ð@  ¨G¯O©OÄ|ÐT[Ð]aÓGbà#ñ%ˆð
 Ð/Ð0Ð0qÐrð 	à×ÒØ˜9¤S¬¯©«°w×7IÑ7IÑ)IÓ%JÐ$KÈ2ÐNÑNˆIØà×)Ò)ñ rðMñ	Nˆ	ñ
 DP L >°°I°;Ñ!?ÐU^ˆˆ~ÑØˆøôy œIÐ&ò 	Ø‹Kð	ús   ŠI ÉI+É*I+rí   c                 ó`   — || j                   dœt        j                  | «      ¥t        | «      ¥S )zTResult dict for an exited session: exit metadata + the completion-sized output tail.)rí   rÈ   )rÈ   rP  rÈ  r  )rð   rí   s     r   r2  zProcessRegistry._exit_snapshot  s;   € ð ¨¯©ñTä×*Ñ*¨7Ó3ðTä7IÈ'Ó7RðTð 	Tr   zprocess.kill©r9  Úconsume_outputr9  r;  c                óÊ  — | j                  |«      }|€t        |«      S |j                  rg|j                  rt	        |j                  «       |j
                  5  | j                  |d«      }ddd«       |r| j                  j                  |«       S 	 | j                  |||«      }|�|S |j                  rt	        |j                  «       |j
                  5  |j                  }ddd«       rg n| j                  |«      }|rldj                  t        t        |«      «      }	t        j                  d|j                   t#        |«      |	«       ddt#        |«      › d|	› d�|j                   |d	d
œS |j
                  5  t%        |«      }
|r| j                  j                  |«       d	|_        d|_        d|_        ||_        ddd«       | j-                  |«      st/        |«       | j1                  «        d|j                   |j(                  |j*                  dœ
¥S # 1 sw Y   �Œ²xY w# 1 sw Y   �ŒFxY w# 1 sw Y   ŒvxY w# t2        $ r}dt        |«      dœcY d}~S d}~ww xY w)uŒ  Kill a background process and return its output snapshot.
        ``consume_output`` is true for explicit tool/RPC kills (the caller sees the
        output). Bulk cleanup passes false so it doesn't suppress an autonomous
        completion notification â€” except abandoned-turn reaping (``kill_started_since``),
        which passes true so a killed abandoned process can't revive stopped work.NÚalready_exitedrÙ  uP   Kill incomplete for %s: %d process(es) still alive (%s) â€” session kept runningrî   zKill incomplete: z process(es) still alive (z); session runningT)rí   rî   ré   r  r0  iñÿÿÿr;  )rí   ré   r  r  rì   )ry   rï   r  r  rß   r1  r2  r[  r   Ú_signal_killr  r�  rx  r{   rB   rC   r  rþ   r  r  r  r  rË  r   r4  rœ   )r6  ré   r9  r;  rð   r    ÚearlyÚsignal_race_exitedr  Úaliverú   r\  s               r   Úkill_processzProcessRegistry.kill_process  sQ  € ð —(‘(˜:Ó&ˆØˆ?Ü˜jÓ)Ð)Ø�>Š>ð ×#Ò#Ü" 7×#7Ñ#7Ô8Ø—‘ñ HØ×,Ñ,¨WÐ6FÓG�÷Hñ Ø×)Ñ)×-Ñ-¨jÔ9ØˆMð3	8Ø×%Ñ% g¨z¸>ÓJˆEØÐ Ø�ð ×#Ò#Ü" 7×#7Ñ#7Ô8ð —‘ñ 4Ø%,§^¡^Ð"÷4ñ 1™°d×6OÑ6OÐPWÓ6XˆIÙØŸ	™	¤#¤c¨9Ó"5Ó6�Ü—‘ØfØ—J‘J¤ I£°ô7ð &à+¬C°	«NÐ+;ð <Ø!˜7Ð"4ð6à")§*¡*¸9Ø'+ñ-ð -ð —‘ñ 4Ü+¨GÓ4�Ù!Ø×-Ñ-×1Ñ1°*Ô=Ø!%�”Ø$'�Ô!Ø,4�Ô)Ø-3�Ô*÷4ð ×)Ñ)¨'Ô2Ü% gÔ.Ø×"Ñ"Ô$à"°'·*±*ÐSZ×SlÑSlØ&-×&@Ñ&@ñLàDJðLð L÷mHñ Hú÷(4ñ 4ú÷&4ð 4ûô$ ò 	8Ø%´°A³Ñ7Õ7ûð	8úsi   ÁHÂI Â*-I ÃH(Ã$B
I Å/I Å;AH5Ç AI ÈH%È(H2È-I È5H>È:I É	I"É
IÉI"ÉI"c                 ó  — |j                   r	 |j                   j                  d¬«       y|j                  r1| j                  |j                  j                  |j                  «       y|j                  r8|j                  r,|j                  j                  d|j                  › d�d¬«       y|j                  rö|j                  dk(  rç|j                  rÛ| j                  |j                  |j                  «      sŽ|j                   rt#        |j                   «       |j$                  5  d|_        d|_        t+        |«      }ddd«       |r| j,                  j/                  |«       | j1                  |«       d	|j(                  d
œ¥S | j                  |j                  |j                  «       ydddœS # t        $ r= |j                  r.t	        j
                  |j                  t        j                  «       Y yw xY w# 1 sw Y   Œ½xY w)zØDeliver the kill via PTY, local Popen tree, sandbox exec or recovered host
        PID. Returns a final result dict when the kill cannot proceed (recycled/dead
        recovered PID, or no runtime handle), else None.T)Úforcezkill r¥  r'   rb  r  Nr=  )rí   r  rî   zkRecovered process cannot be killed after restart because its original runtime handle is no longer availablerì   )r3  rþ  rœ   r  r<   rç  rè  ré  r  r  r  r	  rw  r  r  rÉ  r  rß   r1  r  r  r  r[  r   rË  )r6  rð   ré   r;  rú   s        r   r>  zProcessRegistry._signal_kill]  sÃ  € ð �<Š<ð9Ø—‘×&Ñ&¨TÐ&Ô2ðN ðG �_Š_ð ×$Ñ$ W§_¡_×%8Ñ%8¸'×:QÑ:QÔRð@ ð? �_Š_ §¢Ø�O‰O×#Ñ# e¨G¯K©K¨=¸Ð$EÈqÐ#ÔQð< ð; ×Ò '×"3Ñ"3°vÒ"=À'Ç+Â+ð ×)Ñ)¨'¯+©+°w×7NÑ7NÔOØ×'Ò'Ü& w×';Ñ';Ô<Ø—]‘]ñ 9Ø%)�G”NØ(,�GÔ%Ü/°Ó8�F÷9ñ "Ø×-Ñ-×1Ñ1°*Ô=Ø×&Ñ& wÔ/Ø"2À×ARÑARÑ]ÐV\Ð]Ð]Ø×$Ñ$ W§[¡[°'×2IÑ2IÔJð ð	 "ðNñð øô; ò 9Ø—;’;Ü—G‘G˜GŸK™K¬¯©Ô8øðH ðM9ú÷&9ð 9ús   ŽF3 Ä&G<Æ3AG9Ç8G9Ç<HÚokc                 ót  — | j                  |«      }|€t        |«      S |j                  rdddœS 	 |j                  r ||j                  «       |S |j                  r|j                  j
                  sdddœS  ||j                  j
                  «       |S # t        $ r}dt        |«      dœcY d}~S d}~ww xY w)u    Run a stdin operation on a running session â€” ``pty_op(pty)`` under PTY mode,
        else ``pipe_op(stdin)`` on the Popen pipe â€” and return *ok* on success.Nr=  zProcess has already finishedrì   rî   z?Process stdin not available (non-local backend or stdin closed))ry   rï   r  r3  r  rÖ   rœ   r{   )r6  ré   Úpty_opÚpipe_oprE  rð   r\  s          r   Ú	_stdin_opzProcessRegistry._stdin_opŒ  s«   € ð —(‘(˜:Ó&ˆØˆ?Ü˜jÓ)Ð)Ø�>Š>Ø.Ð9WÑXÐXð		8Ø�|Š|Ù�w—|‘|Ô$ð
 ˆIð	 —_’_¨G¯O©O×,AÒ,AØ")Ð4uÑvÐvá˜Ÿ™×-Ñ-Ô.ØˆIøÜò 	8Ø%´°A³Ñ7Õ7ûð	8ús)   ±B Á&B Á8B Â	B7ÂB2Â,B7Â2B7Údatac           	      óX   ‡— ˆfd„}ˆfd„}| j                  |||dt        ‰«      dœ«      S )zASend raw data to a running process's stdin (no newline appended).c                 óú   •— t         rA| j                  t        ‰t        «      r‰j	                  d«      «       y t        ‰«      «       y | j                  t        ‰t
        «      r‰j                  dd«      n‰«       y )Nr0   Úsurrogateescape)r÷  r¿  r   r¾  r›   r{   Úencode)r  rJ  s    €r   Úvia_ptyz,ProcessRegistry.write_stdin.<locals>.via_pty¢  sV   ø€ åØ—	‘	´*¸TÄ5Ô2I˜$Ÿ+™+ gÓ.ÕYÌsÐSWËyÕYð —	‘	ÄZÐPTÔVYÔEZ˜$Ÿ+™+ gÐ/@ÔAÐ`dÕer   c                 óH   •— | j                  ‰«       | j                  «        y rÚ   )r¿  rÀ  )rÖ   rJ  s    €r   Úvia_pipez-ProcessRegistry.write_stdin.<locals>.via_pipe«  s   ø€ Ø�K‰K˜ÔØ�K‰K�Mr   rE  )rí   Úbytes_written)rI  rþ   )r6  ré   rJ  rO  rQ  s     `  r   Úwrite_stdinzProcessRegistry.write_stdinŸ  s1   ø€ ô	fô	ð �~‰~˜j¨'°8ÈÔ_bÐcgÓ_hÑ=iÓjÐjr   c                 ó†   — | j                  |«      }| j                  ||t        r|r|j                  rdz   «      S dz   «      S )uŒ  Send data + newline to stdin (like pressing Enter).
        On a Windows PTY, Enter is a carriage return: ConPTY treats ``\r`` as
        end-of-line and a bare ``\n`` through pywinpty is NOT a line terminator â€” the
        child's blocking line read (``readline()``, Go ``bufio.Scanner``) never returns
        and the process hangs looking healthy. ``\r\n`` gives it both; POSIX keeps ``\n``.z
rˆ  )ry   rS  r÷  r3  )r6  ré   rJ  rð   s       r   Úsubmit_stdinzProcessRegistry.submit_stdin°  sC   € ð —(‘(˜:Ó&ˆØ×Ñ 
¨D½kÉgÐZa×ZfÒZf°FÑ,qÓrÐrÐlpÑ,qÓrÐrr   c                 ó¼   — | j                   €dddœS 	 | j                  | j                  |«      |«       d|ddœS # t        $ r}dt        |«      dœcY d}~S d}~ww xY w)uâ   Ask the desktop GUI to close this process's read-only terminal tab. Does NOT
        kill the process â€” output keeps buffering and the tab can be reopened from the
        status stack. Errors when no UI close sink is wired.Nrî   z;close_terminal is only available in the Hermes desktop app.rì   rE  z’Closed 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  )rc  ry   rœ   r{   )r6  ré   r\  s      r   Úrequest_close_terminalz&ProcessRegistry.request_close_terminal¹  sm   € ð �=‰=Ð Ø%Ð0mÑnÐnð	8Ø�M‰M˜$Ÿ(™( :Ó.°
Ô;ð  jð-ñ.ð 	.øô ò 	8Ø%´°A³Ñ7Õ7ûð	8ús   “!: º	AÁAÁAÁAc                 óz   — | j                  |«      }|�|j                  rdnd}| j                  |d„ d„ d|dœ«      S )zGClose a running process's stdin / send EOF without killing the process.zEOF sentzstdin closedc                 ó"   — | j                  «       S rÚ   )Úsendeofr¼  s    r   rˆ  z-ProcessRegistry.close_stdin.<locals>.<lambda>Ð  s   €  C§K¡K£M€ r   c                 ó"   — | j                  «       S rÚ   )rÍ  )rÖ   s    r   rˆ  z-ProcessRegistry.close_stdin.<locals>.<lambda>Ð  s   € ÀÇÁÃ€ r   rE  )rí   r­  )ry   r3  rI  )r6  ré   rð   r¿  s       r   Úclose_stdinzProcessRegistry.close_stdinË  sG   € à—(‘(˜:Ó&ˆØ#Ð/°G·L²L‰jÀnˆØ�~‰~ØÑ1Ñ3NÐ[_ÐloÑPpórð 	rr   c                 ó,   — t        | j                  «      S )zMO(1) running count for status-bar polling; dict ``len()`` is atomic, no lock.)rþ   rS  rr  s    r   Úcount_runningzProcessRegistry.count_runningÒ  s   € ä�4—=‘=Ó!Ð!r   )Úinclude_retainedr`  c                ó>  — |r
t        «       ni }| j                  5  |j                  | j                  «       |j                  | j                  «       ddd«       |j                  «       D �cg c]  }| j                  |«      ‘Œ }}|s|r1|D �cg c]&  }|r|j                  |k(  s|r|j                  |k(  r|‘Œ( }}g }|D �]Ã  }| j                  |«       |j                  |j                  dd |j                  |j                  |j                  xs |j                  t        j                   dt        j"                  |j$                  «      «      t'        t        j                  «       |j$                  z
  «      |j(                  rdnd|j*                  r|j*                  dd nddœ	}|r%|r#|j                  |k7  r|j                  |k(  rd	|d
<   |j,                  r?|j.                  s3|j                  t1        |j,                  «      |j2                  dkD  ¬«       |j4                  rd	|d<   |j(                  r-|j6                  |d<   |j8                  |d<   |j:                  |d<   |j<                  rd	|d<   |j?                  |«       �ŒÆ |S # 1 sw Y   �Œ8xY wc c}w c c}w )uv  Running and recently-finished processes for ``task_id`` and/or ``session_key``;
        cross-task entries sharing the gateway session (a forgotten preview server
        blocking session reset) are flagged ``"session_scoped": true``.

        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).
        NéÈ   z%Y-%m-%dT%H:%M:%Sr  r  i8ÿÿÿr.   )	ré   rÈ   r
  r  r  r  r  rí   r  TÚsession_scopedr   )r"  Ú	watch_hitr   r  r  r  r  ) r   r1  r
  rT  rS  rv  rÌ  r  r  rá  r  rÈ   r
  r  r  rƒ   ÚstrftimeÚ	localtimer  r?   r  r÷   r"  r,  rA  r*  r   r  r  r  r  rK   )	r6  r  r  r`  Úsessionsrâ   Úall_sessionsr    Úentrys	            r   Úlist_sessionszProcessRegistry.list_sessionsÖ  sB  € ñ 0@Ô)Ô+ÀRˆØ�Z‰Zñ 	+Ø�O‰O˜DŸN™NÔ+Ø�O‰O˜DŸM™MÔ*÷	+ð DLÇ?Á?ÓCTÖU¸a˜×6Ñ6°qÕ9ÐUˆÐUÙ‘kà'öØÙ §	¡	¨WÒ 4¹+È!Ï-É-Ð[fÒJfò ðˆLð ð ˆØó 	!ˆAð ×&Ñ& qÔ)àŸd™dØŸ9™9 T c˜?Ø—u‘uØ—u‘uØ!"§¡Ò!=°A·I±IÜ"Ÿm™mÐ,?ÄÇÁÐPQ×P\ÑP\ÓA]Ó^Ü"%¤d§i¡i£k°A·L±LÑ&@Ó"AØ&'§h¢h™(°IØ<=¿OºO !§/¡/°$°%Ñ"8ÐQSñ
ˆEñ ™;¨1¯9©9¸Ò+?ÀAÇMÁMÐU`ÒD`Ø*.�Ð&Ñ'à×Ò¨×(9Ò(9Ø—‘¬D°×1AÑ1AÓ,BÈaÏmÉmÐ^_ÑN_�Ô`Ø×#Ò#Ø.2�Ð*Ñ+Ø�xŠxØ%&§[¡[��kÑ"Ø%&§[¡[��kÑ"Ø-.×-@Ñ-@�Ð)Ñ*Ø�zŠzØ$(��jÑ!Ø�M‰M˜%Ö ð=	!ð> ˆ÷S	+ñ 	+üò Vùòs   ›7JÁ,JÂ+JÊJc                 óX  ‡— | j                   5  t        | j                  j                  «       «      }ddd«       D ]  }| j	                  |«       Œ | j                   5  t        ˆfd„| j                  j                  «       D «       «      cddd«       S # 1 sw Y   ŒcxY w# 1 sw Y   yxY w)z™True if any still-running session satisfies *predicate*, after refreshing
        detached sessions so a finished-but-unreaped process reads as inactive.Nc              3   óL   •K  — | ]  }|j                    xr  ‰|«      –— Œ y ­wrÚ   )r  )r5   râ   Ú	predicates     €r   r7   z/ProcessRegistry._any_running.<locals>.<genexpr>	  s#   øè ø€ ÒU¸˜1Ÿ8™8�|Ò4©	°!«Ó4ÑUùs   ƒ!$)r1  rA  rS  rv  rÌ  rÞ   )r6  rm  rg  rð   s    `  r   Ú_any_runningzProcessRegistry._any_running	  s–   ø€ ð �Z‰Zñ 	4Ü˜DŸM™M×0Ñ0Ó2Ó3ˆH÷	4àò 	4ˆGØ×*Ñ*¨7Õ3ð	4à�Z‰Zñ 	VÜÓU¸d¿m¹m×>RÑ>RÓ>TÔUÓU÷	Vñ 	V÷		4ð 	4ú÷	Vð 	Vús   Ž$BÁ,B ÂBÂ B)c                 ó,   ‡— | j                  ˆfd„«      S )z5Whether any process for ``task_id`` is still running.c                 ó"   •— | j                   ‰k(  S rÚ   ©r  )râ   r  s    €r   rˆ  z6ProcessRegistry.has_active_processes.<locals>.<lambda>	  s   ø€ ¨1¯9©9¸Ñ+?€ r   ©rn  ©r6  r  s    `r   Úhas_active_processesz$ProcessRegistry.has_active_processes	  s   ø€ à× Ñ Ó!?Ó@Ð@r   c                 óÚ   — | j                   5  | j                  j                  «       D �cg c]!  }|j                  |k(  sŒ|j                  rŒ |‘Œ# c}cddd«       S c c}w # 1 sw Y   yxY w)z@Running processes whose RAW spawning owner is ``owner_task_id``.N)r1  rS  rv  r  r  ©r6  r  râ   s      r   Úrunning_owned_byz ProcessRegistry.running_owned_by	  sZ   € à�Z‰Zñ 	lØ#Ÿ}™}×3Ñ3Ó5Ök˜!¸¿¹ÈMÓ9YÐbc×bjÓbj’AÒk÷	lñ 	lùÚk÷	lð 	lús'   �A!ªA¿AÁAÁA!ÁA!Á!A*c                 ó6  — | j                   5  | j                  j                  «       D �cg c]O  }|j                  |k(  r>|j                  r2|j
                  | j                  vr|j
                  | j                  vr|‘ŒQ c}cddd«       S c c}w # 1 sw Y   yxY w)zØExited ``notify_on_complete`` processes of ``owner_task_id`` whose result nobody read (no wait/log/poll).
        A child's completion notice is suppressed in the parent, so an unread exit is otherwise lost silently.N)r1  rT  rv  r  r   r  r[  r\  rv  s      r   Úunread_completions_owned_byz+ProcessRegistry.unread_completions_owned_by#	  s‹   € ð �Z‰Zñ 	cØ#Ÿ~™~×4Ñ4Ó6ö c˜!Ø—‘¨-Ò7¸A×<PÒ<PØŸ™ D×$=Ñ$=Ñ=À!Ç$Á$Èd×NaÑNaÑBaò ò c÷	cñ 	cùòc÷	cð 	cús   �BªAB
Á>BÂ
BÂB)r  Ú
from_ownerÚto_ownerÚ
to_task_idÚto_session_keyr  c                óò   — | j                  |«      }| j                  5  |�|j                  s|j                  |k7  r
	 ddd«       y||_        ||_        ||_        ||_        |cddd«       S # 1 sw Y   yxY w)a¡  Move a RUNNING process from one owner to another under the registry lock. Ownership is the ``owner_task_id``
        field: completion notices are stamped from it at exit time and teardown kills by it, so flipping it here is the
        whole transfer. Returns the session, or None when it is unknown, already exited, or not owned by ``from_owner``
        (the caller must not report a transfer that did not happen).N)ry   r1  r  r  r  r  r  )r6  ré   rz  r{  r|  r}  r  rð   s           r   Útransfer_ownershipz"ProcessRegistry.transfer_ownership+	  sw   € ð —(‘(˜:Ó&ˆØ�Z‰Zñ 	Øˆ '§.¢.°G×4IÑ4IÈZÒ4WØ÷	ð 	ð %-ˆGÔ!Ø(ˆGŒOØ"0ˆGÔØ#'ˆGÔ Ø÷	÷ 	ò 	ús   žA-ÁA-Á-A6Úmax_active_agec                 ó\   ‡‡‡— t        j                   «       Š| j                  ˆˆˆfd„«      S )a  Active processes for a gateway session key. Processes older than
        ``max_active_age`` seconds are ignored as stale so a forgotten ``http.server``
        can't freeze session idle/daily reset forever; ``None`` keeps legacy behaviour
        (any running process blocks).c                 óV   •— | j                   ‰k(  xr ‰d u xs ‰| j                  z
  ‰k  S rÚ   )r  r  )râ   r€  rx  r  s    €€€r   rˆ  z8ProcessRegistry.has_active_for_session.<locals>.<lambda>B	  s4   ø€ �a—m‘m {Ñ2ò RØ 4Ð'ÒP¨C°!·,±,Ñ,>À.Ñ+Pð r   )rƒ   rn  )r6  r  r€  rx  s    ``@r   Úhas_active_for_sessionz&ProcessRegistry.has_active_for_session;	  s+   ú€ ô
 �i‰i‹kˆØ× Ñ õRóSð 	Sr   c                 ó&   — | j                  d„ «      S )u�   Whether ANY background process is running â€” scale-to-zero must not
        suspend a gateway with live background work or the process is lost.c                  ó   — y)NTr   )râ   s    r   rˆ  z0ProcessRegistry.has_any_active.<locals>.<lambda>H	  rÝ  r   rr  rr  s    r   Úhas_any_activezProcessRegistry.has_any_activeE	  s   € ð × Ñ ¡Ó0Ð0r   c                 ó    ‡— | j                   5  t        ˆfd„| j                  j                  «       D «       «      cddd«       S # 1 sw Y   yxY w)uÜ   Running IDs owned by ``task_id`` â€” a turn-boundary marker: on timeout
        only processes absent from the starting snapshot belong to the abandoned
        turn; older ones intentionally span turns and must survive.c              3   óp   •K  — | ]-  }|j                   ‰k(  sŒ|j                  rŒ |j                  –— Œ/ y ­wrÚ   )r  r  r  )r5   râ   r  s     €r   r7   z7ProcessRegistry.snapshot_running_ids.<locals>.<genexpr>O	  s*   øè ø€ Òk aÀQÇYÁYÐRYÓEYÐbc×bjÓbj˜QŸT�TÑkùs   ƒ6˜6¥6N)r1  Ú	frozensetrS  rv  rs  s    `r   Úsnapshot_running_idsz$ProcessRegistry.snapshot_running_idsJ	  s@   ø€ ð �Z‰Zñ 	lÜÓk¨4¯=©=×+?Ñ+?Ó+AÔkÓk÷	l÷ 	lò 	lús   Ž,AÁAc                óF   — | j                  |t        |xs d«      |d¬«      S )z¼Kill ``task_id`` processes created after ``baseline_ids``. Output is
        consumed so an abandoned turn can't enqueue a follow-up reviving work the
        timeout deliberately stopped.r   T©Úexclude_idsr9  r;  )Úkill_allr‰  )r6  r  Úbaseline_idsr9  s       r   Úkill_started_sincez"ProcessRegistry.kill_started_sinceQ	  s'   € ð �}‰}˜W´)¸LÒ<NÈBÓ2OÐX^Ðosˆ}ÓtÐtr   rŽ  rŒ  r�  c                ó$  ‡ ‡‡— ‰ j                   5  ‰ j                  j                  «       D �cg c]/  }|�|j                  |k(  r|j                  |vr|j
                  s|‘Œ1 }}ddd«       t        ˆˆ ˆfd„D «       «      S c c}w # 1 sw Y   Œ$xY w)zQKill all running processes, optionally filtered by task_id. Returns count killed.Nc              3   ó|   •K  — | ]3  }‰j                  |j                  ‰‰¬ «      j                  d«      dv –— Œ5 y­w)r:  rí   >   r;  r=  N)rB  r  ry   )r5   râ   r;  r6  r9  s     €€€r   r7   z+ProcessRegistry.kill_all.<locals>.<genexpr>`	  sE   øè ø€ ò ð ð ×Ñ˜aŸd™d¨6À.ÐÓQ×UÑUÐV^Ó_Ø+ô,ñùs   ƒ9<)r1  rS  rv  r  r  r  Úsum)r6  r  r�  r9  r;  râ   rò  s   `  ``  r   rŽ  zProcessRegistry.kill_allW	  s’   ú€ ð �Z‰Zñ 	àŸ=™=×/Ñ/Ó1öØØ�O q§y¡y°GÒ';ÀÇÁÈ[ÑAXÐab×aiÒaiò ðˆGð ÷	ô
 õ ð ôó ð 	ùò	÷	ð 	ús   �B­4BÁ!BÂBÂBc                 óì  ‡ — t        j                   «       }‰ j                  j                  «       D ��cg c]  \  }}||j                  z
  t        kD  sŒ|‘Œ  }}}t        ‰ j                  «      t        ‰ j                  «      z   t        |«      z
  t        k\  }|r@‰ j                  D �cg c]	  }||vsŒ|‘Œ c}x}r|j                  t        |ˆ fd„¬«      «       |D ]-  }‰ j                  ‰ j                  |   «       ‰ j                  |= Œ/ ‰ j                  j                  «       ‰ j                  j                  «       z  }‰ xj                  |z  c_        ‰ xj                  |z  c_        yc c}}w c c}w )zkDrop expired finished sessions, then the oldest survivor while over
        MAX_PROCESSES. Must hold _lock.c                 ó6   •— ‰j                   |    j                  S rÚ   )rT  r  )r  r6  s    €r   rˆ  z2ProcessRegistry._prune_if_needed.<locals>.<lambda>n	  s   ø€ ¸$¿.¹.ÈÑ:M×:XÑ:X€ r   )r±  N)rƒ   rT  r  r  ÚFINISHED_TTL_SECONDSrþ   rS  ÚMAX_PROCESSESrK   rN   rÇ  Úkeysr[  r\  )r6  rx  r  râ   ÚexpiredÚover_capr  Útrackeds   `       r   r3  z ProcessRegistry._prune_if_neededg	  s,  ø€ ô �i‰i‹kˆØ%)§^¡^×%9Ñ%9Ó%;×k™6˜3 ÀÀaÇlÁlÑ@RÔVjÓ?j’3ÐkˆÑkÜ�t—}‘}Ó%¬¨D¯N©NÓ(;Ñ;¼cÀ'»lÑJÌmÑ[ˆÙ°d·n±nÖ&[¨sÈÐSZÒHZ¢sÒ&[Ð[˜Ð[Ø�N‰Nœ3˜yÓ.XÔYÔZØò 	$ˆCð ×*Ñ*¨4¯>©>¸#Ñ+>Ô?Ø—‘˜sÑ#ð	$ð —-‘-×$Ñ$Ó&¨¯©×)<Ñ)<Ó)>Ñ>ˆØ×!Ò! WÑ,Õ!Ø×Ò˜wÑ&Öùó# lùâ&[s   ³E+ÁE+Â'	E1Â1E1rö  rÚ   )r   )Nr.   r.   NFr.   )Nr.   r.   r(   r.   )r.   N)rð   rñ   r   N)Nrb  )r.   )NN)fr³   r´   rµ   r¶   rŒ  rf  rñ   r?   rj  ri  rp  r>  rw  Ústaticmethodr{   rŽ  r’  r©  r   rv   r‚  rµ  r?  r£  r   rÂ  rÅ  ÚclassmethodrÉ  rÌ  rÒ  rÛ  rÞ  râ  r  r   r  r
  r  r  r  r   r$  r)  r-  r8  rJ  r_  r–   r=  rY  ri  r  rX  r”  r¢  ry  rE  rƒ  r�  rË  rÈ  rÇ  rÐ  rÓ  rç  rÞ  rí  rñ  rú  r  r	  ry   r  rá  r  r  r)  re  r2  rB  r>  rI  rS  rU  rX  r]  r_  rA  rj  rn  rt  rw  ry  r  rƒ  r†  r‰  rŠ  r�  rŽ  r3  r   r   r   rP  rP  X  sf
  „ ñQð5Ðò#BðL ^ð ¸cð Àcó ó+ó3ð0 ~ð 0¸Eð 0Àdó 0ð, ð  ð  ¨ò  ó ð ð! Nð !¸3ð !À4ó !ðH¨^ð HÀsð HÈtó HðT
¨Nð 
Èð 
ÐRUð 
ÐZ^ó 
ð ð	
 >ð 	
°dò 	
ó ð	
ð ð
 3ð 
°ð 
À$ò 
ó ð
ð( uð (°ó (ðT ð  ¨¡ð  °$ò  ó ð ð ð 8¨C¡=ð °X¸c±]ò ó ðð ðX H¨S¡Mð XÀ8ÈCÁ=ð XÐUYò Xó ðXð°¸.Ñ1Ið ÈhÐWeÑNfó ð  ð˜Tò ó ðð ðD˜sð D¨ò Dó ðDð ð˜Sð ¨Eð °eò ó ðð ðQ¨ò Qó ðQð ñWy cð Wy¸8ÀC¹=ð WyÐTXò Wyó ðWyðr ðK˜sð K t¨C¡yò Kó ðKð ÐðÐ,<ð ÀÀcÁó ð1Ð(8ð 1¸TÀ#¹Yó 1ð@ ð-ÐTbò -ó ð-ð ð
%˜3ð 
% 3ò 
%ó ð
%ð >ð Àð ÐSVð Ð_bð ÐgkÐloÑgpó ð& ð˜Tð  dò ó ðñ! nð !ÐRUð !Ðimó !ð ¨ð Àcð ÐUYð Ð^ló ð0 TVØKMñ6Øð6Ø!$ð6Ø69ð6ØMPð6àð6à(,ð6àEHð6àR`ó6ðp! ~ð !¸Z×=MÑ=Mð !ÐRVó !ð0 []Ø°BÈRØ#'òØ×$Ñ$ðØ25ðØ<DÀS¹MðØTWðàðà.1ðàGJðð !ðð -;óð( ^`Ø02ñ"Øð"Ø!$ð"Ø+.ð"Ø@Cð"ØWZð"àð"à*-ð"à7Eó"ðLPJ Nó PJód2ð. ð
¨Cð 
¸ð 
Àò 
ó ð
ð@6¨ð 6¸Sð 6ÈCð 6Ð[^ð 6Ðknó 6ðp-T¨ó -Tð^) nð )¸Cð )ÀDó )ð( nð (ÀDó (ð
,¨ð ,¸Dó ,ð\ ð
˜nð 
°ò 
ó ð
ð%°ó %ð07°ð 7¸ó 7ð`¨Sð `°Tó `ð (,ðOØHLÐehòOØ ‘}ðOØ9>À¹ðOØ]bðOà	óOðb ðY¨eò Yó ðYð QUò 	u¨Sð 	uÈð 	uÐY]ó 	uð ð°$ò ó ðð ðA˜ð A¨Cð AÐRVð AÐ[_ò Aó ðAð  15ð4ØTXò4Øð4ØMQð4à	!ó4ðn Ðð	t˜cð 	t h¨~Ñ&>ó 	tðK¨#ð K°(¸>Ñ2Jó Kó$1(ðf ð{˜nð {°ò {ó ð{ð˜sð  tó ñ* 3ð °°d±
ð È#ð ÐX\ó ñ>E˜sð E¨Sð E¸Dó EðN ðT ð T¸ð TÀò Tó ðTð 1?ÐW[òP8ØðP8Ø*-ðP8ØPTðP8à	óP8ðd- Nð -Àð -ÐUYð -Ð^fÐgkÑ^ló -ð^8 Cð 8¸dð 8Àtó 8ð&k cð k°ð k¸ó kñ"s sð s°#ð s¸tó sð.°ð .¸ó .ð$r cð r¨dó rð"˜só "ð6Ðfkò 6 Sð 6¸cð 6Ð_cð 6Ðptó 6ðtV¨ó VðA¨Cð A°Dó Aðl¨cð l°d¸>Ñ6Jó lð
c¸ð cÀÀnÑAUó cð =?ò¨Sð Àð ÐPSð Ðadð Ø+.ðØ69ðØCKÈNÑC[óñ S°#ð SÀxÐPUÁð SÐbfó Sð1 ó 1ð
l¨Cð l°I¸c±Nó lðu¨#ð uÈð uÐPSó uð (,ðÙIRËØ ¸òØ ‘}ðØ=Fðàðà26ðàCFóó 'r   rP  )ÚregistryÚ
tool_errorÚprocess_manageu  Poll, wait on, or kill background terminal processes (from terminal(background=true)). Completed results remain retrievable by session_id when resuming their owning conversation (up to 7 days, newest 64 results per profile; rolling output tail). poll: status + new output. log: full output, paged. wait: block until exit or timeout (partial output on timeout). write vs submit: submit appends Enter â€” use it to answer prompts; write sends raw bytes, no newline. close: EOF stdin. kill: terminate. handoff (subagents only): transfer a running process you started to your parent agent, which then receives its completion; `data` = one sentence on its purpose. Subagent-owned processes are otherwise killed when the subagent finishes and their notifications never reach the parent.ÚobjectÚstring)	rA  r  rp  re  rç  r¿  ÚsubmitrÍ  Úhandoff)r}  ÚenumztFrom terminal background output; any unique prefix works ('4dae' for proc_4dae56ca81f6). Required except for 'list'.)r}  Údescriptionz:Stdin text for write/submit; purpose sentence for handoff.ÚintegerzMax seconds for 'wait'.r{  )r}  r¦  Úminimumz$Log line offset (default: last 200).zMax log lines.)Úactionré   rJ  r�   r   rÿ   r©  )r}  Ú
propertiesÚrequired)rm  r¦  Ú
parametersr.   rq  rú   r˜   c                ó.   — ddl m}  ||| ||xs dd«      S )u  ``transform_terminal_output`` seam for background-process output â€” the poll/wait/log/kill
    results and the completion/heartbeat/watch notifications â€” so a plugin that rewrites terminal
    output sees the same command output whether it ran in the foreground or not (#70760).
    Same helper as the foreground path; callers redact AFTER it, never before, so a replacement
    the plugin returns is still masked. ``returncode`` is None while the process is running and
    ``env_type`` is not recorded per process, so it is passed empty.r   )Ú_apply_output_transform_hookr.   )Útools.terminal_tool_resultr®  )rú   rÈ   r˜   r  r®  s        r   Útransform_process_outputr°  »	  s!   € õ HÙ'¨°¸ÀWÂ]ÐPRÐTVÓWÐWr   r    c                 ó(  — t        | t        «      s| S ddlm}m} | j                  d«      xs d}t        | j                  d«      xs d«      }|sMt        j                  t        | j                  d«      xs d«      «      x}�t        t        |dd«      xs d«      }dD ]Q  }t        | j                  |«      x}t        «      sŒ%|sŒ(t        ||| j                  d«      |¬	«      } |||«      | |<   ŒS t        |t        «      r|r ||d
¬«      | d<   | S )aÄ  Transform, then redact secrets from background-process output before it reaches the
    model, session.db and CLI, mirroring the foreground ``terminal`` pipeline (hook first,
    redaction after) so the two surfaces can't diverge. Respects ``security.redact_secrets``;
    ``redact_terminal_output`` picks ``code_file`` from the recorded command.

    The command string itself is also redacted in case it carried an inline credential. See #43025.
    r   )Úredact_sensitive_textÚredact_terminal_outputrÈ   r.   r  ré   )rú   r  r  )rÈ   r˜   r  T)Ú	code_file)
r   rv   Úagent.redactr²  r³  ry   r{   Úprocess_registryr°  r°  )r    r²  r³  rÈ   r  rð   r±  Úvalues           r   rƒ  rƒ  Æ	  s  € ô �fœdÔ#ØˆßJà�j‰j˜Ó#Ò) r€Gä�&—*‘*˜YÓ'Ò-¨2Ó.€GÙÔ#3×#7Ñ#7¼¸F¿J¹JÀ|Ó<TÒ<ZÐXZÓ8[Ó#\Ð\˜ÐiÜ”g˜g y°"Ó5Ò;¸Ó<ˆØ+ò AˆÜ˜vŸz™z¨#›Ð.�e´Õ4ºÜ,¨U¸GÐPV×PZÑPZÐ[fÓPgÐqxÔyˆEÙ0°¸Ó@ˆF�3ŠKðAô �'œ3Ô¡GÙ1°'ÀTÔJˆˆyÑØ€Mr   c                 óè   — d}t        t        «      5  ddlm}  |d¬«      xs d}d d d «       dt        j                  | |xs d d¬«      D �cg c]  }t        |«      ‘Œ c}iS # 1 sw Y   Œ>xY wc c}w )Nr.   r   )Úget_current_session_key)r%  Ú	processesT)r  r  r`  )r   rœ   Útools.approval_contextr¹  r¶  rj  rƒ  )r  r  r¹  r—  s       r   Ú_list_processesr¼  à	  sŒ   € ð €KÜ	”)Ó	ñ @åBÙ-°bÔ9Ò?¸Rˆ÷@ð ä!×/Ñ/Ø¨Ò)<¸Ètð 0ó UöVàô 	˜qÕ!òVð Wð W÷	@ð @üòVs   ’A#ÁA/Á#A,c                 ó,   — t         j                  | «      S rÚ   )r¶  r  ©r  Úas     r   rˆ  rˆ  ñ	  s   € Ô,×1Ñ1°#Ó6€ r   Tc                 óp   — t         j                  | |j                  d«      |j                  dd«      ¬«      S )Nr   rÿ   rb  )r   rÿ   )r¶  r)  ry   r¾  s     r   rˆ  rˆ  ò	  s1   € Ô+×4Ñ4°SÀÇÁÀxÃÐXY×X]ÑX]Ð^eÐgjÓXkÐ4Ól€ r   c                 óN   — t         j                  | |j                  d«      ¬«      S )Nr�   rb  )r¶  re  ry   r¾  s     r   rˆ  rˆ  ó	  s    € Ô,×1Ñ1°#¸q¿u¹uÀYÓ?OÐ1ÓP€ r   c                 ó,   — t         j                  | «      S rÚ   )r¶  rB  r¾  s     r   rˆ  rˆ  ô	  s   € Ô,×9Ñ9¸#Ó>€ r   c           	      ó`   — t         j                  | t        |j                  dd«      «      «      S ©NrJ  r.   )r¶  rS  r{   ry   r¾  s     r   rˆ  rˆ  õ	  s%   € Ô-×9Ñ9¸#¼sÀ1Ç5Á5ÈÐQSÓCTÓ?UÓV€ r   c           	      ó`   — t         j                  | t        |j                  dd«      «      «      S rÄ  )r¶  rU  r{   ry   r¾  s     r   rˆ  rˆ  ö	  s%   € Ô.×;Ñ;¸CÄÀQÇUÁUÈ6ÐSUÓEVÓAWÓX€ r   c                 ó,   — t         j                  | «      S rÚ   )r¶  r]  r¾  s     r   rˆ  rˆ  ÷	  s   € Ô-×9Ñ9¸#Ó>€ r   )r  rp  re  rç  r¿  r£  rÍ  r1  c                 óX  — ddl m}m} ddlm} |5  |j                  t        |xs d«      «      }ddd«       r|j                  d«      nd}t        |dd«      }t        |«      r |«       nd}	|	€dd	iS t        t        |	d
d«      xs t        |	dd«      xs d«      }
|
sddiS t        |dd«      }|€	g x}|_	        t        |«      t        k\  rddt        › d�iS t        |j                  d«      xs d«      j                  «       }|sddiS t        j                  | t        |xs d«      |
 ||
«      t        t        |	dd«      xs d«      |¬«      }|€dd| › d�iS |j                  |j                   |j"                  |dœ«       d|j                   |j"                  ddœS # 1 sw Y   �ŒqxY w)a¡  Subagent-only: transfer a running background process to the parent agent so its completion is delivered THERE
    (child-owned process notices are suppressed and child teardown kills what it owns). Validated against the live spawn
    tree: the caller must be a registered child and must own the process; anything else is an error, never a silent
    no-op, so a PID mentioned in prose can't masquerade as a transfer.r   )Ú_active_subagentsÚ_active_subagents_lock)Ú_resolve_container_task_idr.   NÚagentÚ_delegate_parent_refrî   zThandoff is only available to a running subagent with a live parent; you are not one.Ú_current_task_idré   zNparent has no process owner id yet; retry after the parent's turn has started.Ú_handed_off_processeszhandoff cap reached (z2 per subagent); wait on or kill the rest yourself.rJ  zshandoff requires `data`: one sentence saying what the process is for and what the parent should do with its result.)rz  r{  r|  r}  r  zcannot hand off zf: not a running process you own (already exited? read its result with poll/log and report it instead).)ré   rÈ   r  Ú
handed_offzzYour parent now owns this process and will receive its completion; you will not. Mention the handoff in your final answer.)rí   ré   rÈ   r  )Útools.delegate_tool_registryrÈ  rÉ  Útools.terminal_toolrÊ  ry   r{   r°  r  rÎ  rþ   Ú_MAX_HANDOFFS_PER_CHILDr>   r¶  r  rK   r  rÈ   )ré   r1  r  rÈ  rÉ  rÊ  ÚrecordÚchildÚ
parent_refr  Úparent_ownerÚhandedr  rð   s                 r   Ú_handoff_processrØ  û	  sß  € ÷
 WÝ>Ø	ñ ;Ø"×&Ñ&¤s¨7ª=°bÓ'9Ó:ˆ÷;á#)ˆF�J‰J�wÔ¨t€EÜ˜Ð 6¸Ó=€JÜ% jÔ1‰ZŒ\°t€FØ€~ØÐoÐpÐpÜ”w˜vÐ'9¸2Ó>ÒiÄ'È&ÐR^Ð`bÓBcÒiÐgiÓj€LÙØÐiÐjÐjÜ�UÐ3°TÓ:€FØ€~Ø/1Ð1ˆ�Ô,Ü
ˆ6ƒ{Ô-Ò-ØÐ0Ô1HÐ0IÐI{Ð|Ð}Ð}Üˆt�x‰x˜ÓÒ% 2Ó&×,Ñ,Ó.€DÙØð  Oð  Pð  	PÜ×1Ñ1Øœs 7¢=¨bÓ1¸LÙ-¨lÓ;Üœ7 6¨<¸Ó<ÒBÀÓCÈ$ð 2ó P€Gð €ØÐ+¨J¨<ð 8Að Að Bð 	Bà
‡M�M §¡¸¿¹ÐQUÑVÔWØ"°'·*±*ÈÏÉð,ñ-ð -÷5;ñ ;ús   ‘FÆF)c           	      ó<  — | j                  dd«      }| j                  d«      �t        | j                  dd«      «      nd}|dk(  r/t        j                  t	        |j                  d«      «      d¬«      S |dk(  r>|st        d	«      S t        j                  t        || |j                  d«      «      d¬«      S |t        v rO|st        d
|› �«      S t        |   \  }} ||| «      }t        j                  |rt        |«      d¬«      S |d¬«      S t        d|› d�«      S )Nr©  r.   ré   rA  r  F)Úensure_asciir¤  z"session_id is required for handoffzsession_id is required for zUnknown process action: zA. Use: list, poll, log, wait, kill, write, submit, close, handoff)	ry   r{   ÚjsonÚdumpsr¼  rŸ  rØ  Ú_SESSION_ACTIONSrƒ  )r1  Úkwr©  ré   ÚhandlerÚredactr    s          r   Ú_handle_processrá  $
  s  € Ø�X‰X�h Ó#€Fà48·H±H¸\Ó4JÐ4V”�T—X‘X˜l¨BÓ/Ô0Ð\^€JØ�ÒÜ�z‰zœ/¨"¯&©&°Ó*;Ó<È5ÔQÐQØ�ÒÙÜÐBÓCÐCÜ�z‰zÔ*¨:°t¸R¿V¹VÀIÓ=NÓOÐ^cÔdÐdØÔ!Ñ!ÙÜÐ ;¸F¸8ÐDÓEÐEÜ*¨6Ñ2‰ˆ�Ù˜ TÓ*ˆÜ�z‰z¹FÔ0°Ó8Ð]bÔcÐcÈÐ]bÔcÐcÜÐ0°°Ð8yÐzÓ{Ð{r   rÝ  u   âš™ï¸�)rm  ÚtoolsetÚschemarß  Úemojii€Q rÚ   )|r¶   r’  Ú
contextlibr   rÛ  Úloggingr<   rF  ru  rè  rk   r–   r!  rB  rƒ   r“   Úpathlibr   Úsystemr÷  rx   Útools.environments.localr   r   r	   Úhermes_cli._subprocess_compatr
   Údataclassesr   r   Útypingr   r   r   r   r   r   rØ  r   Ú$tools.process_registry_notificationsr   Ú!tools.process_registry_checkpointr   Útools.process_registry_resultsr   r   Ú	getLoggerr³   rB   r   r   r    r@  rý   r–  r—  r¡  rŸ  r¢  rh  r�  ru  r»  rº  r¼  r*   r?  rÂ   rD  r�   r…   r†   rA   rQ   rO   r?   r\   r{   rb   re   rp   r�   rˆ   r¢   r«   r°   rº   rU  r²   r»   rÍ   rÎ   r½   rÆ   rÒ   rß   rè   rv   rï   rø   r  rñ   r¯  Ú_CHECKPOINT_FIELDSÚ__dataclass_fields__rv  rm  r%  Ú_CHECKPOINT_DEFAULTSrP  r¶  Útools.registryrž  rŸ  ÚPROCESS_SCHEMAr°  rƒ  r¼  rÝ  rØ  rÒ  rá  ÚregisterÚMAX_ACTIVE_PROCESS_AGE)Úfs   0r   ú<module>rù     s»  ðòó Ý Û Û Û 	Û Û Û Û Û Û Û Û Û Ý àˆh�o‰oÓ 9Ñ,€ð ˆH�O‰OÓ Ñ(€	ß ]Ñ ]Ý <ß (ß A× Aå -å LÝ Dß Xà	ˆ×	Ñ	˜8Ó	$€ñ "Ó#Ð&6Ñ6€Ø,Ð ðv˜$ó vð Ð ð Ð ØÐ Ø€ð  Ð ØÐ ð Ð ð Ð ØÐ ØÐ ð !Ð Ø Ð Ø "Ð ð ,0Ð ˜( 4™.Ó /Ø*˜IŸN™NÓ,Ð ØÐ ð $(Ð  Ø/Ð Ø#5Ð  Ø5Ð ð$M #ó $MðN	 ð 	°ð 	¸Cð 	ÀDÈÁIó 	ð, 4ó ,ð
 4ð ¨Dó ñ" 8¨D°°c°©NÑ#;ð "ÀtÈCÐQTÈHÁ~ó "ðJ7˜x¨™~ó 7ð+¨4ó +ð\¨ó ð(T¨$¨s©)ð TÀ#ð TÈ$ÈsÉ)ó Tð  Ð ô ,ô ð2 cð 2¸3ð 2À4ó 2ðRð ð$ð ô˜:ô ð¨$¨s°C¨x©.ð ¸Tó ð. "ò52Ø�#‰Yð52Ø(+ð52ØIMð52àð52ð ó52ðp #ð ¨$ó ðD ð ¨ó ðP˜3ð P 4ó Pð2Ð*ð 2¨sð 2°só 2ð`Ð 0ð `°Tó `ð ÷K1ð K1ó ðK1ð^ aÐ ð ˆu�kÐ#4°nÀeØ�)˜_¨mðñ 3Ð1Ô2ðð 5Gðð ð	ð .ð	ð 0Ið	ð K[ð	ð
 ñÐ ð ×0Ñ0×7Ñ7Ó9öà	Ø‡v�vÐ#Ñ#ð ‡F�F�1—6‘6Ð-Ò-‰R°1·9±9Ñ<òÐ ôd'Ð,ô d'ñP9 #Ó$Ð ÷ 0ð ð

	\ð ð !Úfñð
 !ð  Vñð
 !Ø[ñð
 "Ø8Øñð "ØEñð
 "Ø/Øññ-
ð8 �Jñ=ñ%2€ðj fhò X Sð X°cð XÀxÐPSÁ}ð XÐ_bð XÐloó Xð 4ð ¨Dó ð4W ó Wñ" 7¸Ð=ÙlÐnrÐsÙPÐRVÐWÙ>ÀÐEÙVÐX]Ð^ÙXÐZ_Ð`Ù>ÀÐFñÐ ð#- ð #-¨Dð #-¸8ÀC¹=ð #-ÈTó #-ðL Ð ò|ð& €× Ñ Ø	ØØØØ
õð Ñ ùòi?s   È/=L 