9j. UdZddlmZddlZddlZddlZddlZddlmZm Z m Z ddl m Z m Z ddl mZmZmZmZmZejeZdZdZd Zd Zd Zd Zd ZdZdZdZdZ dZ!dZ"dZ#dZ$ddddddZ%iddddddddddd dd!dd"dd#dd$d$d%d$d&d$d'd$d(d$d)d)d*d)d+d)d)d)d,d,d,d,d,d-Z&eGd.d/Z'dtd4Z(eGd5d6Z)dud8Z*iZ+d9e,d:<dvd<Z-dwd>Z.dxdAZ/dydBZ0dCdDdzdIZ1d{dLZ2d|dNZ3d}dOZ4ej5dPej6Z7d~dQZ8ddTZ9ddWZ:eddddXdd`Z;ddddZGdjdkZ?dlZ@dmZAedCddnddrZBgdsZCdS)unPersistent session goals — the Ralph loop for Hermes. A goal is a free-form user objective that stays active across turns. After each turn completes, a small judge call asks an auxiliary model "is this goal satisfied by the assistant's last response?". If not, Hermes feeds a continuation prompt back into the same session and keeps working until the goal is done, turn budget is exhausted, the user pauses/clears it, or the user sends a new message (which takes priority and pauses the goal loop). State is persisted in SessionDB's ``state_meta`` table keyed by ``goal:`` so ``/resume`` picks it up. Design notes / invariants: - The continuation prompt is just a normal user message appended to the session via ``run_conversation``. No system-prompt mutation, no toolset swap — prompt caching stays intact. - Judge failures are fail-OPEN: ``continue``. A broken judge must not wedge progress; the turn budget is the backstop. - When a real user message arrives mid-loop it preempts the continuation prompt and also pauses the goal loop for that turn (we still re-judge after, so if the user's message happens to complete the goal the judge will say ``done``). - This module has zero hard dependency on ``cli.HermesCLI`` or the gateway runner — both wire the same ``GoalManager`` in. Nothing in this module touches the agent's system prompt or toolset. ) annotationsN) dataclassfieldasdict)datetimetimezone)AnyDictListOptionalTupleg>@ia[Continuing toward your standing goal] Goal: {goal} Continue working toward this goal. Take the next concrete step. If you believe the goal is complete, state so explicitly and stop. If you are blocked and need input from the user, say so clearly and stop.a[Continuing toward your standing goal] Goal: {goal} Completion contract: {contract_block} Continue working toward the outcome above. Take the next concrete step. Stay within the stated boundaries and do not violate the constraints. Before claiming the goal is done, satisfy the Verification criterion and show the concrete evidence (command output, file contents, test result). If you hit the stated stop condition or are otherwise blocked and need user input, say so clearly and stop.a{[Continuing toward your standing goal] Goal: {goal} Additional criteria the user added mid-loop: {subgoals_block} Continue working toward the goal AND all additional criteria. Take the next concrete step. If you believe the goal and every additional criterion are complete, state so explicitly and stop. If you are blocked and need input from the user, say so clearly and stop.uYou are a strict judge evaluating whether an autonomous agent has achieved a user's stated goal. You receive the goal text, the agent's most recent response, and — when present — a list of background processes the agent has running. Decide one of three verdicts. DONE — the goal is fully satisfied: - The response explicitly confirms the goal was completed, OR - The response clearly shows the final deliverable was produced, OR - The response explains the goal is unachievable / blocked / needs user input (treat this as DONE with reason describing the block). WAIT — the goal is NOT done, but the next step is to wait for async work to finish rather than act again. Choose this ONLY when the agent's progress is genuinely gated on something running on its own: - A background process listed below is still running AND the response shows the agent is waiting on its result (e.g. a CI poller, build, test run, deploy). If the process has a session id, return it in ``wait_on_session`` — that releases when the process exits OR its watch_patterns trigger fires (use this for a long-lived watcher that signals mid-run and may never exit). Otherwise return its pid in ``wait_on_pid`` (releases on exit only). - The agent says it is rate-limited / backing off / must wait a fixed period — return seconds in ``wait_for_seconds``. Picking WAIT parks the loop without burning a turn; it resumes automatically when the pid exits or the time elapses. Do NOT pick WAIT just because work remains — only when re-poking now would be pure busy-work because the agent can't progress until the async thing finishes. CONTINUE — not done, and there is a concrete next step the agent can take right now. This is the default when in doubt. Reply ONLY with a single JSON object on one line. Shapes: {"verdict": "done", "reason": ""} {"verdict": "continue", "reason": ""} {"verdict": "wait", "wait_on_session": "", "reason": ""} {"verdict": "wait", "wait_on_pid": , "reason": ""} {"verdict": "wait", "wait_for_seconds": , "reason": ""} The legacy shape {"done": , "reason": "..."} is still accepted (true=done, false=continue).znBackground processes the agent currently has running (it may be waiting on one of these): {background_lines} uGoal: {goal} Agent's most recent response: {response} {background_block}Current time: {current_time} Is the goal satisfied — done, continue, or wait?uGoal: {goal} Additional criteria the user added mid-loop (all must also be satisfied for the goal to be DONE): {subgoals_block} Agent's most recent response: {response} {background_block}Current time: {current_time} Decision: For each numbered criterion above, find concrete evidence in the agent's response that the criterion is satisfied. Do not accept generic phrases like 'all requirements met' or 'implying it was done' — require specific evidence (a file contents excerpt, an output line, a command result). If ANY criterion lacks specific evidence in the response, the goal is NOT done — return CONTINUE (or WAIT if blocked on a listed background process). Is the goal AND every additional criterion satisfied?u=Goal: {goal} Completion contract (the authoritative definition of done): {contract_block} Agent's most recent response: {response} {background_block}Current time: {current_time} Decision rules: - The goal is DONE only when the Verification criterion is satisfied AND the response shows concrete evidence of it (a command result, file contents excerpt, test/benchmark output) — not a claim like 'done' or 'all tests pass' without evidence. - If any stated Constraint was violated, the goal is NOT done — CONTINUE. - If the response shows the agent is waiting on a listed background process to satisfy the Verification criterion (e.g. CI is the verification and it's still running), return WAIT on that process instead of re-poking — re-poking now would be pure busy-work. - If the response explains the work is blocked / unachievable / needs user input (e.g. the stated Stop condition was hit), treat it as DONE with the reason describing the block. - Otherwise the goal is NOT done — CONTINUE. Is the goal satisfied per its completion contract — done, continue, or wait?aYou turn a user's plain-language objective into a structured completion contract for an autonomous coding agent. The contract has five fields: - outcome: the single end state that must be true when done - verification: the specific test / command / artifact that PROVES the outcome (must be concrete and checkable) - constraints: what must NOT change or regress - boundaries: which files, dirs, tools, or systems are in scope - stop_when: the condition under which the agent should stop and ask for human input instead of pushing on Infer sensible, specific values from the objective and any project context implied by it. Prefer concrete verification (a named test command, a build, a benchmark) over vague phrases. Keep each field to one or two sentences. If a field genuinely cannot be inferred, use an empty string for it. Reply ONLY with a single JSON object on one line: {"outcome": "...", "verification": "...", "constraints": "...", "boundaries": "...", "stop_when": "..."})outcome verification constraints boundaries stop_whenOutcome Verification Constraints BoundarieszStop when blockedrgoaldonez done whenrverifyz verified byevidenceproofr constraintpreservezmust notz do not changerboundaryscoper)allowedfilesz stop whenrblockedzstop if blockedz give up whenceZdZUdZdZded<dZded<dZded<dZded<dZ ded<dd Z dd Z e ddZ ddZdS) GoalContractuOptional structured completion contract for a goal. Each field is free-form prose the user (or :func:`draft_contract`) supplies. Empty fields are omitted everywhere — a goal with no contract behaves exactly like the original free-form goal. The contract is woven into both the continuation prompt (so the agent targets the verification surface and respects constraints) and the judge prompt (so "done" is decided against evidence, not vibes). strrrrrrreturnboolcFtfdtD S)Nc3\K|]&}t|V'dSN)getattrstrip.0fselfs 6/home/rurouni/.hermes/hermes-agent/hermes_cli/goals.py z(GoalContract.is_empty..8s9JJAwtQ''--//JJJJJJ)any_CONTRACT_FIELDSr4s`r5is_emptyzGoalContract.is_empty7s*JJJJ9IJJJJJJJr7Dict[str, str]c*fdtDS)Nc2i|]}|t|S)r/r1s r5 z(GoalContract.to_dict..;s%>>>74##>>>r7)r9r:s`r5to_dictzGoalContract.to_dict:s>>>>-=>>>>r7dataOptional[Dict[str, Any]]'GoalContract'cttts |S|difdtDS)Nc~i|]9}|t|pd:Sr()r)getr0)r2r3rBs r5r@z*GoalContract.from_dict..As>RRRAaTXXa[[.B//5577RRRr7r?) isinstancedictr9)clsrBs `r5 from_dictzGoalContract.from_dict=sL$%% 355LsSSRRRRAQRRRSSSr7cg}tD]L}t||}|r&|dt|d|Md|S)uRender non-empty contract fields as a labelled block. Empty contract → empty string (callers skip the section entirely).- :  )r9r/r0append_CONTRACT_LABELSjoin)r4linesr3vals r5 render_blockzGoalContract.render_blockCsz! @ @A$""((**C @ >"21"5>>>>???yyr7Nr*r+)r*r<)rBrCr*rDr*r))__name__ __module__ __qualname____doc__r__annotations__rrrrr;rA classmethodrLrVr?r7r5r'r'%sGLKJIKKKK????TTT[T       r7r'textr)r*Tuple[str, GoalContract]c|sdtfSg}dtD}|D]}|}|sd}d|vr|d\}}}t |} | C|r/|| |d}|s||d |} td id| D} | | fS) uLSplit user-typed goal text into a headline + structured contract. Supports inline ``field: value`` lines so power users can type a full contract in one shot, e.g.:: Migrate auth to JWT verify: the auth test suite passes constraints: keep the public /login response shape unchanged boundaries: only touch services/auth and its tests stop when: a schema change needs product sign-off The first non-field line(s) become the goal headline; recognized ``field:`` lines populate the contract. Lines for the same field are joined. Unrecognized prefixes stay part of the headline, so a plain free-form goal with an incidental colon (``Fix bug: the parser``) is NOT mangled — only lines whose prefix matches a known alias are pulled out. Returns ``(headline, contract)``. r(ci|]}|gSr?r?)r2r3s r5r@z"parse_contract..es#D#D#DaAr#D#D#Dr7F:NT cdi|]-\}}|d|.S)rd)rSr0)r2r3vs r5r@z"parse_contract..ws4 = = =da1chhqkk!! = = =r7r?) r'r9 splitlinesr0 partition_CONTRACT_ALIASESrHlowerrQrSitems) r_headline_partsfieldsraw_linelinematchedprefix_valuekeyheadlinecontracts r5parse_contractrwNsc& "<>>!! "N#D#D3C#D#D#DFOO%% ( (~~   $;;#~~c22 FAu#'' (<(<(>(>??C5;;==s ""5;;==111 (  ! !$ ' ' 'xx''--//H = =fllnn = = =H X r7cVeZdZUdZded<dZded<dZded<eZded <d Z d ed <d Z d ed <dZ ded<dZ ded<dZ ded<dZded<eeZded<dZded<dZded<d Zd ed<dZded<d Zd ed<eeZded<d'd Zed(d#Zd)d%Zd'd&ZdS)* GoalStatez+Serializable goal state stored per session.r)ractivestatusrint turns_used max_turnsfloat created_at last_turn_atN Optional[str] last_verdict last_reason paused_reasonconsecutive_parse_failures)default_factoryz List[str]subgoals Optional[int]waiting_on_pidwaiting_on_session waiting_untilwaiting_reason waiting_sincer'rvr*cLt|}tj|dS)NF) ensure_ascii)rjsondumps)r4rBs r5to_jsonzGoalState.to_jsons"d||z$U3333r7raw 'GoalState'c tj|}|dpg}g}t|tr d|D}|did|ddd|dddt |ddpdd t |d t pt d t|d d pd d t|d d pd d |d d|dd|ddt |ddpdd|d|drt |dndd|drt|dnddt|dd pd d|ddt|dd pd dt |dS)Nrcg|]D}t|#t|ESr?)r)r0r2ss r5 z'GoalState.from_json..s9OOO1A OA OOOr7rr(r{rzr}rr~rrrrrrrrrrrrrvr?) rloadsrHrIlistr|DEFAULT_MAX_TURNSrr)r'rL)rKrrB raw_subgoalsrs r5 from_jsonzGoalState.from_jsonsz#xx ++1r   lD ) ) POO OOOHs   &"%%% 88Hh/// 488L!449::: $((;0ABBWFWXXX  TXXlC88?C@@@  txx<<CDDD  .111 /// ((?333 (+4884PRS+T+T+YXY'Z'Z'Z X <@88DT;U;U_C%5 6777[_ DH88L`CaCa kD)=$> ? ? ?gk  # > > E#FFF  88$4555  # > > E#FFF! ""++DHHZ,@,@AAA#  r7r+cH|jduo|j Sr.)rvr;r:s r5 has_contractzGoalState.has_contracts%}D(I1G1G1I1I-IIr7cz|jsdSddt|jdDS)z\Render the subgoals as a numbered ``- N. text`` block. Empty when no subgoals exist.r(rPc3,K|]\}}d|d|VdSrNz. Nr?r2ir_s r5r6z2GoalState.render_subgoals_block..s7[[ga)a))4))[[[[[[r7start)rrS enumerater:s r5render_subgoals_blockzGoalState.render_subgoals_blocksD} 2yy[[4=XY9Z9Z9Z[[[[[[r7rX)rr)r*rrW)rYrZr[r\r]r{r}rr~rrrrrrrrrrrrrrr'rvrr^rrrr?r7r5ryrys55 IIIFJ&I&&&&JL"&L&&&&!%K%%%%#'M''''&'''''  %555H5555(%)N(((((,,,,,M$(N((((M#U<@@@H@@@@4444    [ 8JJJJ \\\\\\r7ry session_idc d|S)Nzgoal:r?)rs r5 _meta_keyrs :  r7Dict[str, Any] _DB_CACHE Optional[Any]c ddlm}ddlm}t |}n3#t $r&}t d|Yd}~dSd}~wwxYwt |}||S |}n3#t $r&}t d|Yd}~dSd}~wwxYw|t|<|S)aReturn a SessionDB instance for the current HERMES_HOME. SessionDB has no built-in singleton, but opening a new connection per /goal call would thrash the file. We cache one instance per ``hermes_home`` path so profile switches still pick up the right DB. Defensive against import/instantiation failures so tests and non-standard launchers can still use the GoalManager. r)get_hermes_home) SessionDBz,GoalManager: SessionDB bootstrap failed (%s)Nz$GoalManager: SessionDB() raised (%s)) hermes_constantsr hermes_staterr) ExceptionloggerdebugrrH)rrhomeexccacheddbs r5_get_session_dbrs444444******??$$%%  CSIIIttttt]]4 F   Y[[  ;SAAAtttttIdO Is,#& AAA8 B B3 B..B3Optional[GoalState]c|sdSt}|dS |t|}n3#t$r&}td|Yd}~dSd}~wwxYw|sdS t |S#t$r'}td||Yd}~dSd}~wwxYw)z4Load the goal for a session, or None if none exists.Nz GoalManager: get_meta failed: %sz3GoalManager: could not parse stored goal for %s: %s) rget_metarrrrryrwarning)rrrrs r5 load_goalrs t   B ztkk)J//00  7===ttttt t""3''' LjZ]^^^ttttts-"; A+A&&A+3B B>B99B>stateNonec|sdSt}|dS |t||dS#t$r&}t d|Yd}~dSd}~wwxYw)z5Persist a goal to SessionDB. No-op if DB unavailable.Nz GoalManager: set_meta failed: %s)rset_metarrrrr)rrrrs r5 save_goalr#s    B z> Ij))5==??;;;;; >>> 7=========>s5A A?A::A?cZt|}|dSd|_t||dS)zDMark a goal cleared in the DB (preserved for audit, status=cleared).Ncleared)rr{r)rrs r5 clear_goalr0s6 j ! !E }EL j%     r7r(reasonold_session_idnew_session_idrr+ct|r|r||krdS t|}|t|dddkrdSt|dSt||t|td|||pddS#t $r&}td|Yd}~dSd}~wwxYw) uCarry a persistent /goal from a parent session to its continuation. Context compression rotates ``session_id`` to a fresh child session, but ``load_goal`` does a flat ``goal:`` lookup with no parent-lineage walk — so an active goal silently dies at the compaction boundary (#33618). Copy the goal onto the new session and archive the old row as ``cleared`` so exactly one active goal row exists per logical conversation (avoids the "two active goals" hazard of a pure copy). Returns True when a goal was migrated, False when there was nothing to migrate or the DB was unavailable. Best-effort and never raises — a failure here must not block compression. FNr{rz(GoalManager: migrated goal %s -> %s (%s)rotationTz&GoalManager: goal migration failed: %s)rr/rrrrr)rrrrrs r5migrate_goal_to_sessionr9s >^3S3Su.)) =GE8T::iGG5 ^ $ $ 05.%(((>""" 6 NF,@j   t  =sCCCuuuuus"&BB>B B7B22B7limitr|cN|sdSt||kr|S|d|dzS)Nr(u… [truncated])len)r_rs r5 _truncaterds9 r 4yyE <+ ++r7pidc|r|dkrdS ddlm}t|t|S#t$rYnwxYw ddl}t|t|S#t$rYdSwxYw)u<Return True if a process with ``pid`` is currently alive. Delegates to ``gateway.status._pid_exists`` — the canonical, cross-platform, footgun-safe liveness check (psutil with a ctypes / POSIX fallback). Critically this avoids ``os.kill(pid, 0)``, which on Windows is NOT a no-op: it routes to ``CTRL_C_EVENT`` and hard-kills the target's console process group (bpo-14484). Any error resolves to False (treat unknown as dead) so a stale barrier never wedges the loop — the worst case is the goal resumes one turn early, which is safe. rF) _pid_existsN)gateway.statusrr+r|rpsutil pid_exists)rrrs r5 _pid_aliverls #((u ......KKC))***       F%%c#hh//000 uus!*7 AA2A;; B B c~|sdS ddlm}t||S#t$rYdSwxYw)u]Whether a goal parked on a process_registry session should stay parked. Delegates to ``process_registry.is_session_waiting`` — True while the session is running and (if it has watch_patterns) its trigger hasn't fired. Fail-safe: any import/registry error yields False (don't wait) so a stale barrier can never wedge the loop. Frprocess_registry)tools.process_registryrr+is_session_waitingr)rrs r5_session_waitingrsg u;;;;;;$77 CCDDD uus '. <<z\{.*?\}c  ddlm}|}|dpididt}t |}|dkr|Sn#t $rYnwxYwtS)a#Resolve auxiliary.goal_judge.max_tokens, falling back to the default. ``load_config()`` is cached on the config file's (mtime, size), so calling this once per judge turn is cheap. A non-positive or non-int value falls back to the default rather than crashing the goal loop. r) load_config auxiliary goal_judge max_tokens)hermes_cli.configrrHDEFAULT_JUDGE_MAX_TOKENSr|r)rcfgrss r5_goal_judge_max_tokensrs  111111kmm WW[ ! ! 'R Sr " " S7 8 8  E  199L       ##sA*A.. A;:A;r/Tuple[str, str, bool, Optional[Dict[str, Any]]]c |sdS|}|dr=|d}|d}|dkr ||dzd}d tj| ng#t $rZt |}|r; tj|d n#t $rd YnwxYwYnwxYwt tsd d t|d d dfSt d pdpd} d}t|tr'|}nh d}t|tr)|dv}nt|}|rdnd }|dvrd }|dkr||ddfSd% fd } dp) dp d} t| tr.| rd|dd| ifS| ddd } | d|dd| ifS| d!d"d#} | d|dd"| ifSd |d$ddfS)&aParse the judge's reply. Fail-open on unusable output. Returns ``(verdict, reason, parse_failed, wait_directive)`` where: - ``verdict`` is ``"done"``, ``"continue"``, or ``"wait"``. - ``parse_failed`` is True when the judge returned output that couldn't be interpreted as the expected JSON verdict (empty body, prose, malformed JSON). Callers use it to auto-pause after N consecutive parse failures so a weak judge model doesn't silently burn the budget. - ``wait_directive`` is set only for ``verdict == "wait"``: a dict with ``{"pid": int}`` or ``{"seconds": int}`` (whichever the judge supplied). ``None`` otherwise. If a wait verdict carries neither a usable pid nor seconds, it is downgraded to ``continue`` (can't park on nothing). Accepts both the new ``{"verdict": ...}`` shape and the legacy ``{"done": }`` shape. )continuezjudge returned empty responseTN````rPrNrrzjudge reply was not JSON: Trr(zno reason providedverdictr>1yesrtrue>rwaitrrFkeysr)r*rc|D]K}|}| t|}|dkr|cS5#ttf$rYHwxYwdS)Nr)rHr| TypeError ValueError)rkrfivrBs r5 _first_intz)_parse_judge_response.._first_intsz  A Ay VV66IIIz*    ts9A  A wait_on_sessionr wait_session wait_on_pidrwait_pidwait_for_secondsseconds wait_secondsu, (wait verdict had no target — continuing))rr)r*r)r0 startswithfindrrr_JSON_OBJECT_REsearchgrouprIrJrr)rHrjr+)rr_nlmatchr verdict_rawrdone_valrrsessrrrBs @r5_parse_judge_responsersE" GFF 99;;D u!zz# YYt__ 88Q=D&*D z$ &&t,,   z%++a..11      dD ! !\O #s8K8KOOQUW[[[ (##)r * * 0 0 2 2 J6JF((9%%K+s##1##%%++--88F## h $ $ ">>##))++/KKDD>>D 0&&j222&t++       88% & & \$((<*@*@ \DHH^D\D\D$CCvu|TZZ\\&BBB *]E: 6 6C vuucl22j+YGGGvuy'&::: &NNNPUW[ [[s6/B&C(+'CC( C"C(!C""C('C(background_processesOptional[List[Dict[str, Any]]]c|sdSg}|D]}t|ts|ddkr3|d}|sKtt |dpdddd}|d }tt |d pdddd}|d }d |}|r|d |z }|d|z }| |d|dz }|d} | r$|drdnd} |d| | z }n|dr|dz }|r|d|z }|||sdSt d |S)aRender the live background-process list for the judge prompt. Each entry is a ``process_registry.list_sessions()`` dict. Only RUNNING processes are worth showing (an exited one is nothing to wait on). Returns an empty string when there's nothing running, so the judge prompt is byte-identical to the no-background case (no behavior change for the common path). r(r{exitedrcommandrPrdxuptime_secondsoutput_previewrz- pid z / session rONz (running zs)watch_patterns watch_hitz [already matched]z | watch_patterns=notify_on_completez | notify_on_completez | recent output: )background_lines) rIrJrHrr)replacer0rQJUDGE_BACKGROUND_BLOCK_TEMPLATEformatrS) rrTprcmduptimetailsidrowpshits r5_render_background_blockr)s> rE !!T""   55??h & & eeEll  AEE),,233;;D#FFLLNNPSTT'((QUU#344:;;CCD#NNTTVVX[\\eeL!!~~  ( '#'' 'D S    ++++ +Dee$%%  ,*+%% *<*<D&&"C 33c33 3DD UU' ( ( , + +D  0 /// /D T r * 1 1499UCSCS 1 T TTr7)timeoutrrrv last_responser*rrOptional[List[str]]rvOptional[GoalContract]c $|sdS|sdS ddlm}m}n3#t$r&}t d|Yd}~dSd}~wwxYw |d\} } n3#t$r&}t d |Yd}~dSd}~wwxYw| | sd Sd |pgD} t|} tj tj  d } ||s|}| r5ddt#| dD}|d|}t$t)|dt)|dt)|t*| | }n| r}ddt#| dD}t,t)|dt)|dt)|t*| | }n?t.t)|dt)|t*| | } | jj| dt6dd|dgdt9||pd}nM#t$r@}t d|ddt=|jddfcYd}~Sd}~wwxYw |j dj!j"pd }n#t$rd }YnwxYwtG|\}}}}t d!|t)|d"|rd#|nd ||||fS)$uAsk the auxiliary model whether the goal is satisfied. Returns ``(verdict, reason, parse_failed, wait_directive)`` where verdict is ``"done"``, ``"continue"``, ``"wait"``, or ``"skipped"`` (when the judge couldn't be reached). ``wait_directive`` is set only for ``"wait"`` (``{"pid": int}`` or ``{"seconds": int}``); ``None`` otherwise. ``parse_failed`` is True only when the judge call succeeded but its output was unusable (empty or non-JSON). API/transport errors return False — they are transient and should fail-open silently. Callers use this flag to auto-pause after N consecutive parse failures (see ``DEFAULT_MAX_CONSECUTIVE_PARSE_FAILURES``). ``subgoals`` is an optional list of user-added criteria (from ``/subgoal``) factored into the verdict. ``background_processes`` is the live ``process_registry.list_sessions()`` snapshot; when the agent is waiting on one (a CI poller, build, etc.) the judge can return a ``wait`` verdict naming its pid, parking the loop instead of re-poking. ``contract`` is an optional structured completion contract; when present the judge decides DONE strictly against its Verification criterion and refuses completion when a Constraint was violated. All three are additive — a contract, subgoals, and a background-process list can coexist in one judge prompt; when none are set, behavior is identical to the original free-form judge. This is deliberately fail-open: any error returns ``("continue", ..., False, None)`` so a broken judge doesn't wedge progress — the turn budget and the consecutive-parse-failures auto-pause are the backstops. )skippedz empty goalFN)rz$empty response (nothing to evaluate)FNrget_auxiliary_extra_bodyget_text_auxiliary_clientz.goal judge: auxiliary client import failed: %sN)rzauxiliary client unavailableFNrz0goal judge: get_text_auxiliary_client failed: %s)rzno auxiliary client configuredFNcbg|],}|||-Sr?)r0rs r5rzjudge_goal..s2MMMAQM17799MaggiiMMMr7)tzz%Y-%m-%d %H:%M:%S %ZrPc3,K|]\}}d|d|VdSz- Extra criterion rONr?rs r5r6zjudge_goal..sJAt1Q00$00r7rrii )rcontract_blockresponsebackground_block current_timec3,K|]\}}d|d|VdSrr?rs r5r6zjudge_goal..sH# # !(D   d  # # # # # # r7)rsubgoals_blockr8r9r:)rr8r9r:systemrolecontentusermodelmessages temperaturerr* extra_bodyu@goal judge: API call failed (%s) — falling through to continuerz judge error: Fr(z"goal judge: verdict=%s reason=%s%srz wait=)$r0agent.auxiliary_clientr1r2rrrr)rnowrutc astimezonestrftimer;rVrSr(JUDGE_USER_PROMPT_WITH_CONTRACT_TEMPLATEr!r_JUDGE_RESPONSE_SNIPPET_CHARS(JUDGE_USER_PROMPT_WITH_SUBGOALS_TEMPLATEJUDGE_USER_PROMPT_TEMPLATEchat completionscreateJUDGE_SYSTEM_PROMPTrinfotyperYchoicesmessager@r)rr+r*rrrvr1r2rclientrCclean_subgoalsr9r:r7extrapromptr<resprrr parse_failedwait_directives r5 judge_goalr_DsL ::<<433    ONNG^^^^^^^^^ GGG EsKKKFFFFFFGG11,??  GGG GMMMFFFFFFG~U~HH NM(.bMMMN/0DEE<8<000;;==FFG]^^LH$5$5$7$7!..00  :II(qAAAE!/99%99N9@@4&&$^T::}.KLL-% A    # # ,5nA,N,N,N# # #   :@@4&&$^T::}.KLL-% A  ,224&&}.KLL-% 3  M{&--!.ABBF33-////119T.    MMM VX[\\\?499+=??LLLLLLLMl1o%-3 5J#4N4N1GV\> KK,63''%3;!!!! FL. 88s^7 A'A""A'+A:: B*B%%B*AK L5L LLL44 MMtask_idrList[Dict[str, Any]]c ddlm}||pg}n4#t$r'}td|gcYd}~Sd}~wwxYwd|DS)uReturn the live background-process snapshot for the goal judge. Thin, fail-safe wrapper over ``process_registry.list_sessions(task_id)``. Returns only RUNNING processes (an exited one is nothing to wait on) and never raises — any import/registry failure yields ``[]`` so the goal loop degrades to its pre-wait-barrier behavior (judge just won't see processes). The drivers (CLI + gateway) call this and pass the result into ``GoalManager.evaluate_after_turn(background_processes=...)``. rr)r`z&gather_background_processes failed: %sNcng|]2}t|t|ddk0|3S)r{r)rIrJrHrs r5rz/gather_background_processes..s; W W W!:a#6#6 W155??h;V;VA;V;V;Vr7)rr list_sessionsrrr)r`rsessionsrs r5gather_background_processesrfs;;;;;;#11'1BBHb  =sCCC  X Wx W W WWs! AA A A)r* objectivec |pd}|sdS ddlm}m}n3#t$r&}t d|Yd}~dSd}~wwxYw |d\}}n3#t$r&}t d|Yd}~dSd}~wwxYw||sdS |jj |dtd d d t|d d gdt||pd }n3#t$r&}t d|Yd}~dSd}~wwxYw |jdjjpd}n#t$rd}YnwxYwt#|} t%| t&s+t dt|ddSt(| } | rdn| S)uExpand a plain-language objective into a structured completion contract. Uses the ``goal_judge`` auxiliary task (main-model-first, cache-safe — it is a side LLM call, not a conversation turn). Returns a populated :class:`GoalContract` on success, or ``None`` when the auxiliary client is unavailable or the model's reply can't be parsed. Callers fall back to a bare free-form goal in that case, so a missing/weak aux model never blocks setting a goal. r(Nrr0z.goal draft: auxiliary client import failed: %srz0goal draft: get_text_auxiliary_client failed: %sr=r>rAz Objective: rrBz goal draft: API call failed (%s)z"goal draft: reply was not JSON: %rr)r0rGr1r2rrrrPrQrRDRAFT_CONTRACT_SYSTEM_PROMPTrrrTrVrWr@_extract_json_objectrIrJr'rLr;) rgr*r1r2rrXrCr\rrBrvs r5draft_contractrkseb''))I t^^^^^^^^^  EsKKKttttt11,??   GMMMttttt~U~t{&--!.JKK,W9YPT;U;U,W,WXX-////119T.     6<<<tttttl1o%-3   $ $D dD ! ! 99S#;N;NOOOt%%d++H$$&& 444H4sW% AAAA(( B2BB"AC<< D,D''D,0E EErCc|sdS|}|dr=|d}|d}|dkr ||dzd} tj|}nj#t $r]t |}|sYdS tj|d}n#t $rYYdSwxYwYnwxYwt|tr|ndS)zBest-effort: pull the first JSON object out of a model reply. Shares the fence-stripping + first-object fallback logic used by the judge parser, but returns the dict (or None) rather than a verdict. NrrrPrrr) r0rr rrrr r r rIrJ)rr_r rBrs r5rjrjs# t 99;;D u!zz# YYt__ 88Q=D z$ &&t,, 44 :ekk!nn--DD   444  D dD)) 344t3s6,B&C(+'CC( C"C(!C""C('C(ceZdZdZedd=dZed>d Zd?d Zd?d Z d?dZ d@dZ ddddAdZ dBdZ dCdDdZdddEd!ZdFd#ZdGd$ZdHd&ZdId(ZdJd)Zd@d*ZdKdLd-ZdKdMd.ZdKdNd0Zd?d1Zd?d2Zddd3dOd9ZdPd;Zd@d<ZdS)Q GoalManagerufPer-session goal state + continuation decisions. The CLI and gateway each hold one ``GoalManager`` per live session. Methods: - ``set(goal)`` — start a new standing goal. - ``clear()`` — remove the active goal. - ``pause()`` / ``resume()`` — explicit user controls. - ``status()`` — printable one-liner. - ``evaluate_after_turn(last_response)`` — call the judge, update state, and return a decision dict the caller uses to drive the next turn. - ``next_continuation_prompt()`` — the canonical user-role message to feed back into ``run_conversation``. )default_max_turnsrr)ror|cr||_t|pt|_t ||_dSr.)rr|rror_state)r4rros r5__init__zGoalManager.__init__Fs3$!$%6%K:K!L!L+4Z+@+@ r7r*rc|jSr.)rqr:s r5rzGoalManager.stateMs {r7r+c4|jduo|jjdkS)Nrzrqr{r:s r5 is_activezGoalManager.is_activeQs{$&I4;+=+IIr7c0|jduo |jjdvS)N>rzpausedrur:s r5has_goalzGoalManager.has_goalTs{$&U4;+=AU+UUr7cF|jduo|jSr.)rqrr:s r5rzGoalManager.has_contractWs"{$&E4;+C+C+E+EEr7c|j}| |jdvrdS|jd|jd}|jr4dt |jdt |jdkrdnd nd }|rd nd }|||}|jd kr|jr5t|jr!|j p d |j}d |d|d|j S|j r5t|j r!|j p d|j }d |d|d|j S|j rctj|j krGt|j tjz }|j p|d}d|d|d|d|j Sd|d|j S|jdkr"|jr d|jnd }d||d|j S|jdkr d|d|j Sd|jd|d|j S)N>rz*No active goal. Set one with /goal ./z turnsz, z subgoalrrr(z , contractrzsession u⏳ Goal (parked on ): pid u⏳ Goal (parked us — u⊙ Goal (active, rxu — u⏸ Goal (paused, ru✓ Goal done (zGoal ()rqr{r}r~rrrrrrrrrrtimer|r) r4rturnssubconmetawr remainingrZs r5 status_linezGoalManager.status_lineZs K 9L00??<55!+555UVU_gQ3qz??QQ3qz??a3G3GCCRQQQeg"//119llr##c## 8x  # F(89M(N(N F%J)JA4H)J)JEbEEDEEQVEEE FJq/?$@$@ F%B)B0@)B)BEbEEDEEQVEEE T49;;#@#@$)++ =>> %8IS9SSBSS$SS16SSS99999 9 8x  12H-AO---bE@@e@@@@ @ 8v  6T66af66 6555D55QV555r7N)r~rvrr~rrvr-ryc &|pd}|stdt|dd|rt|n|jt jd||n t }||_t|j ||S)Nr(zgoal text is emptyrzrr)rr{r}r~rrrv) r0rryr|rorr'rqrr)r4rr~rvrs r5setzGoalManager.setws !!## 3122 2(1Mc)nnnt7My{{!)!5XX<>>    $/5))) r7r'c|jdS|p t|j_t|j|j|jS)zAttach or replace the completion contract on the active goal. Returns the updated state, or None when there is no goal to attach to. N)rqr'rvrr)r4rvs r5 set_contractzGoalManager.set_contracts@ ; 4'9<>> $/4;///{r7 user-pausedrc|jsdSd|j_||j_d|j_d|j_d|j_d|j_d|j_t|j |j|jS)Nrxr) rqr{rrrrrrrrr4rs r5pausezGoalManager.pausess{ 4% $* !%) ")- &$' !%) "$' !$/4;///{r7T) reset_budgetrc|jsdSd|j_d|j_d|j_d|j_d|j_d|j_d|j_|r d|j_t|j |j|jS)Nrzrr) rqr{rrrrrrr}rr)r4rs r5resumezGoalManager.resumes{ 4% $( !%) ")- &$' !%) "$' !  '%&DK "$/4;///{r7rcr|jdSd|j_t|j|jd|_dS)Nr)rqr{rrr:s r5clearzGoalManager.clears8 ;  F& $/4;/// r7c|jsdSd|j_d|j_||j_t |j|jdS)Nr)rqr{rrrrrs r5 mark_donezGoalManager.mark_donesI{  F# #)  "( $/4;/////r7r_c|j|std|pd}|st d|jj|t|j|j|S)zAppend a user-added criterion to the active goal. Requires ``has_goal()``; raises ``RuntimeError`` otherwise. Returns the cleaned text so the caller can show it back to the user. Nno active goalr(zsubgoal text is empty) rqry RuntimeErrorr0rrrQrr)r4r_s r5 add_subgoalzGoalManager.add_subgoals ; dmmoo /00 0 !!## 6455 5 ##D)))$/4;/// r7 index_1basedc|j|stdt|dz }|dks|t |jjkr*t dt |jjd|jj|}t|j |j|S)z to add criteria))rqrrr:s r5render_subgoalszGoalManager.render_subgoalss8 ; %%{# KJJ{00222r7r(rc|j|jjdkrtdt|}|dkrt d||j_d|j_d|j_|pdpd|j_ tj |j_ t|j |j|jS)uPark the goal loop on a background process PID. While the PID is alive, ``evaluate_after_turn`` returns ``should_continue=False`` without burning a turn or calling the judge — the loop quiesces instead of re-poking the agent into busy work. The barrier auto-clears when the process exits. Requires an active goal. For a process with a watch_patterns/notify_on_complete trigger, prefer ``wait_on_session`` so a mid-run trigger (not just exit) releases the barrier. Nrzno active goal to parkrzpid must be a positive integerrr()rqr{rr|rrrrr0rrrrr)r4rrs r5wait_onzGoalManager.wait_ons ; $+"4"@"@788 8#hh !88=>> >%( ")- &$' !&,l%9%9%;%;%Ct "$(IKK !$/4;///{r7c|j|jjdkrtdt|pd}|st d||j_d|j_d|j_|pdpd|j_ tj |j_ t|j |j|jS)uPark the goal loop on a process_registry session's OWN trigger. Unlike ``wait_on`` (which releases only on PID exit), this releases when the session's trigger fires: it exits, OR — if it was started with ``watch_patterns`` — its pattern matches. This is the right barrier for a long-lived watcher/server/poller that signals mid-run and may never exit. Requires an active goal. Nrzrr(z%session_id must be a non-empty stringr)rqr{rr)r0rrrrrrrrr)r4rrs r5rzGoalManager.wait_on_session s ; $+"4"@"@788 8)r**0022  FDEE E)3 &%) "$' !&,l%9%9%;%;%Ct "$(IKK !$/4;///{r7rc|j|jjdkrtdt|}|dkrt dd|j_d|j_tj|z|j_|pd pd|j_ tj|j_ t|j |j|jS)u;Park the goal loop until ``seconds`` from now have elapsed. Time-based counterpart to ``wait_on`` — for backoff / cooldown waits where there's no process to track (e.g. the agent is rate-limited). The barrier auto-clears once the deadline passes. Requires an active goal. Nrzrrz"seconds must be a positive integerr()rqr{rr|rrrrrr0rrrr)r4rrs r5rzGoalManager.wait_for_secondss ; $+"4"@"@788 8g,, a<<ABB B%) ")- &$(IKK'$9 !&,l%9%9%;%;%Ct "$(IKK !$/4;///{r7c|jdS|jj|jj|jjsdSd|j_d|j_d|j_d|j_d|j_t |j|jdS)z^Clear any active wait barrier (pid / session / time). Returns True if one was cleared.NFrT)rqrrrrrrrr:s r5 stop_waitingzGoalManager.stop_waiting4s ; 5 K & . .6K-75%) ")- &$' !%) "$' !$/4;///tr7c^|j}|dS|j,t|jrdS|dS|j,t |jrdS|dS|jr4tj|jkrdS|dSdS)aTrue iff a barrier is set AND not yet satisfied. Session barrier: active until the process exits or its watch-pattern trigger fires. Pid barrier: active while the process is alive. Time barrier: active until the deadline passes. Side effect: a satisfied barrier is cleared here (lazy auto-clear) so the next evaluation resumes normal judging. NFT)rqrrrrrrr)r4rs r5 is_waitingzGoalManager.is_waitingGs K 95  + 455 t      5  '!*++ t      5 ? y{{Q_,,t      5ur7)user_initiatedrr+rrrrc |j}| |jdkr|r|jndddddddS|rw|j d|j}nM|j d |j}n;t d t |jtjz }|d }|j p|}dddd |d |d|dS|xj dz c_ tj|_ t|j ||jpd||r|jnd\}}} } ||_||_| r|xjdz c_nd |_|dkr| r| dr6|t-| d|d| d}n| dr6|t | d|d | d}n5|t | d|| dd}dddd|d|d|dS|dkr(d|_t3|j|dddd|d|dS|jt6kr>d|_d|jd|_t3|j|dddd|d|jddS|j |jkrNd|_d |j d!|jd"|_t3|j|dddd|d#|j d!|jd$dSt3|j|dd%|d|d&|j d!|jd'|dS)(uRun the judge and update state. Return a decision dict. ``user_initiated`` distinguishes a real user prompt (True) from a continuation prompt we fed ourselves (False). Both increment ``turns_used`` because both consume model budget. ``background_processes`` is the live ``process_registry.list_sessions()`` snapshot for this session. It's handed to the judge so it can decide to WAIT on an in-flight process (CI poller, build, ...) instead of re-poking the agent — the automatic counterpart to ``/goal wait``. Decision keys: - ``status``: current goal status after update - ``should_continue``: bool — caller should fire another turn - ``continuation_prompt``: str or None - ``verdict``: "done" | "continue" | "wait" | "skipped" | "inactive" - ``reason``: str - ``message``: user-visible one-liner to print/send NrzFinactiverr()r{should_continuecontinuation_promptrrrWr}rrz s remainingwaitingu⏳ Goal parked — waiting on rOr)rrrvrrrrrru'⏳ Goal parked (judge) — waiting on ru✓ Goal achieved: rxz(judge model returned unparseable output z turns in a rowru%⏸ Goal paused — the judge model (z turns) isn't returning the required JSON verdict. Route the judge to a stricter model in ~/.hermes/config.yaml: auxiliary: goal_judge: provider: openrouter model: google/gemini-3-flash-preview Then /goal resume to continue.zturn budget exhausted (r|ru⏸ Goal paused — zD turns used. Use /goal resume to keep going, or /goal clear to stop.Tu↻ Continuing toward goal (r~)rqr{rrrmaxr|rrrr}rr_rrrrvrrrrHrr)rrrr&DEFAULT_MAX_CONSECUTIVE_PARSE_FAILURESrr~next_continuation_prompt) r4r+rrrtgtrrrr]r^s r5evaluate_after_turnzGoalManager.evaluate_after_turnfs4  =ELH44*/9%,,T#('+%*   ??   '3;!9;;%13U1333u':TY[['H#I#IJJ "///)0SF"#('+$ LSLLFLL   A!Y[[8B J ^+t!5','9'9';';EU^^ 9 9 9 5~%"  1  , , 1 , , ,/0E , f   !!,// 6$$S )E%F%Fv$VVV? !=??##E** 6 S!677 GGG4^E244%%c.*C&D&DV%TTT' 2555"#('+! TSTTFTT   f  !EL dou - - - #('+! 999    +/U U U#ELl5;[lll   dou - - -"#('+% 5E<\555 $  u . .#EL"aE.sJ""4544d44""""""r7rr)rr7)rr<)r)rqr{rrvrVrrSr*CONTINUATION_PROMPT_WITH_CONTRACT_TEMPLATEr!r*CONTINUATION_PROMPT_WITH_SUBGOALS_TEMPLATErCONTINUATION_PROMPT_TEMPLATE)r4r7rZs r5rz$GoalManager.next_continuation_prompts>{ dk0H<<4 ; # # % % ![1>>@@N{# > ""#,T[-A#K#K#K"""%3!=!=e!=!==DD[%-E  ;  =DD[%#{@@BBE ,22 8H2IIIr7c|jdS|jsdS|jjS)z>Public helper for the /goal show + /goal draft slash commands.Nru^(no completion contract — set one with /goal draft or inline field: value lines))rqrrvrVr:s r5render_contractzGoalManager.render_contract.sD ; %%{'')) tss{#00222r7)rr)ror|)r*rrWrX)rr)r~rrvr-r*ry)rvr'r*r)r)rr)r*r)rr+r*r)r*r)rr)r*r)r_r)r*r))rr|r*r)r*r|rG)rr|rr)r*ry)rr)rr)r*ry)rr|rr)r*ry)r+r)rr+rrr*r)r*r)rYrZr[r\rrrpropertyrrvryrrrrrrrrrrrrrrrrrrrrr?r7r5rnrn5s EVAAAAAAXJJJJVVVVFFFF6666:<@dh"         .2 0000        33330,*&F $?C m m m m m m ^JJJJ2333333r7rnuM[Continuing toward this kanban task — judge says it is not done yet] Reason: {reason} Take the next concrete step toward completing the task. When the work is genuinely finished, call kanban_complete with a summary. If you are blocked and need human input, call kanban_block with a reason. Do not stop without calling one of them.z[The work looks complete, but the task is still open] Reason: {reason} If the task is genuinely done, call kanban_complete now with a short summary of what you did. If something still blocks completion, call kanban_block with the reason instead.)r~first_responselog goal_textr~rc d6fd }t|pt}|dkrt}|pd} d} d} |} n,#t$r} |d | d d | d dcYd} ~ Sd} ~ wwxYw| dkr|d|d| dd| ddS| dkr|d|d| dd| ddS| dvr|d|d| dd | d| dSt|| \}}}}|dkrd}|d | d!|d"|d#t |d$|dkrz| rL|d|d% |d&|d'n&#t$r} |d(| d)Yd} ~ nd} ~ wwxYwd*| d+dSt t |d,-}d } n)tt |d,-}| |kre|d|d.| d!|d/ |d0| d!|d1t |d2n&#t$r} |d(| d)Yd} ~ nd} ~ wwxYwd*| d3dS ||pd} nA#t$r4} |d4| d d | d5t| j dcYd} ~ Sd} ~ wwxYw| dz } @)7uDrive a kanban worker through a Ralph-style goal loop. The dispatcher spawns a goal-mode worker exactly like a normal worker (``hermes -p chat -q "work kanban task "``). The worker's first turn has already run by the time this is called; ``first_response`` is that turn's reply. From here we: 1. Check whether the worker already terminated the task (called ``kanban_complete`` / ``kanban_block``). If so, stop — nothing to do. 2. Otherwise judge the latest response against ``goal_text`` (the card's title + body). ``continue`` → feed a continuation prompt and run another turn IN THE SAME SESSION via ``run_turn``. ``done`` but the task is still open → one explicit "call kanban_complete" nudge. 3. When the turn budget is exhausted and the worker still hasn't terminated the task, ``block_fn`` is invoked so the card lands in a sticky ``blocked`` state for human review (NOT a silent exit). This function performs NO SessionDB persistence — a worker process is ephemeral, so the turn budget lives in a local counter. It is fully decoupled from the CLI for testability: callers inject ``run_turn`` (str -> str), ``task_status_fn`` (() -> str|None), and ``block_fn`` (reason: str -> None). Returns a decision dict: ``{"outcome", "turns_used", "reason"}`` where outcome is one of ``"completed_by_worker"``, ``"blocked_budget"``, ``"blocked_by_worker"``, or ``"stopped"``. msgr)r*rcJ |dS#t$rYdSwxYwdSr.)r)rrs r5_logz"run_kanban_goal_loop.._log{sG ? C     ?s   rr(FTz'kanban goal loop: status check failed (z ); stoppingstoppedzstatus check failed)rr}rNrzkanban goal loop: task z completed by worker after z turn(s)completed_by_workerzworker completed the taskr%z blocked by worker after blocked_by_workerzworker blocked the task)runningreadyz status=z ; stoppingzstatus=rrzkanban goal loop: turn r|z verdict=z reason=rz0 judged done but worker won't finalize; blockingzfGoal-mode worker's output looked complete but it never called kanban_complete after a finalize nudge (z).z#kanban goal loop: block_fn failed (rblocked_budgetzjudged done, never finalizedirz exhausted z turns; blockingz,Goal-mode worker exhausted its turn budget (z3) without completing the task. Last judge verdict: i,zturn budget exhaustedz#kanban goal loop: run_turn failed (zrun_turn error: )rr)r*r) r|rrr_rKANBAN_GOAL_FINALIZE_TEMPLATEr!!KANBAN_GOAL_CONTINUATION_TEMPLATErUrY)r`rrun_turntask_status_fnblock_fnr~rrrr+r}nudged_to_finalizer{rrr _parse_failed_waitr[s ` r5run_kanban_goal_looprTsNI2!233I1}}% "(bMJA e#^%%FF e e e DK3KKK L L L( Ncdd d d d d d d e V   Dc7cczccc d d d4JZuvv v Y   Da7aaZaaa b b b2*Xqrr r - - - DP7PPFPPP Q Q Q( N`X^N`N`aa a 1;9m0T0T- f   G  qz q qI q q q qYbciknYoYo q qrrr f  ! yhwhhhiiiGHUJPUUU!GGGDEsEEEFFFFFFFFG#3:Ywxxx2996SVAWAW9XXF!%  6==YvWZE[E[=\\F  " " Dg7ggzggIggg h h h CD"DD%.DD+4VS+A+ADD  C C CA3AAABBBBBBBB C/zUlmm m w$HV,,2MM w w w DGsGGG H H H( NuaefiajajasNuNuvv v v v v v v w a CAsk A A) A$A)$A)!D11 E;EE"G11 H;HH H,, I*6)I%I*%I*)ryr'rnrwrkrrrrOrNrLrirrrrrrrr_r)r_r)r*r`)rr)r*r))r*r)rr)r*r)rr)rryr*r)rr)r*r)rr)rr)rr)r*r+)r_r)rr|r*r))rr|r*r+)rr)r*r+r)rr)r*r)rrr*r))rr)r+r)r*rrr,rrrvr-r*rr.)r`rr*ra)rgr)r*rr*r-)rr)r*rC) r`r)rr)r~r|rr)r*r)Dr\ __future__rrloggingrer dataclassesrrrrrtypingr r r r r getLoggerrYrrDEFAULT_JUDGE_TIMEOUTrrMrrrrrSr rOrNrLrir9rRrir'rwryrrr]rrrrrrrrcompileDOTALLr rrr)r_rfrkrjrnrrr__all__r?r7r5rs::#"""""  0000000000''''''''33333333333333  8 $ $  $*+&P ++"+#,X0 9<).U):/>Y" $  y I I  N   n > ^=-  ],  !" \#$ "18 % % % % % % %  % P....l \\\\\\\\\\\\\\ \\H     <* > > > >!!!!XZ######V,,,,8$"*Z33$$$$0^\^\^\^\B+U+U+U+Ud+$(;?'+@9@9@9@9@9@9FXXXXX(8M757575757575t4444@33333333V(", ' xxxxxxv   r7