PL jByUdZddlmZddlZddlZddlZddlZddlmZm Z m Z ddl m Z m Z ddl mZmZmZmZmZejeZdZdZd Zd Zd Zd Zd ZdZdZdZeGddZ d6dZ!iZ"de#d<d7dZ$d8dZ%d9dZ&d:d Z'd;d$Z(ej)d%ej*Z+dd2Z.Gd3d4Z/gd5Z0dS)?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>@iia[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} 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 and the agent's most recent response. Your only job is to decide whether the goal is fully satisfied based on that response. A goal is DONE only when: - 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). Otherwise the goal is NOT done — CONTINUE. Reply ONLY with a single JSON object on one line: {"done": , "reason": ""}zlGoal: {goal} Agent's most recent response: {response} Current time: {current_time} Is the goal satisfied?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} 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. Is the goal AND every additional criterion satisfied?ceZdZUdZded<dZded<dZded<eZded <d Z d ed <d Z d ed <dZ ded<dZ ded<dZ ded<dZded<eeZded<ddZeddZddZdS) GoalStatez+Serializable goal state stored per session.strgoalactivestatusrint turns_used max_turnsfloat created_at last_turn_atN Optional[str] last_verdict last_reason paused_reasonconsecutive_parse_failures)default_factoryz List[str]subgoalsreturncHtjt|dS)NF) ensure_ascii)jsondumpsrselfs 4/home/kuhnn/.hermes/hermes-agent/hermes_cli/goals.pyto_jsonzGoalState.to_jsonsz&,,U;;;;raw 'GoalState'ctj|}|dpg}g}t|tr d|D}||dd|ddt |ddpdt |d t pt t|d d pd t|d d pd |d |d|dt |ddpd| S)Nr#cg|]D}t|#t|ES)rstrip.0ss r+ z'GoalState.from_json..s9OOO1A OA OOOr-rrrrrrrrrrrr r!) rrrrrrrrr r!r#)r'loadsget isinstancelistrDEFAULT_MAX_TURNSr)clsr.data raw_subgoalsr#s r+ from_jsonzGoalState.from_jsonsVz#xx ++1r   lD ) ) POO OOOHs&"%%88Hh//488L!449::$((;0ABBWFWXXTXXlC88?C@@txx<<CDD.11//((?33'*4884PRS+T+T+YXY'Z'Z    r-cz|jsdSddt|jdDS)z\Render the subgoals as a numbered ``- N. text`` block. Empty when no subgoals exist.r8 c3,K|]\}}d|d|VdSz- z. Nr2r5itexts r+ z2GoalState.render_subgoals_block..s7[[ga)a))4))[[[[[[r-start)r#join enumerater)s r+render_subgoals_blockzGoalState.render_subgoals_blocksD} 2yy[[4=XY9Z9Z9Z[[[[[[r-r$r)r.rr$r/)__name__ __module__ __qualname____doc____annotations__rrr=rrrrrr r!rr<r#r, classmethodrArOr2r-r+rrs-55 IIIFJ&I&&&&JL"&L&&&&!%K%%%%#'M''''&'''''  %555H5555<<<<   [ ,\\\\\\r-r session_idrr$c d|S)Nzgoal:r2)rWs r+ _meta_keyrYs :  r-Dict[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_stater_r Exceptionloggerdebugr[r:)r^r_homeexccacheddbs r+_get_session_dbris444444******??$$%%  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) riget_metarYrbrcrdrrAwarning)rWrhr.rfs r+ load_goalrns 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)riset_metarYr,rbrcrd)rWrorhrfs r+ save_goalrss    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)rnrrs)rWros r+ clear_goalrvs6 j ! !E }EL j%     r-rHlimitrcN|sdSt||kr|S|d|dzS)Nr8u… [truncated])len)rHrws r+ _truncaterzs9 r 4yyE <+ ++r-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.configr|r:DEFAULT_JUDGE_MAX_TOKENSrrb)r|cfgvalues r+_goal_judge_max_tokensr*s  111111kmm WW[ ! ! 'R Sr " " S7 8 8  E  199L       ##sA*A.. A;:A;r.Tuple[bool, str, bool]cl|sdS|}|dr=|d}|d}|dkr ||dzd}d} tj|}ng#t $rZt |}|r; tj|d}n#t $rd}YnwxYwYnwxYwt|tsd d t|d d fS| d }t|tr)|dv}nt|}t| dpd}|sd}||d fS)aParse the judge's reply. Fail-open to ``(False, "", parse_failed)``. Returns ``(done, reason, parse_failed)``. ``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 that flag to auto-pause after N consecutive parse failures so a weak judge model doesn't silently burn the turn budget. )Fzjudge returned empty responseTz````rCrJNrFzjudge reply was not JSON: Tdone>1yesrtruereasonr8zno reason provided)r3 startswithfindr'r9rb_JSON_OBJECT_REsearchgroupr;dictrzr:rlowerbool)r.rHnlr?matchdone_valrrs r+_parse_judge_responserBs <;; 99;;D u!zz# YYt__ 88Q=D&*D z$ &&t,,   z%++a..11      dD ! !QJ9S#3F3FJJDPPxxH(C  ~~%%''+GGH~~ (##)r * * 0 0 2 2F &%  s6.B&C'*'CC' C!C' C!!C'&C')timeoutr#r last_responserrr#Optional[List[str]]Tuple[str, str, bool]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} tjtj  d } | r|d dt| dD} tt#|dt#| dt#|t$| } n>t&t#|dt#|t$| } |jj|dt.dd| dgdt1||pd} nL#t$r?}t d|ddt5|jdfcYd}~Sd}~wwxYw | jdjjpd}n#t$rd}YnwxYwt?|\}}}|rdnd}t d|t#|d |||fS)!uAsk the auxiliary model whether the goal is satisfied. Returns ``(verdict, reason, parse_failed)`` where verdict is ``"done"``, ``"continue"``, or ``"skipped"`` (when the judge couldn't be reached). ``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``) that the judge must also factor into its DONE/CONTINUE decision. When non-empty the prompt switches to the with-subgoals template; otherwise behavior is identical to the original judge. This is deliberately fail-open: any error returns ``("continue", "...", False)`` so a broken judge doesn't wedge progress — the turn budget and the consecutive-parse-failures auto-pause are the backstops. )skippedz empty goalF)continuez$empty response (nothing to evaluate)Fr)get_auxiliary_extra_bodyget_text_auxiliary_clientz.goal judge: auxiliary client import failed: %sN)rzauxiliary client unavailableFr~z0goal judge: get_text_auxiliary_client failed: %s)rzno auxiliary client configuredFcbg|],}|||-Sr2)r3r4s r+r7zjudge_goal..s2MMMAQM17799MaggiiMMMr-)tzz%Y-%m-%d %H:%M:%S %ZrCc3,K|]\}}d|d|VdSrEr2rFs r+rIzjudge_goal..sH# # !(D   d  # # # # # # r-rJrKi)rsubgoals_blockresponse current_time)rrrsystem)rolecontentuser)modelmessages temperaturerr extra_bodyu@goal judge: API call failed (%s) — falling through to continuerz judge error: Fr8rz goal judge: verdict=%s reason=%sx) r3agent.auxiliary_clientrrrbrcrdrnowrutc astimezonestrftimerMrN(JUDGE_USER_PROMPT_WITH_SUBGOALS_TEMPLATEformatrz_JUDGE_RESPONSE_SNIPPET_CHARSJUDGE_USER_PROMPT_TEMPLATEchat completionscreateJUDGE_SYSTEM_PROMPTrinfotyperQchoicesmessagerr)rrrr#rrrfclientrclean_subgoalsrrpromptrespr.rr parse_failedverdicts r+ judge_goalrss6 ::<<.--    IHHA^^^^^^^^^ AAA EsKKK@@@@@@AA11,??  AAA GMMM@@@@@@A~U~BBNM(.bMMMN<8<000;;==FFG]^^L # # ,5nA,N,N,N# # #   :@@4&&$^T::}.KLL% A  ,224&&}.KLL%3   G{&--!.ABBF33-////119T.    GGG VX[\\\?499+=??FFFFFFFGl1o%-3 "7s!;!;D&,,ff*G KK2GYvs=S=STTT FL ((s^7 A'A""A'+A:: B*B%%B*AH I4I III22 JJceZdZdZedd-dZed.d Zd/d Zd/d Z d0dZ ddd1dZ d2d3dZ ddd4dZ d5dZd6dZd7d!Zd8d#Zd9d$Zd0d%Zdd&d:d*Zd;d,ZdS)< 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_turnsrWrrrcr||_t|pt|_t ||_dSN)rWrr=rrn_state)r*rWrs r+__init__zGoalManager.__init__s3$!$%6%K:K!L!L+4Z+@+@ r-r$rjc|jSr)rr)s r+rozGoalManager.states {r-rc4|jduo|jjdkS)Nrrrr)s r+ is_activezGoalManager.is_actives{$&I4;+=+IIr-c0|jduo |jjdvS)N>rpausedrr)s r+has_goalzGoalManager.has_goals{$&U4;+=AU+UUr-c|j}| |jdvrdS|jd|jd}|jr4dt |jdt |jdkrdnd nd }|jd krd ||d |jS|jd kr$|jr d|jnd }d|||d |jS|jdkrd||d |jSd|jd||d |jS)N>ruz*No active goal. Set one with /goal ./z turnsz, z subgoalrJr6r8ru⊙ Goal (active, ): ru — u⏸ Goal (paused, ru✓ Goal done (zGoal ()rrrrr#ryrr )r*r6turnssubextras r+ status_linezGoalManager.status_linesB K 9L00??<55!+555UVU_gQ3qz??QQ3qz??a3G3GCCRQQQeg 8x  ??s??qv?? ? 8x  12H-AO---bEFFsFEFFafFF F 8v   to add criteria))rr#rOr)s r+render_subgoalszGoalManager.render_subgoalsbs8 ; %%{# KJJ{00222r-)user_initiatedrrrZc l|j}| |jdkr|r|jndddddddS|xjdz c_tj|_t |j||jpd \}}}||_||_ |r|xj dz c_ nd |_ |d kr(d |_t|j |d ddd |d |dS|j tkr>d |_d|j d|_t|j |d ddd|d|j ddS|j|jkrNd |_d|jd|jd|_t|j |d ddd|d|jd|jddSt|j |dd|d|d|jd|jd|dS)uvRun 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. Decision keys: - ``status``: current goal status after update - ``should_continue``: bool — caller should fire another turn - ``continuation_prompt``: str or None - ``verdict``: "done" | "continue" | "skipped" | "inactive" - ``reason``: str - ``message``: user-visible one-liner to print/send NrFinactiverr8)rshould_continuecontinuation_promptrrrrJ)r#rru✓ Goal achieved: rz(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 (rru⏸ Goal paused — zD turns used. Use /goal resume to keep going, or /goal clear to stop.Tu↻ Continuing toward goal (r)rrrrrrrr#rrr!rsrW&DEFAULT_MAX_CONSECUTIVE_PARSE_FAILURESr rnext_continuation_prompt)r*rrrorrrs r+evaluate_after_turnzGoalManager.evaluate_after_turnls(  =ELH44*/9%,,T#('+%*   A!Y[[(2 J 0F$) ) ) %%"  1  , , 1 , , ,/0E , f  !EL dou - - - #('+! 999    +/U U U#ELl5;[lll   dou - - -"#('+% 5E<\555 $  u . .#EL"aErs:#"""""  0000000000''''''''33333333333333  8 $ $  $*+&P+ I" <), 3\3\3\3\3\3\3\ 3\v     <* > > > >!!!!,,,,"*Z33$$$$0....j+$( \)\)\)\)\)\)HTJTJTJTJTJTJTJTJn   r-