߲j7!DdZddlZddlZddlZddlmZmZmZejdZ dZ dZ dZ dZ d ed efd Zd$d Zd ZdZd$dZdddd ededededeededeededededeeedeededeeded ef dZd Zd!Zd ededeededeedef d"Zd$d#Zy)%abBackground-process launch path: ``terminal(background=true)`` spawns a tracked process via the process registry (Popen locally, ``env.execute`` in a sandbox), stamps gateway routing metadata for completion / watch-pattern notifications and returns the JSON result. Lazy ``tools.terminal_tool`` imports keep the origin's monkeypatch points authoritative. N)AnyListOptionalztools.terminal_toolubackground=true without notify_on_complete=true means this process runs SILENTLY — you will not be told when it exits. If this is a bounded task (test suite, build, CI poller, deploy, anything with a defined end), you almost certainly wanted notify_on_complete=true so the system pings you on exit. Re-launch with notify_on_complete=true, or call process(action='poll') / process(action='wait') yourself to learn the outcome. Only ignore this hint for genuine long-lived processes that never exit (servers, watchers, daemons).uUThis looks like a homebrewed CI poller built from `gh pr view --json statusCheckRollup` and/or `gh pr checks | jq`. That shape has burned us repeatedly in hermes-agent dev work (PRs #31329, #31448, #31695, #31709, #31745, #32264, #33131) — stdout buffering kills output capture, jq null-key edge cases silently exit the loop, conclusion-vs-status field confusion exits early with bogus all-green verdicts, TTY-only summary banners never appear when piped. Use the canonical snippets in the green-ci-policy skill instead: the exit-code-driven `gh pr checks $PR >/dev/null` (rc 0 = green, 8 = pending, else fail) for exit-on-first-fail behavior, or the column-2 awk-on-tabs poller (`awk -F"\t" "$2==\"pending\""`) for sharded matrices. Load skill_view(name='github/hermes-agent-dev', file_path='references/green-ci-policy.md') for the verbatim snippets. If you must roll a custom loop with rich structured output, write each tick to a known file (`tee -a $TMPDIR/ci.log`) and rely on `process(action='log')` to read THAT file — do not rely on background-process stdout capture for line-buffered shell loops.u\notify_on_complete / watch_patterns are not available in this session — it cannot receive an async completion after the turn ends (a one-shot runner such as `hermes -z`, a cron job, a Kanban worker, or a stateless HTTP endpoint). The process is running in the background; retrieve its result with process(action='poll') or process(action='wait').))watcher_chat_idHERMES_SESSION_CHAT_ID)watcher_user_idHERMES_SESSION_USER_ID)watcher_user_nameHERMES_SESSION_USER_NAME)watcher_thread_idHERMES_SESSION_THREAD_ID)watcher_message_idHERMES_SESSION_MESSAGE_ID)parent_session_idHERMES_SESSION_IDcommandreturncNd|vxsd|v}d|vxs d|vxsd|v}d|vxs|xr|S)Nz gh pr viewz gh pr checksz jq z| jqz$(jqstatusCheckRollup)rhas_ghhas_jqs C/home/ubuntu/.hermes/hermes-agent/tools/terminal_tool_background.py_looks_like_homebrew_ci_pollerrGsI W $ A'(AF w  H&G"3 Hv7HF ' ) @f.?@c n|dd}|sy||_tD]\}}t||||dy)zCopy the spawning chat's routing metadata onto the process session so completion / watch notifications reach the right chat/thread.HERMES_SESSION_PLATFORMN)watcher_platform_ROUTING_FIELDSsetattr) proc_sessionget_session_envplatformattrvars r_stamp_gateway_routingr'NsE8"=H $,L!$> c dOC$<=>rct||||xs||} |dk(r-|jdt|dr |jnd|d| S|jdd|i| S)N)rcwdtask_id owner_task_id session_keylocalenv)env_varsuse_ptyr)dict spawn_localhasattrr. spawn_via_env) process_registryr.env_typerr)effective_task_idr*r, effective_ptycommons r_spawnr:Ys~ 's4E ' <+<+WF7+++` 'U 3SWW}`X^` ` )  ) ) watch_patternsr=r#s r_apply_async_supportrGcse .!>11Q!|_=!>11(-K$%(?K$% KKFGSX rc d|_|jd||jdtddDcic]!\}}|j dt ||#c}}d|j d}t tjjdd d}t|r|nd}||j|ry|jj|ycc}}w) aGateway mode: register a fast watcher so completion triggers a new agent turn (CLI mode uses the completion_queue directly). Armed on the live gateway loop right away: the post-turn drain alone leaves a process that finishes while its launching turn is still running unwatched, and the chat mute for as long as that turn lasts (#112033). Before the gateway serves, or while it stops, the descriptor waits in ``pending_watchers`` for the startup / post-turn drain instead.) session_idcheck_intervalr,r$Nwatcher_T)r>rz gateway.run_gateway_runner_ref)watcher_intervalrDrr removeprefixgetattrrsysmodulesgetcallablearm_process_watcherpending_watchersappend)r5r"r,r%_watcher runner_refrunners r_register_completion_watcherr]us%&L!"oo; 11*#2. 0tQ   Z (',*E E 0 #9W9W G79NPTUJ%j1Z\tF f88A%%,,W5 0s&C)completion_output_charsheartbeat_secondsr.r6r7r*r,workdirr)r8r>rF approval_noter^pty_disabled_reasonr_c ddlm}ddlm}m}m}|||||} t ||||||||| }d|j|jddd}| r| |d <| r| |d <| s | s t|d <|r4t|r)|jd d }|r |d ztznt|d <t||| | \} } |t| | d\} }|r&tj!d|j|||d<| rkd|_d|d<| rt%| |_|j(r t+|||ddlm}|rd|d<t0|d<n|r|j3|||d<n|rd|d<| rt5| |_|j6|d<t9j:|dS#t<$r.}t9j:d d|d|ddcYd}~Sd}~wwxYw)zSpawn *command* as a tracked background process and return the JSON result. Never inline-polls ``is_interrupted()``: the spawn detaches and returns exit_code 0 immediately, so the stale-interrupt kill cannot occur here. rr5)_redact_terminal_error_text_resolve_command_cwd#_resolve_notification_flag_conflict)r` default_cwdr,r6)r.r6rr)r7r*r,r8zBackground process startedN)outputrJpid exit_codeerrorapprovalpty_notehintrz T)r>rF backgroundzbackground proc %s: %swatch_patterns_ignoredr>)is_delegated_child_contextF subagent_noter_zGheartbeat needs notify=true delivery, which this session cannot receiveheartbeat_ignoredrF) ensure_asciirLz$Failed to start background process: )rirkrl)tools.process_registryr5tools.terminal_toolrerfrgr:rDrj_SILENT_BACKGROUND_HINTrrT_HOMEBREW_CI_POLLER_HINTrGboolrBwarningr>intr^rr]agent.delegation_contextrr_SUBAGENT_NOTIFY_NOTE arm_heartbeatlistrFjsondumps Exception)rr.r6r7r*r,r`r)r8r>rFrar^rbr_r5rerfrg effective_cwdr"rEexisting conflict_noterres rspawn_background_processrs(8)SkHM4 #'}/k' ">\__*..QO &3K # &9K #!."9K  5g>"vr2HS[8f#47O#O(@  .B +'9>.K*N(K#$67cg) %   NN3\__m T4AK0 1 .2L +04K, -&7:;R7S 4,,,-=|[Y K)+49 01/D O,"4D3Q3QR^`q3r /0 /xK+ , *.~*>L ',8,G,GK( )zz+E:: zzr03WXYWZ1[\  sEThe user sent a message while this command was running, so it was moved to the background WITHOUT being killed and is still running. You will be notified when it exits (notify_on_complete). Read the user's message and respond to it now; use process(action='poll'|'wait'|'log', session_id=...) to check on this command.cH|dk7rydtdtffd }|S)aBuild the ``yield_handler`` a foreground ``env.execute`` calls when the tool thread is asked to yield (a user message arrived mid-command). Local backend only: the live Popen is adopted by the process registry as a notify-on-complete background session and the partial output is returned to the model right away. Other backends return None (no adoptable host process) and the foreground wait continues.r-N output_so_farrc ddlm}|j|xs|}t||tj d|j |j|d|j |jdS)Nrrd)rr)r*r+r,rz7foreground command yielded to background as %s (pid %s))ri returncodeyielded_session_idrj)rvr5 adopt_local_stamp_routing_if_gatewayrBrCrDrj) procrr5sessionrr)r7r,r*s r_handlerz-yield_to_background_handler.._handlers|;".. 's4E!6%6K'/) ""2G[I Mwzz[b[f[fg#4wzzbibmbm  r)strr1)rr6r)r7r*r,rs` ```` ryield_to_background_handlerrs/7  c  d    Orc~ddlm}m}|sd|_yt |||j rt |||yy)zNRoute the adopted session's completion like a normal notify_on_complete spawn.rr<FN)r@r=r#r>r'rr])r5rr,r=r#s rrrs;Q # %%*"7O4$%5w L r)rN)__doc__rloggingrRtypingrrr getLoggerrBrxryrAr rrzrr'r:rGr]r|rr~ _YIELDED_NOTErrrrrrs  &&   0 1   $] ACADA>=$68$% III),IADIOWX[}II'}I36IGKII/7tCy.AIS[[^R_I! I "# I  I IZXT")1#KN c]),4Mr