+ lHj+!aRt0tRt^RIt^RIt^RIt!RR4t]P !4t/t]^kRt Rt RRlt RR lt R R lt R R ltRRlt]P RRRll4tRRRlltR#)u&Human-wait accounting for :mod:`tools.approval` (per session). Tracks wall-clock time the agent spends verifiably blocked on a HUMAN prompt (CLI approval prompt, gateway approval round-trip). The concurrent tool batch deadline in agent/tool_executor.py excludes this time so a slow human answer never times a batch out — but ONLY this time. Measuring at the source (rather than residency in the authorization gate, which is arbitrary code) is what keeps a wedged pre_tool_call plugin or a dead approval client from growing the exclusion 1:1 with wall clock and defeating the deadline entirely. Keyed by session so one gateway session's pending approval cannot extend a different session's batch deadline; state is process-global like the rest of the approval state, bounded by _HUMAN_WAIT_MAX_SESSIONS. Nc6a]tRt^toRtV3RlRltRtVtR#)_HumanWaitStatec<V^8dQhRR/#)returnN)format __classdict__s">/home/ubuntu/.hermes/hermes-agent/tools/approval_human_wait.py __annotate___HumanWaitState.__annotate__!s%%$%c0^VnRVnRVnR#)N)pendingwindow_startedcompleted_seconds)selfs&r __init___HumanWaitState.__init__!s ,0!$r )rrrN)__name__ __module__ __qualname____firstlineno__ __slots__r__static_attributes____classdictcell__)r s@r rrsBI%%r rgN@c$V^8dQhR\/#)rrfloat)rs"r r r 0s j jE jr cv^RIHp^RIHp\ V\ VP 44\,4#)uMax seconds a single window may contribute: approvals.timeout + margin. Every legitimate human wait self-terminates at ``approvals.timeout`` (the CLI prompt join and the gateway poll loop both enforce it), so a window that overstays this ceiling is itself wedged and must not keep extending a batch deadline. Also the bound on the authorization gate's serialization-lock acquire in agent/tool_executor.py, so the two cannot drift. Never call while holding ``_human_wait_lock`` — it reads the config cache. ``_get_approval_timeout`` caps at ``agent.deadline.MAX_SAFE_TIMEOUT_S`` so the value is always safe for ``Lock.acquire(timeout=...)`` / ``Thread.join(timeout=...)``.approval_context)MAX_SAFE_TIMEOUT_S)toolsr$agent.deadliner%minr!_get_approval_timeoutHUMAN_WAIT_MARGIN_S)r$r%s r human_wait_ceilingr+0s-'1 !5)9)O)O)Q#RUh#h iir cHV^8dQhR\R\R\R\/#)rstartednowceilingrr )rs"r r r ?s(11U11151r c:\\RW, 4V4#)zSeconds an open window contributes: elapsed, floored at 0, capped. Shared by the close-time accrual and the open-window read so the two clamps stay identical by construction.r)r(max)r-r.r/s&&&r _clamped_window_secondsr2?s s3 & 00r c0V^8dQhR\R\/#)r session_keyr)strr)rs"r r r Fs3?r c\PV4pVfi\\4FBp\\4\8dM)\V,P ^8XgK;\VKD \ 4;p\V&V#)aReturn (creating if needed) the wait state for *session_key*. Caller must hold ``_human_wait_lock``. Evicts idle entries (no pending waiter) insertion-order-first until the table is under the cap so an army of short-lived session keys cannot grow it without bound. Entries with an open window are never evicted (that would corrupt live accounting), so the cap is best-effort under 256+ concurrently-pending sessions.)_human_wait_statesgetlistlen_HUMAN_WAIT_MAX_SESSIONSrr)r4statekeys& r _human_wait_stater>Fsq  " "; /E }*+C%&)AA!#&..!3&s+ , 3B2CC";/ Lr c>V^8dQhR\R,R\/#rr4Nrr5)rs"r r r Xs66cDj6S6r c:VeV#^RIHpVP4#)Nr#)r&r$get_current_session_key)r4r$s& r _resolve_keyrDXs &  3 3 55r c$V^8dQhR\/#)rlabelrA)rs"r r r _s 7 7c 7r caaa^RIHo\P!4pRTRT/oTTT3Rl# \dRu#i;i)zCallable that pings the agent's inactivity tracker (at most every ~10s) while a human wait is parked, so the gateway watchdog does not kill the agent while the user is still answering. No-op in minimal tool-only environments.)touch_activity_if_duecR#Nrrr r $activity_heartbeat..fstr last_touchstartc<S!SS4#rJr)rFr<rHsr rKrLis (6r )tools.environments.baserH Exceptiontime monotonic)rFr.r<rHsf @@r activity_heartbeatrT_sDA .. C 3 -E 66 s .??c2V^8dQhR\R,/#)rr4NrA)rs"r r r ms 0 03: 0r c #f"\V4p\P!4p\;_uu_4\ V4pVP ^8XdW#nV;P ^, unRRR4Rx\P!4p\4p\;_uu_4\PV4pVemV;P ^,unVP ^8XdCVP e.V;P\VP W$4, un RVnRRR4R# +'giL;i +'giR#;i \P!4p\4p\;_uu_4\PT4pTemT;P ^,unTP ^8XdCTP e.T;P\TP Y$4, un RTnRRR4i +'gii;i;i5i)aMark the enclosed block as time spent blocked on a human prompt. Wrap ONLY code that is genuinely parked waiting for a user's answer (the CLI approval prompt, the gateway approval poll loop). The concurrent tool batch deadline excludes this time; wrapping anything else re-creates the hang where arbitrary wedged code pushes the deadline out forever. Overlapping windows for the same session coalesce (pending counter), so two serialized approval prompts don't double-count the same wall clock. See #79719. N) rDrRrS_human_wait_lockr>rrr+r7r8rr2)r4r=r.r<r/s& r human_wait_windowrXls { #C .. C  !#& ==A #&    0 nn%&  &**3/E  " ==A%++7//3J5K_K_ad3nn/+/E(      nn%&  &**3/E  " ==A%++7//3J5K_K_ad3nn/+/E(   sf/H1V^8dQhR\R,R\/#r@)r5r!)rs"r r r sC$J%r cj\V4p\P!4p\4p\;_uu_4\ P V4pVf RRR4R#VPpVPeV\VPW#4, pVuuRRR4# +'giR#;i)ujReturn total human-wait seconds recorded for the session: completed windows plus the currently open one (if any). Monotonically non-decreasing for the life of the process — except when an idle session's entry is evicted under cap pressure, which can only shrink a consumer's baseline delta to zero (the safe direction: the deadline fires sooner). Deadline consumers snapshot a baseline at batch start and use the delta. Each window's contribution is clamped to :func:`human_wait_ceiling` (belt-and-braces against the wedged-window hang). Each window's contribution is clamped to :func:`human_wait_ceiling`: every legitimate human wait self-terminates at ``approvals.timeout`` (both the CLI prompt join and the gateway poll loop enforce it), so a window that overstays that bound is itself wedged and must not keep extending a batch deadline (belt-and-braces for #79719). Nr) rDrRrSr+rWr7r8rrr2)r4r=r.r/r<totals& r human_wait_secondsr\s { #C .. C "G  "&&s+ =  ''    + ,U-A-A3P PE    sB!8B!! B2 cbV^8dQh/^\9d\\\3,;R&#)rr7)__conditional_annotations__dictr5r)rs"r r r s*  N43Do-.3O r rJ)r^__doc__ contextlib threadingrRrLockrWr7r;r*r+r2r>rDrTcontextmanagerrXr\r )r^s@r res  %%>>#133 j1$6 7  0 0Fr